【漏洞利用】利用UBUNTUSHIFTFS驱动程序中的DOUBLEFREE漏洞(CVE-2021-3492)

$ sudo sysctl kernel.unprivileged_userns_clonekernel.unprivileged_userns_clone = 1

$ unshare -U -r # create a userns where uid 0 is mapped on current user$ unshare -m    # create a mount namespace$ mount -t tmpfs none [dir]

$ mkdir d1 d2$ unshare -U -r$ unshare -m$ mount -t tmpfs none d1$ mount -t shiftfs -o mark,passthrough=2 d1 d2

static long shiftfs_real_ioctl(struct file *file, unsigned int cmd, unsigned long arg){int newfd = -EBADF;long err = 0, ret = 0;void __user *argp = (void __user *)arg;struct btrfs_ioctl_vol_args *btrfs_v1 = NULL;struct btrfs_ioctl_vol_args_v2 *btrfs_v2 = NULL;
    ret = shiftfs_btrfs_ioctl_fd_replace(cmd, argp, &btrfs_v1, &btrfs_v2, &newfd);if (ret < 0)return ret;
// here wrapper to vfs_ioctl()// ...
    err = shiftfs_btrfs_ioctl_fd_restore(cmd, newfd, argp, btrfs_v1, btrfs_v2);if (!ret)        ret = err;
return ret;}

#define BTRFS_PATH_NAME_MAX 4087struct btrfs_ioctl_vol_args {    __s64 fd;char name[BTRFS_PATH_NAME_MAX + 1];};

如果在 shiftfs 管理的文件上执行此 ioctl，则处理代码会将结构 btrfs_ioctl_vol_args 从用户空间复制到内核空间。替换此结构中的 fd 字段后，将其复制回用户空间：

static int shiftfs_btrfs_ioctl_fd_replace(int cmd, void __user *arg,struct btrfs_ioctl_vol_args **b1,struct btrfs_ioctl_vol_args_v2 **b2,int *newfd){// ...
if (cmd == BTRFS_IOC_SNAP_CREATE) {        v1->fd = *newfd;        ret = copy_to_user(arg, v1, sizeof(*v1));        v1->fd = oldfd;    } else {// ...    }
if (ret)        shiftfs_btrfs_ioctl_fd_restore(cmd, *newfd, arg, v1, v2);
return ret;
}

该函数copy_to_user返回剩余字节数。如果在复制过程中发生故障，则返回正值。在调用函数中shiftfs_real_ioctl，通过检查返回值是否为负来检测错误。因此，即使发生错误，也会执行标称路径，导致shiftfs_btrfs_ioctl_fd_restore第二次调用。这个函数执行另一个copy_to_user将结构再次发送btrfs_ioctl_vol_args到用户空间然后释放它。

static int shiftfs_btrfs_ioctl_fd_restore(int cmd, int fd, void __user *arg,struct btrfs_ioctl_vol_args *v1,struct btrfs_ioctl_vol_args_v2 *v2){int ret;
if (!is_btrfs_snap_ioctl(cmd))return 0;
if (cmd == BTRFS_IOC_SNAP_CREATE)        ret = copy_to_user(arg, v1, sizeof(*v1));else        ret = copy_to_user(arg, v2, sizeof(*v2));
    __close_fd(current->files, fd);    kfree(v1);    kfree(v2);
return ret;}

只能同时设置v1或之一v2。两种结构都会导致相同的漏洞并具有相同的大小。调用两次shiftfs_btrfs_ioctl_fd_restore导致：

1. 关闭两次相同的 fd

2. 释放两次相同的结构

shiftfs_btrfs_ioctl_fd_replace在从用户空间复制期间已分配此结构：

v1 = memdup_user(arg, sizeof(*v1));

核函数同时memdup_user执行copy_from_user分配和分配。此分配使用带有 GFP_USER 标志的kmalloc，它使用与 GFP_KERNEL 相同的平板。

总而言之，当出现故障时copy_to_user：

虽然可以在此分配上触发双重释放，但也有可能忘记分配，从而永远失去此内存。实际上，如果 的值v1->fd针对当前进程中的无效文件描述符，则该函数返回负错误并且kfree永远不会执行。这个错误允许任何用户填满整个内核内存，直到系统内存不足。

同步用户空间和内核空间

双重释放允许通过在两次释放操作之间分配相同类型的内核内存块并在第二次释放后喷射受控对象来接管相同类型的内核内存块。所以需要以下元素：

• 一种在第一个空闲和第二个空闲之间阻塞内核的方法。

• 受害者：相同类型的内存块 (kmalloc-4096)，它可以提供漏洞利用原语，如内核内存读/写。

一种喷射技术，允许创建相同类型的内存块并用受控数据填充其内容。

Ubuntu 内核配置已经CONFIG_PREEMPT_VOLUNTARY设置。这意味着内核在执行内核代码时不会被调度程序抢占，除非代码自愿要求它。然而，有几种已知的技术允许在执行某些操作时阻塞内核。在我们的例子中，在第一个 free 和第二个 free 之间调用的几个函数可以被阻塞：

• vfs_ioctl在较低的 inode 上执行。使用带有 FUSE 的用户控制的文件系统可以阻止对文件的任何操作。

• copy_to_user在每次调用 kfree 之前执行。使用 userfaultfd 允许阻止操作。

• close_fd在每次调用 kfree 之前执行。此操作可以使内核在特殊条件下休眠。

该userfaultfd方法已在利用被使用。Ubuntu groovy (20.10) 的内核引入了一项新功能，允许用户空间程序根据写入错误管理其页面。虽然可以根据页面错误管理页面，但现在可以定义写保护页面并在执行写入时由内核调用。

它的用法很简单，漏洞利用创建了两个线程：一个在copy_to_user（内核模式）期间触发写入错误，而另一个处理此错误。在此处理期间（不受时间限制），第一个线程在 shiftfs 内核代码中并被阻塞，直到第二个线程选择解除阻塞的情况。

该漏洞利用分配了两页用户空间内存。使用在这两个页面中使用字节的结构调用易受攻击的 ioctl。通过将第一页设置为写保护，在copy_to_user. 在故障处理中，第二页被标记为写保护，而第一页被设置为可写。

此方法允许copy_to_user在同一结构上阻止内核执行的多个操作。copy_to_user在第一次释放之后进行的事实意味着，如果在受害者被分配（对于第一页）后 userfaultfd 回调解除内核阻塞，则受害者内容被复制到用户空间内存。

下图显示了漏洞利用所使用的内存映射和保护序列：

在同一个 SLAB 中寻找受害者

Linux 内核有几种分配内存的方法。大多数分配使用kmalloc由 SLUB 分配器管理。当驱动程序需要一块内存时，会根据请求的大小使用相应的缓存。例如，这个 bug 中使用的内存大小为 4096 ：SLUB 分配器将使用缓存kmalloc-4096。由于存在用于上的两个电源对齐尺寸缓存，这个高速缓存包含用于分配的大小的块2097 4096之间的高速缓存中含有的列表板坯的存储器几个连续块组成。当kfree被调用时，块被添加到free_list它的slab中。

要使用双重空闲来接管块，我们只需要确保以下几点：

• 第一个法线kfree是在已知的 CPU 上进行的

• 受害者被分配在相同的 CPU 上，使用kmalloc兼容的大小来使用相同的平板。因为每个 CPU 都有一个始终对应最新的slabkfree，所以返回的块与 1 中的相同。

• 第二辆马车kfree制作完成。

• 在同一 CPU 上进行另一次分配，大小相同，以控制受害者的新内容。

该漏洞利用在同一 CPU 上使用 执行所有这些操作sched_setaffinity，这对于非特权用户是允许的。为了防止其他内核分配的竞争，它们必须在一个小的时间窗口内进行。

但是如何找到合适的受害者呢？我们需要让内核在 2097 到 4096 字节之间分配一个块，这对于了解 KASLR 偏移和/或获得某种强大的原语（如任意写入或调节执行流程的方法）很有用。

我使用了两种方法来定位受害者：

• 我构建了一个合适对象的数据库。使用相同的源代码和相同的配置，构建了一个带有调试数据的vmlinux。然后，使用pahole，提取了所有内核结构名称和大小。由于内核通常分配结构大小的块，因此这是寻找受害者的好方法。

• 在运行时，可以使用内核跟踪器来显示内核所做的所有分配。通过过滤分配大小，可以通过生成系统活动（例如，启动浏览器……）来找到潜在的受害者。

事实证明，潜在的受害者并不多。希望我找到了一个有趣的，它也可以从非特权用户触发：devinet_sysctl_table。

static struct devinet_sysctl_table {struct ctl_table_header *sysctl_header;struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];} devinet_sysctl= {    .devinet_vars = {        DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",devinet_sysctl_forward),        DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),        DEVINET_SYSCTL_RW_ENTRY(BC_FORWARDING, "bc_forwarding"),// ...    }}

该漏洞利用的受害者是网络 sysctl 表之一。这些表是在启动时为主网络堆栈创建的。但是，网络命名空间使用专用的 sysctl 表。可以使用路径 /proc/sys/net/ 中的 procfs 文件系统读取和写入这些配置值。

创建新的网络命名空间时，分配的第一个 kmalloc-4096 块存储堆栈的 IPv4 通用 sysctl 表。该表由文件 net/ipv4/devinet.c 管理。分配的是全局表 devinet_sysctl_table 的副本。这可以在执行以下操作后使用内核跟踪器进行检查unshare -n：

bash-1912    [002] ....  5515.306551: kmalloc: call_site=__devinet_sysctl_register+0x47/0x110 ptr=00000000552c19f5 bytes_req=2120 bytes_alloc=4096 gfp_flags=GFP_KERNELbash-1912    [002] ....  5515.306595: kmalloc: call_site=__devinet_sysctl_register+0x47/0x110 ptr=000000007dd47f0d bytes_req=2120 bytes_alloc=4096 gfp_flags=GFP_KERNELbash-1912    [002] ....  5515.306742: kmalloc: call_site=mr_table_alloc+0x42/0x100 ptr=00000000598ab799 bytes_req=3608 bytes_alloc=4096 gfp_flags=GFP_KERNEL|__GFP_ZERObash-1912    [002] ....  5515.306766: kmalloc: call_site=ipv4_mib_init_net+0xf4/0x1a0 ptr=00000000d0d71277 bytes_req=4096 bytes_alloc=4096 gfp_flags=GFP_KERNEL|__GFP_ZERObash-1912    [002] ....  5515.306811: kmalloc: call_site=__register_sysctl_table+0x50/0x1e0 ptr=000000001ae330cc bytes_req=3216 bytes_alloc=4096 gfp_flags=GFP_KERNEL|__GFP_ZERObash-1912    [002] ....  5515.306922: kmalloc: call_site=ipv6_init_mibs+0xb2/0x110 ptr=00000000dd7d83c1 bytes_req=4096 bytes_alloc=4096 gfp_flags=GFP_KERNEL|__GFP_ZERO

创建网络命名空间会分配匹配相同块大小的其他块。当进行多次分配时，CPU Slab 可能会被新的 Slab 替换，从而丢失插入全局部分列表中的牺牲 Slab（包含未绑定到 CPU 的空闲块的 Slab）。为了取回这个slab，漏洞利用分配了比一个slab中的块数更多的块。在我们的例子中，一个slab包含8个块，为了取回受害者slab，最后分配了8个以上的块。

所选择的受害者非常有趣，因为它包含一个ctl_table定义如下的结构：

struct ctl_table {const char  *              procname;             /*     0   0x8 */void *                     data;                 /*   0x8   0x8 */int                        maxlen;               /*  0x10   0x4 */umode_t                    mode;                 /*  0x14   0x2 */struct ctl_table *         child;                /*  0x18   0x8 */        proc_handler *             proc_handler;         /*  0x20   0x8 */struct ctl_table_poll *    poll;                 /*  0x28   0x8 */void *                     extra1;               /*  0x30   0x8 */void *                     extra2;               /*  0x38   0x8 */};

该proc_handler字段是一个函数指针！通过泄漏其原始值，可以检索 KASLR 偏移量。对于网络 sysctl，第一个指针devinet_sysctl_forward用于通过从内核符号文件中减去其基地址来计算 KASLR 偏移量。

此外，sysctl 头地址在结构的开头泄漏。这是一个独特的分配和转储其内容允许检索受害者的地址。

使用的喷洒技术很简单：它使用了漏洞 (BTRFS_IOC_SNAP_CREATE) 的数倍相同的 ioctl。实际上，系统调用执行了 4096 字节的分配。通过在fd字段中设置无效的文件描述符，永远不会释放分配，这对于修复双重释放非常有用。对喷射内容的唯一限制是在第一个字节上，因为该字段fd由 shiftfs 代码修补。安装 R/W 原语后，受害者的初始内容的第一个字节将被恢复。

使用 sysctl 表稳定原语

sysctl 表中的条目由结构定义，ctl_table并被块重用和喷射技术覆盖。

内核读/写可以通过将指针数据设置到给定的目的地并使用该函数proc_doulongvec_minmax作为proc_handler. 当用户空间进程读取和写入 /proc/sys/net/ipv4/conf/all 中的文件时，此函数将在数据指向的内核内存中读取和写入任意数量的 64 位值。

该漏洞利用接管了几个 sysctl：

• sysctl0 : /proc/sys/net/ipv4/conf/all/forwarding: 用于转储 sysctl_header 并获取受害者的地址

• sysctl1 : /proc/sys/net/ipv4/conf/all/mc_forwarding: 此 sysctl 设置为覆盖主命名空间 (sys.debug.exception-trace) 中的全局 sysctl 以获得可重用的 R/W 原语。在受害者地址被泄露并写入 sysctl2 的内容后，全局 sysctl 表被恢复。

• sysctl2 : /proc/sys/net/ipv4/conf/all/bc_forwarding: 目标 sysctl3 并允许更改读/写的目的地（数据字段）。

• sysctl3 : /proc/sys/net/ipv4/conf/all/accept_redirects: 用于 R/W 内核内存，此表由 sysctl2 修补。

• sysctl4 : /proc/sys/net/ipv4/conf/all/secure_redirects: 用于调用函数，该表由 R/W 原语修补。

原语稳定后，漏洞利用程序可以通过读写/proc中的文件来读写内核内存。

内核代码执行和root权限

请注意，稳定的内核读/写足以获得用户级 root 访问权限。但是由于我们已经有了一个调用原语，我决定通过内核代码执行来实现。防止从内核执行用户态代码的主要内核保护是 SMAP。该保护可防止内核本身访问或执行专用功能（如copy_{from|to}_user.

不应同时存在具有写入和执行权限的映射。然而，遗留内核代码调用set_memory_x将受害者页面重新映射为可执行文件的函数。

要调用此函数，将 sysctl4 与修补的proc_handler. 当它被调用时，第一个参数是ctl_table. 将数据写入 sysctl 文件（在 /proc 中）时，第二个参数设置为 1。因此，在调用 时set_memory_x，第二个参数将为 1，即要重新映射为可执行文件的页数。由于它有 4096 字节长，受害者仅由一页组成，但表的地址在页开始时没有对齐。set_memory_x与未对齐的地址一起使用时，其页面仍会重新映射，但WARN_ON宏会在 dmesg 中显示警告。

使用这种技术，受害者内存被设置为可执行。一个 shellcode 被写入这个内存中，然后 sysctl4 被修补以调用这个有效载荷。shellcode 执行通常的代码来获取当前进程的 root 凭据：

commit_cred(prepare_kernel_cred(0));

最后，漏洞利用会产生一个新的 shell。

结论

在搜索本地权限提升漏洞时，我发现了很多我不知道的功能，并学习了几种利用技术（userfaultfd、spray 技术、块重用等）。我很幸运在我审核的第一批司机中找到了一些东西。

double free 漏洞非常危险，因为它们通常仅使用一个 bug 即可被利用。正如所呈现的错误所见，它在提供块重用的同时提供信息泄漏。即使没有这个信息泄露，劫持一个已知的内核对象也可能就足够了。

这些sysctl表是非常有趣的利用目标。对全局结构（如果 KALSR 偏移被解析，则地址是已知的）的单次写入允许获得可重用的 R/W 原语。使用这些原语，可以通过各种方式获得根权限。

如果您不使用非特权容器，我建议设置kernel.unprivileged_userns_clone为 0 以减少攻击面。

这是我第一次参加 Pwn2Own。我要感谢 ZDI 组织 Pwn2Own 和 Ubuntu 内核团队的参与和他们修复错误的反应。

资源

Ubuntu 修复：

https://ubuntu.com/security/CVE-2021-3492

其他关于内核开发的博文：

CVE-2017-11176：

• https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html

• https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part2.html

• https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html

• 关于 Userfaultfd：https ://blog.lizzie.io/using-userfaultfd.html

• 关于 Userfaultfd 和 Sprays：https ://duasynt.com/blog/linux-kernel-heap-spray

CVE-2017-7308：

• https://googleprojectzero.blogspot.com/2017/05/exploiting-linux-kernel-via-packet.html

• https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-7308

本文始发于微信公众号（Ots安全）：【漏洞利用】利用 UBUNTU SHIFTFS 驱动程序中的 DOUBLE FREE 漏洞 (CVE-2021-3492)