什么是内核 UAF、OOB、Use-After-Free?内核漏洞和用户态漏洞的区别

本文系统剖析Linux内核中两类高危内存漏洞:Use-After-Free(UAF)和Out-of-Bounds(OOB)。详细阐述其成因、触发机制、典型场景(如引用计数错误、异步工作队列、ioctl多路径)、SLUB分配器行为影响,以及KASAN检测原理。重点对比内核与用户态漏洞在权限模型(Ring0 vs Ring3)、内存分配器(SLUB vs ptmalloc)、防护机制(SMEP/SMAP/CFI/KASLR)及利用路径上的本质差异,并指出对象复用、类型混淆、堆布局控制等核心攻防要点。

前言

在内核安全学习的初期,绝大多数人最先接触到的两类高频漏洞就是 UAF(Use-After-Free,释放后使用) 和 OOB(Out-of-Bounds,越界访问)。很多初学者会把用户态堆溢出、UAF 的经验直接套到内核漏洞上,结果发现处处碰壁:同样是 UAF,用户态 UAF 利用起来相对直观,内核 UAF 却要面对 SLUB 分配器、KASLR、SMEP/SMAP、CFI 一大堆保护;同样是 OOB,用户态溢出一般是篡改栈返回地址或者堆 chunk 元数据,内核 OOB 一不小心就直接触发内核 panic,很难稳定利用。

还有很多人分不清概念:UAF 就是 Use-After-Free,二者是同一个东西,OOB 分为 OOB Read(越界读)和 OOB Write(越界写),它们是两类成因完全不同,但经常组合在一起使用的内核漏洞。同时,很多学习者会产生疑问:内核漏洞和用户态漏洞到底差在哪?为什么内核漏洞价值更高、利用门槛更高?内核漏洞提权的本质逻辑和用户态漏洞有什么异同?

本文会从基础概念入手,先把 UAF、OOB 的定义、底层成因、触发场景、危害、简单示例讲清楚,再横向对比内核漏洞与用户态漏洞在内存模型、权限、分配器、防护机制、利用目标、风险后果上的巨大差异。同时结合 SLUB 分配器的基础行为,解释为什么内核 UAF/OOB 的利用逻辑和用户态 glibc ptmalloc 堆漏洞完全不一样,附带简单代码示例、漏洞触发场景、漏洞检测方式、常见的利用前置条件,以及对应的缓解加固方案。适合刚入门内核安全、之前学过用户态 PWN,准备转向内核漏洞分析的读者阅读。

免责声明:本文所有内容仅用于授权环境下的安全学习、漏洞分析、安全加固,禁止在未授权系统中进行漏洞测试与攻击。

一、基础概念梳理:先分清 UAF、Use-After-Free、OOB

很多新手第一眼看到标题会疑惑:UAF 和 Use-After-Free 难道不是同一个东西?没错,UAF 就是 Use-After-Free 的缩写。

  • Use-After-Free:全称,中文标准叫法:释放后使用;
  • UAF:简写,安全圈通用缩写;
  • OOB:Out-of-Bounds,越界访问,分为越界读 OOB Read 和越界写 OOB Write。

这两类是 Linux 内核中上报数量最多、CVE 产出最高的内存破坏类漏洞,除此之外还有 Double Free(双重释放)、整数溢出、空指针解引用、类型混淆等漏洞,而 UAF 和 OOB 是所有内核内存漏洞里最核心、最常被拿来做提权利用的类型。

1.1 什么是 Use-After-Free(UAF / 释放后使用)

一句话定义:一块堆内存已经调用释放函数还给分配器之后,程序代码仍然保留这块内存的指针,后续继续读写这个已经被释放的内存地址,就叫做 UAF,释放后使用。

放在内核语境下:内核调用 kfree() 释放一个通过 kmalloc() 或者 kmem_cache_alloc() 分配出来的 slab 对象,对象被放回 SLUB 的 freelist 空闲链表;但是内核代码里,还存在一个指向这块内存的野指针,后续代码流程继续通过这个指针去读、写这块内存,触发 UAF。

我们先看一段简化的伪代码,方便理解:

// 内核伪代码,仅演示UAF成因
struct test_obj {
    char buf[0x20];
    void (*func_ptr)(void);
};

struct test_obj *p;

p = kmalloc(sizeof(struct test_obj), GFP_KERNEL); // 分配对象
kfree(p); // 释放对象,内存还给SLUB freelist

// 漏洞:释放之后,没有把p置NULL,后续继续使用p指针
p->func_ptr(); 

上面这段代码就是最经典的 UAF 模型。当 kfree(p) 执行完成之后,这个对象就进入空闲链表,SLUB 随时可以把这块内存重新分配给其他内核对象。
此时指针 p 本身没有被置空,它依旧保存原来的内存地址。后续调用 p->func_ptr() 的时候,就会访问这块已经释放的内存。

UAF 的两种危害分支:

  1. 信息泄露(读类 UAF):释放之后,读取这块内存。如果这块内存还没有被重新分配覆盖,我们读到的是旧对象残留数据;如果已经被分配给其他对象,就可以读取其他内核对象里面的敏感数据,比如内核指针,用来绕过 KASLR。
  2. 可控篡改(写类 UAF):释放之后,向这块内存写入数据。如果我们可以在释放之后、写操作之前,主动触发分配,让这块内存分配到我们可控的对象,就可以改写目标对象里面的函数指针、权限结构体字段,最终实现控制流劫持或者权限篡改(修改 cred 结构体 uid=0 提权)。

这里有一个非常关键的认知:UAF 漏洞本身不会直接提权,UAF 只是提供了一条 “访问已经释放内存” 的通道。能不能利用,核心取决于释放之后这块内存能不能被我们可控的对象复用,也就是对象复用(Object Reuse)。 这也是内核 UAF 和用户态 UAF 最大的分水岭之一:用户态 ptmalloc 的 chunk 复用行为相对可控,内核 SLUB 分配器有 per-cpu cache、freelist 随机化、slab 隔离,对象复用难度远高于用户态。

1.2 什么是 OOB(Out-of-Bounds,越界访问)

OOB,越界访问,指访问内存的时候,访问的地址超出了这块内存对象合法的边界范围。OOB 分为两大类:OOB Read(越界读)、OOB Write(越界写)。

  • OOB Read:读取的范围超过缓冲区合法大小;
  • OOB Write:写入的数据长度超过缓冲区合法大小,也就是我们常说的堆溢出、缓冲区溢出。

同样给一段简化内核伪代码:

struct test_obj {
    char buf[0x20]; // 合法缓冲区大小 32字节
    unsigned long val;
};
struct test_obj *p = kmalloc(sizeof(struct test_obj), GFP_KERNEL);

// 漏洞:拷贝0x40字节数据,超过buf 0x20的边界,越界写
memcpy(p->buf, user_buf, 0x40);

这个例子中,buf 只有 0x20 字节,但是 memcpy 拷贝了 0x40 字节,超出边界,属于典型 OOB Write。
在内核 SLUB 的场景下,同一个 slab 里面的 object 是紧密连续排布的。p 对象后面紧挨着下一个相邻 object,OOB Write 会直接污染相邻 object 的内存内容。OOB Read 则可以读取相邻对象里面的内核指针,用来泄露地址,绕过 KASLR。

OOB 的核心特点:

  1. OOB 依赖内存布局,能不能溢出到目标对象,取决于目标对象是不是刚好排布在相邻位置,也就是堆布局、堆喷射;
  2. OOB Write 是非常强力的原语,一旦可以稳定控制溢出内容和溢出长度,很容易篡改相邻对象里面的函数指针、cred 权限字段;
  3. OOB Read 最主要的价值就是信息泄露,是绝大多数内核利用链的前置环节,没有泄露拿到内核基址,后续 ROP 无法执行;
  4. OOB 不一定是堆上的,内核栈上的越界访问,属于栈 OOB,也就是栈溢出,栈溢出在内核里有 Stack Canary 保护,现在越来越少见。

很多初学者会混淆:UAF 和 OOB 是不是一回事?
明确区分:

  • UAF:对象本身是完整合法边界,只是对象已经被释放,指针是野指针;
  • OOB:对象本身没有被释放,指针是合法的,但是读写范围超出了对象本身的边界;
    二者成因完全独立,但是真实漏洞利用链中经常搭配使用:OOB Read 泄露 canary / 内核地址,UAF 做对象复用篡改敏感结构体。

1.3 补充:Double Free(双重释放),经常和 UAF 一起出现

Double Free,同一个内存对象,连续两次调用释放函数。
内核场景:对同一个 slab object 执行两次 kfree。

p = kmalloc(0x20, GFP_KERNEL);
kfree(p);
kfree(p); // double free

在老式 SLUB 没有开启 freelist hardening 的环境下,double free 会让同一个 object 两次插入 freelist,空闲链表出现环路,攻击者可以两次分配拿到同一个对象,制造类型混淆。现代内核开启 freelist 校验之后,简单 double free 会直接触发 panic,利用难度大幅提升。很多 double free 漏洞,后续利用的底层思路依然依托于 UAF 的对象复用思想。

二、内核 UAF 详细拆解:触发条件、典型场景、内存行为

理解 UAF,不能只看代码,必须结合前面文章讲过的 SLUB 分配器行为,这是内核 UAF 的根基。

2.1 内核 kmalloc /kfree 和 SLUB freelist 行为回顾

当我们调用 kmalloc,SLUB 优先从当前 CPU 的 per-cpu freelist 取出空闲 object;调用 kfree,object 放回 freelist,标记为空闲。
重点:kfree 并不会清空这块内存里面原有数据,也不会立刻把页面归还伙伴系统。内存里面原来的值会保留,直到这个 object 被下一次分配拿走去覆盖。这就是 UAF 能够读取残留数据的根本原因。

很多初学者会有一个误区:kfree 之后,内存就消失了。不是的,kfree 仅仅是修改 freelist 链表元数据,标记这个位置空闲,内存内容保留。

UAF 完整时间线:

  1. 分配:obj = kmalloc(size, GFP_KERNEL),从 freelist 取出空闲对象,内核拿到对象指针;
  2. 使用:内核读写 obj 里面的数据,正常业务逻辑;
  3. 释放:kfree(obj),对象放回 freelist,指针变量没有置 NULL;
  4. 漏洞触发:后续代码再次通过旧指针访问 obj(读或者写);
  5. 分支 A:对象还没有被重新分配,内存残留旧数据,读 UAF,信息泄露;
  6. 分支 B:在释放之后、漏洞访问之前,我们主动触发分配,这块内存被分配成另外一种类型对象;
  7. 分支 C:漏洞写操作,改写新对象内容,触发类型混淆。

类型混淆(Type Confusion)是内核 UAF 利用的核心:同一块内存,先后被两种不同结构体类型使用。旧代码按照结构体 A 解析这块内存,但是内存里面实际存放的是结构体 B,结构体字段错位,攻击者借此篡改关键字段。

2.2 内核中 UAF 的典型真实业务场景

内核代码量大、模块繁多,UAF 经常出现在引用计数、回调函数、异步工作队列、netfilter、文件系统、socket、ioctl 处理流程中,下面是高频场景:

场景 1:引用计数管理错误(最高发)

内核大量结构体依靠 refcount 引用计数管理生命周期:引用计数减到 0 的时候,执行 kfree 释放。
如果存在一条代码路径,在 refcount 没有正确增加的情况下,依然持有指针;或者 refcount 递减多减一次,提前释放对象,但是其他代码路径还持有指针继续访问,形成 UAF。
Linux 内核很多经典 CVE,比如 netfilter、nf_tables 的 UAF,绝大多数都是 refcount 管理不当。

场景 2:异步工作队列、延迟工作

内核 work_struct、delayed_work,把一个任务交给内核工作队列异步执行。
主线程直接 kfree 了承载 work 的对象,但是 work 还没有执行,后续内核工作线程回调访问已经释放的对象,触发 UAF。
这一类 UAF 很难复现,存在竞态条件(Race Condition),需要精确控制时序,属于竞态 UAF。

场景 3:ioctl 多路径、用户态多次调用

驱动、文件系统提供 ioctl 接口,用户态可以下发命令。不同的 ioctl 命令走不同代码分支,如果分支之间生命周期管理不一致:一条分支释放对象,另外一条分支还可以继续操作对象指针,触发 UAF。大量设备驱动漏洞都属于这类。

场景 4:回调函数、事件通知链

内核注册回调函数,把对象指针传给回调上下文。对象提前释放,后续事件触发回调的时候,访问已经释放的指针,触发 UAF。

2.3 内核 UAF 的两种利用路线

路线 1:信息泄露路线(读 UAF)
释放对象之后,读取残留数据,拿到内核内部指针,用来绕过 KASLR。很多时候单独的读 UAF 不能直接提权,但是是利用链的前置组件。

路线 2:对象复用 + 类型混淆(写 UAF,提权主流路线)
经典提权模型:cred 对象 UAF。

  1. 创建进程,拿到 cred 对象,refcount 下降,cred 被 kfree,进入 freelist;
  2. 我们主动调用系统调用,分配可控内容的内核对象(msg_msg、setxattr 等),抢占这块刚刚释放的内存;
  3. 此时原来 cred 的内存位置,被我们可控的数据覆盖;
  4. 触发 UAF,内核按照 cred 结构体解析这块我们控制的内存,修改 uid、gid 为 0,完成提权。

这条路线就是内核安全圈子常说的:UAF 喷 cred。但是现代内核开启 SLUB 缓存隔离、CONFIG_SLAB_BUCKETS,cred 放在独立专用 cache,普通 kmalloc 对象无法复用 cred 的缓存,这条经典路线已经很难直接使用。这也是保护机制抬高利用门槛的典型体现。

2.4 KASAN 如何捕获 UAF

KASAN(内核地址消毒器)是检测 UAF、OOB 最主流工具。当开启 KASAN,kfree 的对象会被标记为红色隔离区,一旦访问标记为释放的内存,KASAN 直接打印堆栈、报错,终止程序。开发测试环境,开启 KASAN 是发现 UAF 漏洞最有效的手段。

三、内核 OOB 详细拆解:堆 OOB、栈 OOB、读写差异、布局依赖

OOB 分为堆越界(SLUB object 越界)和栈越界(内核栈缓冲区溢出)。栈 OOB 现在有 Stack Canary 防护,利用难度极高;红队、漏洞研究者重点关注的是 SLUB 堆 OOB。

3.1 堆 OOB Write 原理

同一个 slab 里面,多个 object 连续紧密排布,没有自动隔离(默认无隔离,除非开启 KASAN redzone)。

[ object A ][ object B ][ object C ]

A 的合法边界结束之后,紧接着就是 B 的内存。A 发生 OOB Write,溢出的数据直接写入 B 的内存空间。
攻击者的目标:通过堆喷射、分配释放顺序控制布局,让 B 是一个敏感对象(包含函数指针、cred 权限字段),然后通过 A 的越界写篡改 B 的字段。

这里有一个重点:OOB Write 的威力,高度依赖内存布局可控性。
如果 SLUB 开启 freelist randomization,空闲对象顺序随机打乱,攻击者很难稳定让敏感对象落在溢出相邻位置,OOB 利用稳定性急剧下降。这也是现代 SLUB 硬化对 OOB 的缓解。

3.2 OOB Read 的价值

OOB Read 是信息泄露原语,用来读取相邻对象内部的内核虚拟地址指针。内核开启 KASLR,所有 gadget、函数地址都是随机的,攻击者没有地址就无法构造 ROP。OOB Read 拿到任意一个内核指针,减去固定偏移,就可以算出内核 text 段基址,KASLR 失效。
绝大多数稳定内核利用链,第一步都是 OOB Read 泄露地址。

3.3 栈 OOB(内核栈溢出)

内核栈大小很小,通常 8KB,栈溢出就是在栈缓冲区写入过长数据,覆盖栈上的返回地址。
用户态栈溢出经典利用是覆盖返回地址,跳转 shellcode;但是内核栈有 Stack Canary,溢出会先覆盖 canary,函数返回的时候校验失败,直接 panic。
栈溢出漏洞现在在内核中已经非常稀少,就算找到,绕过 canary 也需要配套信息泄露漏洞,所以现在内核提权漏洞主体基本都是堆类漏洞:UAF、堆 OOB。

3.4 OOB 的限制和坑

  1. 溢出长度不可控:很多 OOB 漏洞溢出长度固定,只能改后面几个字节,很难完整篡改一个 8 字节函数指针;
  2. 溢出方向:向前溢出(低地址方向)、向后溢出(高地址方向),只有向后溢出更容易命中相邻 object;
  3. 容易触发 panic:溢出内容破坏无关元数据,直接触发内核 oops,很难稳定复现;
  4. KASAN redzone:KASAN 在 object 之间插入红区哨兵,一旦越界读写直接捕获。

四、核心对比:内核漏洞 VS 用户态漏洞

这是本文最重要的章节,很多学过用户态 PWN 的学习者最大的误区,就是把 ptmalloc 堆的经验直接平移到 SLUB 内核堆,我们从内存模型、权限模型、分配器、防护机制、利用目标、后果、调试方式,全方位对比。

4.1 权限模型:最本质的区别

用户态漏洞:程序运行在 Ring3,普通用户权限。就算拿到 shell,也只是这个进程对应的用户权限,最多拿到当前账号权限,除非再寻找本地提权漏洞。
内核漏洞:内核代码运行在 Ring0,最高权限。只要成功控制内核执行流,默认拥有整个机器最高权限,直接 root。

一句话:用户态漏洞 = 拿到当前进程权限;内核漏洞 = 直接拿到整机最高权限。
这就是内核漏洞 CVE 评级普遍高危、严重,奖金更高的根本原因。

4.2 内存分配器完全不一样

用户态 Linux 程序默认使用 glibc ptmalloc2 /ptmalloc3;内核使用 SLUB(老版本 SLAB、SLOB)。
ptmalloc 和 SLUB 设计目标完全不同:

  • ptmalloc:面向通用用户态程序,支持任意大小 malloc,chunk 元数据放在 chunk 头部,有 bins、unsorted bin、tcache;
  • SLUB:面向内核固定类型对象,优先按固定 size slab 缓存,元数据不在 object 内部,元数据保存在 slab page 结构体,freelist 管理空闲对象,per-cpu 缓存优先无锁分配。

带来巨大差异:

  1. 用户态 tcache double free、tcache poisoning 等利用手法在内核 SLUB 不存在;
  2. ptmalloc 的 chunk header 篡改思路不能直接套 SLUB;
  3. SLUB 有 freelist randomization、freelist hardening、kmalloc cache 隔离等原生安全硬化,ptmalloc 的安全加固相对弱很多;
  4. SLUB 大量专用 kmem_cache(cred、file、task_struct),不同结构体分属独立缓存,跨类型复用门槛高;ptmalloc 所有大小相近 chunk 在同一个 bin,复用简单。

很多用户态熟练的 pwn 选手,刚接触内核 UAF 的时候非常不适应:用户态随便堆喷就能分配到目标 chunk,内核堆喷经常失败,就是因为缓存隔离机制。

4.3 地址空间与防护机制对比

用户态防护:ASLR、NX、Stack Canary、RELRO、SHSTK;
内核防护:KASLR、KPTI、SMEP、SMAP、CFI、Stack Canary、SLUB 硬化、KASAN、init_on_alloc。

额外多出的内核专属防护:

  • SMEP:Ring0 不能执行 Ring3 页面代码,直接废掉传统用户态思路:内核跳用户 shellcode;内核只能使用内核 ROP;
  • SMAP:Ring0 不能直接读写用户态内存;
  • KPTI:页表隔离,缓解 Meltdown 侧信道;
  • SLUB 层硬化:freelist 加密、随机化、缓存隔离。

用户态漏洞可以写 shellcode 放在 bss 堆上,劫持执行流直接执行;内核漏洞几乎全部只能走 ROP/JOP,利用复杂度上升一个量级。

4.4 利用目标差异

用户态漏洞利用目标:劫持程序控制流,执行用户 shellcode,拿到进程 shell;
内核漏洞利用目标,两条主流路线:
路线 A:篡改敏感内核结构体(cred),修改 uid=0,直接提权,不需要复杂 ROP;
路线 B:劫持函数指针,构造 ROP 链,执行内核内部函数(commit_creds (prepare_kernel_cred (0)))完成提权。

也就是说,内核漏洞有一条特殊路线:数据篡改提权,不一定必须劫持指令流,只要能改写 cred 结构体字段,就可以提权。这是用户态漏洞很少有的思路。

4.5 调试与复现难度差异

用户态 pwn:gdb 直接 attach 进程,断点、查看内存、修改内存,调试非常方便;
内核漏洞调试:

  • 需要搭建虚拟机调试环境,开启 kvm + gdb + kgdb;
  • 一旦漏洞触发失败,大概率直接内核 panic、虚拟机卡死重启;
  • 内存状态随调度、CPU per-cpu 缓存动态变化,堆布局不稳定,竞态漏洞复现概率极低;
  • 内核符号、KASLR 导致内存地址每次启动变化;
  • 很多漏洞依赖特定内核版本、特定编译配置,换一个发行版内核版本直接失效。

4.6 漏洞影响范围与稳定性

用户态漏洞:大多只影响单个应用程序;
内核漏洞:内核是操作系统基础,一旦存在漏洞,本机所有用户、所有容器都受影响。容器逃逸漏洞很多依托内核漏洞,容器里面无权限用户,通过内核漏洞突破容器命名空间、cgroup 限制,拿到宿主机 root 权限,这是云安全里最危险的场景。

4.7 表格汇总对比

对比项用户态内存漏洞内核内存漏洞(UAF/OOB)
运行权限Ring3,进程权限Ring0,系统最高权限
分配器ptmalloc / tcacheSLUB slab 分配器
地址随机化ASLRKASLR(粒度、范围更强)
核心硬件防护NX、CanarySMEP/SMAP/KPTI/CFI+SLUB 硬化
主流利用方式shellcode /ret2libc /tcache 利用内核 ROP / 对象复用篡改 cred
利用核心难点泄露 libc 基址泄露内核基址 + 控制 SLUB 对象布局
崩溃后果进程崩溃,系统继续运行内核 panic,整机宕机
漏洞危害进程权限接管整机 root、容器逃逸
调试工具gdb 直接 attachkgdb、qemu+gdb,环境搭建复杂

五、常见误区澄清,初学者高频踩坑点

误区 1:UAF 一定可以提权

错。UAF 只是一个内存错误原语。能不能提权,取决于:

  1. 是否可控释放之后的对象复用;
  2. 是否有办法写入可控数据到复用内存;
  3. 目标结构体字段是否可以被篡改;
  4. 有没有 SLUB 缓存隔离、CFI 等保护拦截。
    很多 UAF 只能信息泄露,无法控制执行流,属于信息泄露漏洞,不能提权。

误区 2:OOB 写就一定可以篡改相邻对象

错。SLUB freelist 随机化,对象排布随机;同时 KASAN 红区、内存对齐、slab 填充都会影响溢出效果,很多 OOB 只能覆盖无效填充字节,碰不到敏感对象。

误区 3:内核漏洞都可以通用,所有 Linux 版本通杀

错。内核是持续迭代的,结构体偏移、SLUB 行为、保护开关随版本变化。同一个 CVE,5.4 版本可利用,5.10 加了 SLUB 硬化之后直接无法利用。

误区 4:内核 UAF 和用户态 UAF 原理一模一样,手法通用

原理层面(释放后继续访问内存)是一致的,但是分配器行为、保护机制、对象隔离完全不一样,用户态堆喷手法在内核大部分场景失效。

误区 5:只要拿到内核任意写,就一定提权

任意写是很强的原语,但是现代内核有 CFI、权限校验、很多敏感结构体加了校验。比如直接写 cred 也存在各种校验拦截,不是无条件成功。

六、UAF、OOB 漏洞的检测手段、加固方案

6.1 静态代码审计(源码层面)

审计重点:

  1. kmalloc/kmem_cache_alloc 和 kfree 配对检查,释放之后指针是否置 NULL;
  2. refcount 引用计数增减逻辑,异步 work、回调函数生命周期;
  3. memcpy、copy_from_user、memset 长度校验,判断长度是否可控、是否存在整数溢出;
  4. ioctl、proc 文件、sysfs、netfilter 等用户可控入口,用户传入 size、offset 参数校验;
  5. 结构体指针在分支路径下的生命周期,判断有没有分支提前释放、其他分支继续访问。

静态检测工具:

  • smatch、coccinelle:内核官方静态检查工具,专门检测内核内存错误;
  • clang static analyzer;
  • CodeQL 内核规则集。

6.2 动态检测

  1. KASAN:首选,专门捕获 UAF、OOB、double free,开发测试环境强制开启;
  2. KFENCE:轻量级内存错误检测,性能损耗远低于 KASAN,可以在准生产环境部署;
  3. eBPF 工具:跟踪 kmalloc/kfree 调用,监控异常的释放后访问行为;
  4. 内核 fuzz:syzkaller,内核最主流模糊测试工具,大量 UAF/OOB CVE 都是 syzkaller 跑出来的。syzkaller 构造系统调用序列,反复触发内核代码路径,自动捕获 KASAN 报错。

6.3 内核编译加固缓解 UAF/OOB

  1. CONFIG_KASAN 测试环境开启,及时捕获内存错误;
  2. CONFIG_SLAB_FREELIST_RANDOM、CONFIG_SLAB_FREELIST_HARDENED:freelist 随机化、指针加密校验,提升 UAF、double free 利用难度;
  3. CONFIG_SLAB_BUCKETS、CONFIG_RANDOM_KMALLOC_CACHES:缓存隔离,阻止跨类型对象复用;
  4. CONFIG_INIT_ON_ALLOC_DEFAULT=y、CONFIG_INIT_ON_FREE_DEFAULT=y:分配 / 释放清零,缓解残留数据信息泄露;
  5. CONFIG_CFI_CLANG:控制流完整性,阻止函数指针劫持;
  6. CONFIG_STACKPROTECTOR_STRONG:栈 canary 防护栈 OOB 溢出;
  7. 系统配置:kptr_restrict=2、dmesg_restrict=1,限制内核地址泄露渠道。

6.4 编码规范,从根源避免 UAF

内核开发编码规范:

  1. 对象 kfree 之后,立刻将指针赋值为 NULL;
  2. 异步 work,在释放对象之前,先 cancel work,等待 work 执行完成,再释放内存;
  3. 引用计数严格成对,每一次拿指针都 refcount_inc,使用完成 refcount_dec;
  4. 用户传入的长度、偏移,先做上限校验、下边界校验,防止整数溢出、越界;
  5. 不要直接使用用户传入指针,统一使用 copy_from_user /copy_to_user。

七、真实漏洞案例简单复盘,加深理解

案例 1:CVE-2021-22555 Netfilter nf_tables UAF
漏洞成因:nf_tables 在删除表项的时候,引用计数处理错误,提前释放对象,异步路径依然访问对象,典型 refcount 错误导致 UAF。
利用思路:对象复用,覆盖结构体,劫持函数指针,内核 ROP 提权。这个漏洞在 5.4 版本流行,是学习内核 UAF 非常经典的案例。新版本内核加 slab 隔离之后利用失效。

案例 2:各类驱动 OOB CVE
很多外设驱动 ioctl 没有校验用户传入拷贝长度,memcpy 越界写相邻 slab object,属于典型 OOB Write。利用依赖堆喷射布局,溢出篡改相邻对象的回调函数指针。

案例 3:syzkaller 经常捕获的文件系统 OOB Read
文件系统解析用户传入 xattr 属性,读取长度没有校验,OOB Read 泄露内核堆指针,单独作为信息泄露漏洞,搭配其他漏洞组成利用链。

从这些案例可以看到:UAF/OOB 是内核内存漏洞的基石,绝大多数高危内核漏洞,底层都逃不开这两类内存错误。

八、总结

Use-After-Free(UAF,释放后使用)指内存对象已经调用 kfree 释放、归还 SLUB 空闲链表,但是内核代码依旧保留野指针,继续读写这块内存;OOB(越界访问)是对象指针合法,但是读写范围超出对象合法边界,分为越界读和越界写。二者成因独立,但是在真实利用链里面经常互相配合:OOB Read 负责泄露内核地址绕过 KASLR,UAF 或者 OOB Write 负责篡改敏感结构体、劫持控制流。

内核漏洞和用户态漏洞最核心差距是权限模型:内核运行在 Ring0,漏洞成功利用直接整机最高权限,还会引发容器逃逸等高危场景。其次 SLUB 分配器和 ptmalloc 设计完全不同,freelist 随机化、缓存隔离、per-cpu 缓存,让内核堆布局控制难度远高于用户态堆。再叠加 SMEP、SMAP、KPTI、CFI 等专属硬件和编译保护,内核漏洞利用无法沿用用户态 shellcode 思路,主流是内核 ROP 或者 cred 结构体篡改。

对于安全学习者来说,入门内核漏洞的正确顺序:先吃透 UAF、OOB 的基础定义,理解 SLUB 分配器对象分配释放和复用逻辑,分清内核和用户态内存模型差异,再去看真实 CVE 的 POC 和 exp。如果跳过这一步,直接抄 exp,会永远看不懂 exp 里面堆喷、CPU 绑定、对象复用这些操作到底是为了解决什么底层问题。同时,开发侧、运维侧可以依靠 KASAN、KFENCE、syzkaller、静态扫描工具提前发现 UAF/OOB,配合内核编译期的 SLUB 硬化、CFI 等配置,做纵深防御,降低内存破坏漏洞被利用的风险。

内核内存漏洞攻防的本质,就是攻击者想方设法控制 SLUB 对象布局、复用内存、构造可控读写原语;防御方通过分配器硬化、内存消毒、控制流校验、信息泄露限制,不断抬高这条链路的实现成本。理解 UAF 与 OOB,就是踏入内核安全攻防的第一块敲门砖。


最后

关于网络安全技术储备

学好网络安全不论是就业还是做副业赚钱都不错,但要学会网络安全还是要有一个学习规划。最后大家分享一份全套的网络安全学习资料,给那些想学习网络安全的小伙伴们一点帮助!

对于0基础小白入门:

如果你是零基础小白,想快速入门网络安全是可以考虑的。

一方面是学习时间相对较短,学习内容更全面更集中。

二方面是可以找到适合自己的学习方案

包括:网安成长学习路线图、SRC&黑客文档、护网行动、黑客必读书单、面试题、学习视频等教程。带你从零基础系统性的学好网络安全!

需要的可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

img

👉1.成长路线图&学习规划👈
要学习一门新的技术,作为新手一定要先学习成长路线图,方向不对,努力白费。

对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图&学习规划。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。

在这里插入图片描述

👉2.网安入门到进阶视频教程👈
很多朋友都不喜欢晦涩的文字,我也为大家准备了视频教程,其中一共有21个章节,每个章节都是当前板块的精华浓缩。(全套教程文末领取哈)

在这里插入图片描述

👉3.SRC&黑客文档👈
大家最喜欢也是最关心的SRC技术文籍&黑客技术也有收录

SRC技术文籍:

在这里插入图片描述

黑客资料由于是敏感资源,这里不能直接展示哦!(全套教程文末领取哈)

👉4.护网行动资料👈
其中关于HW护网行动,也准备了对应的资料,这些内容可相当于比赛的金手指!

在这里插入图片描述

👉5.黑客必读书单👈

随着互联网技术的飞速发展,网络安全已经成为了当今科技领域的一大热点。这些SQL注入、CCNA、Web渗透、Linux服务器等,以其强大的语言理解和防御能力,正在守护着我们网络世界。 那以下这些PDF籍就是非常不错的学习资源。

img

👉6.网络安全岗面试题合集👈
当你自学到这里,你就要开始思考找工作的事情了,而工作绕不开的就是真题和面试题。

在这里插入图片描述

这份完整版的网络安全学习资料已经上传优快云,朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

img

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值