/* size: 136, cachelines: 3, members: 14 */
    /* forced alignments: 1 */
    /* last cacheline: 8 bytes */

随后，当内核遇到缺页异常或其他与内存相关的系统调用时，需要仅根据地址快速查找VMA。以前，VMA 是通过红黑树管理的。但从 Linux 内核 6.1 版本开始，逐渐迁移到了枫树（maple trees）。[枫树][mt] 是一种 RCU 安全的 B 树数据结构，针对存储非重叠区间进行了优化。尽管如此，其复杂的结构增加了代码库的复杂性，并引入了 StackRot 漏洞。

 [mt]: https://docs.kernel.org/6.4/core-api/maple_tree.html

从本质上看，枫树由枫树节点组成。虽然树的结构可能很复杂，但需要注意的是，这种复杂性与 StackRot 漏洞无关。因此，在本文中，我们假设枫树只包含一个节点，即根节点。

这个根节点最多可以包含 16 个区间。这些区间要么表示一段间隙，要么指向一个 VMA。由于间隙也算作区间，所有区间是连续连接的，因此节点结构中只需要 15 个端点（也称为枢轴）。请注意，最左端点和最右端点被省略了，因为它们可以从父节点中获取。```c
struct maple_range_64 {
        struct maple_pnode *       parent;               /*     0     8 */
        long unsigned int          pivot[15];            /*     8   120 */
        /* --- cacheline 2 boundary (128 bytes) --- */
        union {
                void *             slot[16];             /*   128   128 */
                struct {
                        void *     pad[15];              /*   128   120 */
                        /* --- cacheline 3 boundary (192 bytes) was 56 bytes ago --- */
                        struct maple_metadata meta;      /*   248     2 */
                };                                       /*   128   128 */
        };                                               /*   128   128 */

        /* size: 256, cachelines: 4, members: 3 */
};

关于并发修改，maple树施加了一项特定限制，即写入者必须持有排他锁（*规则W*）。对于VMA树而言，此排他锁对应MM写锁。至于读取者，有两种选择。第一种选择是持有MM读锁（*规则A1*），这将导致写入者被MM读写锁阻塞。另一种选择是进入RCU临界区（*规则A2*）。通过这样做，写入者不会被阻塞，且读取者可以继续其操作，因为maple树是RCU安全的。虽然大多数现有的VMA访问采用第一种选择（即规则A1），但规则A2在一些性能关键场景中使用，例如无锁页错误。

然而，还有一个需要特别关注的方面，涉及栈扩展。栈代表一个使用MAP_GROWSDOWN标志映射的内存区域，表明当访问该区域下方的地址时会自动扩展。在这种情况下，相应VMA的起始地址以及maple树中关联的区间会被调整。值得注意的是，这些调整是在未持有MM写锁的情况下进行的。```c
static inline
void do_user_addr_fault(struct pt_regs *regs,
                        unsigned long error_code,
                        unsigned long address)
{
	// ...

	if (unlikely(!mmap_read_trylock(mm))) {
		// ...
	}
	// ...
	if (unlikely(expand_stack(vma, address))) {
		// ...
	}

	// ...
}

if (prev) {
	if (!(prev->vm_flags & VM_GROWSDOWN) &&
	    vma_is_accessible(prev) &&
	    (address - prev->vm_end < stack_guard_gap))
		return -ENOMEM;
}

// ...

因此，栈扩展可以消除间隙。在这种情况下，必须移除枫树节点内的间隙区间。由于枫树是RCU安全的，无法在原地覆盖节点。相反，会创建一个新节点，触发节点替换，旧节点随后通过RCU回调销毁。```c
static inline void mas_wr_modify(struct ma_wr_state *wr_mas)
{
	// ...

	if ((wr_mas->offset_end - mas->offset <= 1) &&
	    mas_wr_slot_store(wr_mas))           // <-- in-place update
		return;
	else if (mas_wr_node_store(wr_mas))      // <-- node replacement
		return;

	// ...
}

## 修复

我于6月15日向Linux内核安全团队报告了此漏洞。随后，由Linus Torvalds主导了修复该Bug的流程。由于漏洞复杂性较高，团队花费了近两周时间才达成共识，形成了一套补丁集。

6月28日，在Linux内核6.5版本的合并窗口期间，修复补丁被合并到Linus的代码树中。Linus提供了一份[详尽的合并信息][fix]，从技术角度阐明了补丁系列。

 [fix]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9471f1f2f50282b9e8f59198ec6bb738b4ccc009

这些补丁随后被反向移植到稳定版内核（[6.1.37][6.1]、[6.3.11][6.3]和[6.4.1][6.4]），并于7月1日有效解决了“Stack Rot”漏洞。

 [6.1]: https://lore.kernel.org/stable/2023070133-create-stainless-9a8c@gregkh/T/
 [6.3]: https://lore.kernel.org/stable/2023070146-endearing-bounding-d21a@gregkh/T/
 [6.4]: https://lore.kernel.org/stable/2023070140-eldercare-landlord-133c@gregkh/T/

## 漏洞利用

该漏洞利用主要针对Google kCTF挑战赛，具体场景为未设置`CONFIG_PREEMPT`和`CONFIG_SLAB_MERGE_DEFAULT`的情况。要利用StackRot，最关键的任务是找到一个满足以下条件的VMA迭代：
 1. 迭代的时机可被控制。这种控制能力使我们能够确保RCU宽限期在VMA迭代期间结束。
 2. 迭代从VMA结构中获取特定信息，并将这些信息返回给用户空间。这一特性使我们能够利用maple节点的UAF漏洞来泄露一些内核地址。
 3. 迭代调用VMA结构中的某些函数指针。这一特定能力使我们能够通过maple节点的UAF来控制内核模式程序计数器（PC）。

选定的VMA迭代是负责生成`/proc/[pid]/maps`内容的迭代。以下小节将展示该迭代如何满足上述条件。

### 第0步：从UAFBR到UAF

在任何VMA迭代过程中，都会获取对VMA树根节点的引用，并遍历其槽位。因此，通过在VMA迭代期间在另一个CPU上触发其他线程的栈扩展，可以同时启动节点替换。此时，访问旧节点被视为一种通过RCU的释放后使用（UAFBR）情况。然而，只有当旧节点在RCU回调中真正被释放时，实际问题才会出现。

这带来了两个挑战：（i）确定旧节点何时被释放，以及（ii）确保在旧节点被释放之前VMA迭代不会完成。

第一个问题相对简单。在内核中，可以使用`synchronize_rcu()`函数等待RCU宽限期结束，从而确保所有预先存在的RCU回调都已被调用。在用户空间，可以调用最终调用`synchronize_rcu()`的系统调用来达到相同目的。因此，当此类系统调用结束时，即可得知旧节点已被释放。值得注意的是，有一个系统调用`membarrier(MEMBARRIER_CMD_GLOBAL, 0, -1)`仅用于调用`synchronize_rcu()`。```c
SYSCALL_DEFINE3(membarrier, int, cmd, unsigned int, flags, int, cpu_id)
{
	// ...

	switch (cmd) {
	// ...
	case MEMBARRIER_CMD_GLOBAL:
		/* MEMBARRIER_CMD_GLOBAL is not compatible with nohz_full. */
		if (tick_nohz_full_enabled())
			return -EINVAL;
		if (num_online_cpus() > 1)
			synchronize_rcu();
		return 0;
	// ...
	}
}

/*
 * Print the dentry name for named mappings, and a
 * special [heap] marker for the heap:
 */
if (file) {
	seq_pad(m, ' ');
	/*
	 * If user named this anon shared memory via
	 * prctl(PR_SET_VMA ..., use the provided name.
	 */
	if (anon_name)
		seq_printf(m, "[anon_shmem:%s]", anon_name->name);
	else
		seq_file_path(m, file, "\n");
	goto done;
}

// ...

此步骤如下图所示：

![步骤 0: 从 UAFBR 到 UAF](https://assets.kitploit.com/production/public/readmes/28620/6791d2c105f1fc504247b668317c7d23c3141c92456dab2fb2e54f7f70e16e15.png)

### 步骤 1: 从 slab UAF 到 page UAF

现在，UAF 在 slab 内发挥作用。如果启用了 `CONFIG_SLAB_MERGE_DEFAULT`，并且 maple 节点的 slab 与 kmalloc-256 合并，则可以通过从 kmalloc-256 分配一个新结构并用用户空间数据填充它，来控制旧节点内的内容。但是，如果没有设置 `CONFIG_SLAB_MERGE_DEFAULT`，则需要采用替代方法。在这种情况下，需要将释放节点的页面返回给页面分配器，从而允许通过分配新页面并相应填充它来控制旧节点。

回想一下，VMA 树只包含一个节点。因此，通过使用 `fork()`/`clone()`，会生成多个 VMA 树和相同数量的 maple 节点。假设一个 slab 包含 M 个 maple 节点，并且每 M 个节点中保留一个节点，而所有其他节点通过 `exit()` 释放，则剩余的节点成为其各自 slab 中的唯一节点。最初，这些 slab 位于 CPU 的部分列表中。当部分列表达到其容量时，这些 slab 会被刷新回相应 NUMA 节点的部分列表。

如果 slab 中的最后一个 maple 节点被释放，则该 slab 变为空。如果此 slab 位于 NUMA 节点的部分列表中，并且该特定 NUMA 节点的部分列表已经达到最大容量，则该页面会立即返回给页面分配器。因此，slab UAF 转变为页面 UAF 场景。可以通过 `msgsnd()` 发送一些数据来操纵释放页面内的内容，这会分配弹性对象并直接用提供的用户数据填充它们。```c
static void __slab_free(struct kmem_cache *s, struct slab *slab,
			void *head, void *tail, int cnt,
			unsigned long addr)

{
	// ...

	if (unlikely(!new.inuse && n->nr_partial >= s->min_partial))
		goto slab_empty;

	// ...
	return;

slab_empty:
	// ...
	discard_slab(s, slab);
}

if (vma->vm_ops && vma->vm_ops->name) {
	name = vma->vm_ops->name(vma);
	if (name)
		goto done;
}

// ...

![Step 3: From UAF to root privileges](https://assets.kitploit.com/production/public/readmes/28620/d9c03475803bb799f2b594935d118d73f2547ea4dcf5b40c54e1454324575a0f.png)

gadget 构建如下：
 1. 栈迁移：`movq %rbx, %rsi; movq %rbp, %rdi; call __x86_indirect_thunk_r13` -> `pushq %rsi; jmp 46(%rsi)` -> `popq %rsp; ret` -> `popq %rsp; ret`，其中 %rdi、%rbx 和 %r13 *初始*指向用户可控数据。
 2. 获取 root 权限：`popq %rdi; ret` -> `prepare_kernel_cred` -> `popq %rdi; ret` -> `movq %rax, (%rdi); ret`，此时 %rdi *指向*栈顶；`popq %rdi; ret` -> `commit_creds`，实际执行 `commit_creds(prepare_kernel_cred(&init_task))`。
 3. 逃逸容器：`popq %rdi; ret` -> `find_task_by_vpid` -> `popq %rdi; ret` -> `movq %rax, (%rdi); ret`，此时 %rdi *指向*栈顶；`popq %rdi; ret` -> `popq %rsi; ret` -> `switch_task_namespaces`，实际执行 `switch_task_namespaces(find_task_by_vpid(1), &init_nsproxy)`。
 4. 解锁 mm：`popq %rax; ret` -> `movq %rbp, %rdi; call __x86_indirect_thunk_rax`，其中 %rbp 指向原始 seq_file；`popq %rax; ret` -> `m_stop`，实际执行 `m_stop(seq_file, ..)`。
 5. 返回用户空间：使用 `swapgs_restore_regs_and_return_to_usermode`，并调用 `execve()` 获取 shell。

最后，使用 `nsenter --mount=/proc/1/ns/mnt` 恢复挂载命名空间，并通过 `cat /flag/flag` 获取 flag。

### 源代码

完整漏洞利用源码位于[此处](https://github.com/lrh2000/stackrot/blob/HEAD/exp)。更多细节请参阅其 README 文件。