from:http://labs.bromium.com/2015/02/02/exploiting-badiret-vulnerability-cve-2014-9322-linux-kernel-privilege-escalation/

POC( 感谢Mickey提供的链接):

https://rdot.org/forum/showthread.php?t=3341

Shawn:对于这个漏洞,本文的结论是SMEP虽然被绕过了,但SMAP是依然奏效的,这里只想提一下类似PaX/Grsecurity的UDEREF特性和SMAP类似,只是属于纯软件 实现,大概2006年左右这个特性就已经有了而且被一些anarchy广泛使用。

0×00 Intro


CVE-2014-9322的描述如下:

linux内核代码文件arch/x86/kernel/entry_64.S在3.17.5之前的版本都没有正确的处理跟SS(堆栈区)段寄存器相关的错误,这可以让本地用户通过触发一个IRET指令从错误的地址空间去访问GS基地址来提权。

这个漏洞于2014年11月23日被社区修复2,至今我并没有见到公开的利用代码和详细的讨论。这篇文章我会尝试去解释这个漏洞的本质以及利用的过程。不幸的 是,我无法完全引用Intel白皮书3的所有内容,如果有读者不熟悉一些术语可以直接查Intel白皮书。所有的实验都是在Fedora 20 64-bit发行版上完成的,内核是3.11.10-301,所有的讨论基于64位进行。

简单结论概要:

1. 通过测试,这个漏洞可以完全稳定的被利用。
2. SMEP[4]不能阻止任意代码执行;SMAP[5]可以阻止任意代码执行。

0×01 Digression: kernel, usermode, iret


enter image description here

0×02 漏洞


在一些情况下,linux内核通过iret指令返回用户空间时会产生一个异常。异常处理程序把执行路径返回到了bad_iret函数,她做了:

#!bash
 /* So pretend we completed the iret and took the #GPF in user mode.*/
 pushq $0
 SWAPGS
 jmp general_protection

正如这行评论所解释,接下来的代码流应该和一般保护异常(General Protection)在用户空间发生时(转跳到#GP处理程序)完全相同。这种异常处理情况大多是由iret指令引发的,e.g. #GP。

问题在于#SS异常。如果有漏洞的内核(比如3.17.5)也有"espfix"功能(从3.16引入的特性),之后bad_iret函数会在只读的栈上执行"push"指令,这会导致页错误(page fault)而会直接引起两个错误。我不考虑这种场景;从现在开始,我们只关注在3.16以前的没有"espfix"的内核。

这个漏洞根源于#SS的异常处理程序没有符合“pretend-it-was-#GP-in-userspace”[6]的规划,与#GP处理程序相比,#SS异常处理会多做一次swapgs指令。如果你对swapgs不了解,请不要跳过下面的章节。

0×03 偏题:swapgs指令


当内存通过gs段进行访问时,像这样:

#!bash
mov %gs:LOGICAL_ADDRESS, %eax

实际会发生以下几步:

1. BASE_ADDRESS值从段寄存器的隐藏部分取出
2. 内存中的线性地址LOGICAL_ADDRESS+BASE_ADDRESS被dereferenced(Shawn:char *p; *p就是deref)。

基地址是从GDT(或者LDT)继承过来的。无论如何,有一些情况是GS段基地址被修改的动作不需要GDT的参与。

引用自Intel白皮书:

“SWAPGS把当前GS基寄存器值和在MSR地址C0000102H(IA32_KERNEL_GS_BASE)所包含的值进行交换。SWAPGS指令是一个为系统软件设计的特权指令。(....)内核可以使用GS前缀在正常的内存引用去访问[per-cpu]内核数据结构。”

Linux内核为每个CPU在启动时分配一个固定大小的结构体来存放关键数据。之后为每个CPU加载IA32_KERNEL_GS_BASE到相应的结构地址上,因此,通常的情况,比如系统调用的处理程序是:

1. swapgs(现在是GS指向内核空间)
2. 通过内存指令和gs前缀访问per-cpu内核数据结构
3. swapgs(撤销之前的swapgs,GS指向用户空间)
4. 返回用户空间

0×04 触发漏洞


现在很明显可以看到这个漏洞简直就是坟墓,因为多了一个swapgs指令在有漏洞代码路径里,内核会尝试从可能被用户操控的错误GS基地址访问重要的数据结构。

当iret指令产生了一个#SS异常?有趣的是,Intel白皮书在这方面介绍不完全(Shawn:是阴谋论的话又会想到BIG BROTHER?);描述iret指令时,Intel白皮书这 么讲:

64位模式的异常:
#SS(0)
如果一个尝试从栈上pop一个值违反了SS限制。
如果一个尝试从栈上pop一个值引起了non-canonical地址(Shawn: 64-bit下只允许访问canonical地址)的引用。

没有一个条件能被强制在内核空间里发生。无论如何,Intel白皮书里的iret伪代码展示了另外一种情况:when the segment defined by the return frame is not present:

IF stack segment is not present
THEN #SS(SS selector); FI;

所以在用户空间,我们需要设置ss寄存器为某个值来表示不存在。这不是很直接:

我们不能仅仅使用:

mov $nonpresent_segment_selector, %eax
mov %ax, %ss

第二条指令会引发#GP。通过调试器(任何ptrace)设置ss寄存器是不允许的;类似的,sys_sigreturn系统调用不会在64位系统上设置这个寄存器(可能32位能工作)。解决方案是:

1. 线程A:通过sys_modify_ldt系统调用在LDT里创建一个定制段X
2. 线程B:s:=X_selector
3. 线程A:通过sys_modify_ldt使X无效
4. 线程B:等待硬件中断

为什么需要在一个进程里使用两个线程的原因是从系统调用(包括sys_modify_ldt)返回是通过硬编码了#ss值的sysret指令。如果我们使X在相同的线程中无效就等同于"ss:=X 指令“,ss寄存器会处于未完成设置的状态。运行以上代码会导致内核panic。按照更有意义的做法,我们将需要控制用户空间的gs基地址;她可以通过系统调用arch_prctl(ARCH_SET_GS)被设置。

0×05 Achieving write primitive


如果运行以上代码,#SS处理程序会正常的返回bad_iret(意思是没有触及到内存的GS基地址),之后转跳到#GP异常处理程序,执行一段时间后就调用到了这个函数:

#!cpp
289 dotraplinkage void
290 do_general_protection(struct pt_regs *regs, long error_code)
291 {
292         struct task_struct *tsk;
...
306         tsk = current;
307         if (!user_mode(regs)) {
                ... it is not reached
317         }
318 
319         tsk->thread.error_code = error_code;
320         tsk->thread.trap_nr = X86_TRAP_GP;
321 
322         if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) &&
323                         printk_ratelimit()) {
324                 pr_info("%s[%d] general protection ip:%lx sp:%lx
error:%lx",
325                         tsk->comm, task_pid_nr(tsk),
326                         regs->ip, regs->sp, error_code);
327                 print_vma_addr(" in ", regs->ip);
328                 pr_cont("\n");
329         }
330 
331         force_sig_info(SIGSEGV, SEND_SIG_PRIV, tsk);
332 exit:
333         exception_exit(prev_state);
334 }

C代码不太明显,但从gs前缀读取到现有宏的值赋给了tsk。第306行是:

#!bash
0xffffffff8164b79d :    mov    %gs:0xc780,%rbx

这很变得有意思起来了。我们控制了current指针,她指向用于描述整个Linux进程的数据结构。

319         tsk->thread.error_code = error_code;
320         tsk->thread.trap_nr = X86_TRAP_GP;

写入(从task_struct开始的固定偏移)我们控制的地址。注意值本身不能被控制(分别是0和0xd常量),但这不应该成为一个问题。游戏结束?

不会,我们想覆盖一些在X上的重要数据结构。如果我们按照以下的步骤:

1. 准备在FAKE_PERCPU的用户空间内存,设置gs基地址给她
2. 让地址FAKE_PERCPU+0xc780存着指针FAKE_CURRENT_WITH_OFFSET,以满足FAKE_CURRENT_WITH_OFFSET= X – offsetof(struct task_struct,thread.error_code)
3. 触发漏洞

之后do_general_protection会写入X。但很快就会尝试再次访问current task_current的其他成员,e.g.unhandled_signal()函数从task_struct指针解引用。我们没有依赖X来控制,最终会在内核产生一个页错误。我们怎么避免这个问题?选项有:

  1. 什么都不做。Linux内核不像Windows,Linux内核是完全允许当一个不是预期的页错误在内核出现,如果可能的话,内核会杀死当前进程之后尝试继续运行(Windows会蓝屏)。这种机制对于大量内核数据污染就无能为力了。我的猜测是在当前进程被杀死后,swapgs不平衡的保持下来,这会导致其他进程上下文的更多页错误。

  2. 使用“tsk->thread.error_code = error_code”覆盖为页错误处理程序的IDT入口。之后页错误发生(被unhandled_signal()触发)。这个技术曾经在一些偶然的环境中成功过。但在这里不会成功,因为有2个原因:

    • Linux让IDT只读
    • 就算IDT可写,我们也不能控制覆盖的值 -- 0或者0xd。SMEP/SMAP也会是问题。
  3. 我们可以尝试产生一个竞争。“tsk->thread.error_code = error_code”会促进代码执行,比如允许通过系统调用控制的代码指针P。之后我们可以在CPU 0上触发漏洞,在同一时间段CPU 1可以循环执行一些系统调用。这个思路可以在CPU 0被破坏前让通过CPU 1获得代码执行,比如hook页错误处理程序,这样CPU 0不会影响更多的地方,我尝试了这种方法多次,但都失败了。可能不同的漏洞在时间线上的不同所致。

  4. Throw a towel on “tsk->thread.error_code = error_code” write.

虽然有些恶心,我们会尝试最后一个选项。我们会让current指向用户空间,设置这个指针可以通过读的deref到我们能控制的内存。自然的,我们观察接下来的代码,找找更多的写deref。

0×06. Achieving write primitive continued, aka life after do_general_protection

下一个机会是do_general_protection()所调用的函数:

#!cpp
int
force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
        unsigned long int flags;
        int ret, blocked, ignored;
        struct k_sigaction *action;

        spin_lock_irqsave(&t->sighand->siglock, flags);
        action = &t->sighand->action[sig-1];
        ignored = action->sa.sa_handler == SIG_IGN;
        blocked = sigismember(&t->blocked, sig);   
        if (blocked || ignored) {
                action->sa.sa_handler = SIG_DFL;
                if (blocked) {
                        sigdelset(&t->blocked, sig);
                        recalc_sigpending_and_wake(t);
                }
        }
        if (action->sa.sa_handler == SIG_DFL)
                t->signal->flags &= ~SIGNAL_UNKILLABLE;
        ret = specific_send_sig_info(sig, info, t);
        spin_unlock_irqrestore(&t->sighand->siglock, flags);

        return ret;
}

task_struct的成员sighand是一个指针,我们可以设置任意值。

action = &t->sighand->action[sig-1];
action->sa.sa_handler = SIG_DFL;

我们无法控制写的值,SIG_DFL是常量的0。这里最终能工作了,虽然有些扭曲。假设我们想覆盖内核地址X。为此我们准备伪造的task_struct,所以X等于t->sighand->action[sig-1].sa.sa_handler的地址。上面还有一行要注意:

#!cpp
spin_lock_irqsave(&t->sighand->siglock, flags);

t->sighand->siglock在t->sighand->action[sig-1].sa.sa_handler的常量偏移上,内核会调用spin_local_irqsave在某些地址上,X+SPINLOCK的内容无法控制。这会发生什么呢?两种可能性:

  1. X+SPINLOCK所在的内存地址看起来像没有锁的spinlock。spin_lock_irqsave会立即完成。最后,spin_unlock_irqrestore会撤销spin_lock_irqsave的写操作。

2.X+SPINLOCK所在的内存地址看起来像上锁的spinlock。如果我们不介入的话,spin_lock_irqsave会无线循环等待spinlock。有些担心,要绕过这个障碍我们得需要其他假设 ---|| X+SPINLOCK所在内存地址的内容。这是可接受的,我们可以在后面看到在内核.data区域里设置X。

* 首先,准备FAKE_CURRENT,让t->sighand->siglock指向用户空间上锁的区域,SPINLOCK_USERMODE
* force_sig_info()会挂在spin_lock_irqsave里
* 这时,另外一个用户空间的线程在另外一个CPU上运行,并且改变了t->sighand,所以t->sighand->action[sig-1.sa.sa_hander成了我们的覆盖目标,之后解锁SPINLOCK_USERMODE
* spin_lock_irqsave会返回
* force_sig_info()会重新载入t->sighand,执行期望的写操作

鼓励细心的读者追问为什么不能使用第2种方案,即X+SPINLOCK在初始时是没有锁的。这并不是全部 ---|| 我们需要准备一些FAKE_CURRENT的字段来让尽量少的代码执行。我不会再透露更多细节 ---|| 这篇BLOG已经够长了....下一步会发生什么?force_sig_info()和do_general_protection()返回。接下来iret指令会再次产生#SS异常处理(因为仍然是用户空间ss的值在栈上引用了一个nonpresent段),但这一次,#SS处理程序里的额外swapgs指令会返回并取消之前不正确的swapgs。 do_general_protection()会调用和操作真正的task_struct,而不是伪造的FAKE_CURRENT。最终,current会发出SIGSEGV信号,其他进程会被调度来执行。这个系统仍然是稳定的。

enter image description here

0×07 插曲:SMEP


SMEP是Intel处理器从第3代Core(Shawn:酷睿)时加入的硬件特性。如果控制寄存器CR4里的SMEP位被设置的话,当RING0(Shawn:标准Linux内核是RING0,在XEN下是例外,RING0是Hypervisor)尝试执行的代码来自标记为用户空间的内存页,CPU就会生成一个错误(Shawn:就是拒绝)。如果可能的话,Linux内核会默认开启SMEP。

0×08 实现代码执行


之前的章节讲述了一种如何以0在内核内存中覆盖8个连续字节的方法。如果SMEP开启的情况下如何实现代码执行呢?

直接覆盖一个内核代码的指针是不行的。我们可以清零top bytes( Shawn: MSB)- 但之后的地址会在用户空间,所以SMEP会阻止这个指针的deref。

换一种方式,我们可以清零几个low bytes( Shawn: LSB),但是之后能利用这个指针的概率也很低。

我们需要一个内核指针P指向结构X包含了代码指针。我们可以覆盖P的top bytes让她成为一个用户空间的地址,这样P->code_pointer_in_x()调用会跳转到一个我们能选择的地址。我不确定最好选择哪个攻击对象。从我的经验来看,我选择内核proc_root变量,这是一个结构体:

#!cpp
struct proc_dir_entry {
            ...
        const struct inode_operations *proc_iops;
        const struct file_operations *proc_fops;
        struct proc_dir_entry *next, *parent, *subdir;
        ...
        u8 namelen;
        char name[];
};

这个结构体是一个proc文件系统的入口(proc_root是/proc作为proc文件系统的根目录)。当一个文件名路径开始在/proc里查询时,subdir指针(从proc_root.subdir开始)会跟进,直到名字被找到。之后proc_iops的指针会被调用:

#!cpp
struct inode_operations {
        struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
        void * (*follow_link) (struct dentry *, struct nameidata *);
        ...many more...
        int (*update_time)(struct inode *, struct timespec *, int);
        ...
} ____cacheline_aligned;

proc_root驻扎在内核代码段里,这意味着漏洞利用需要知道她的地址。这个信息可以从/proc/kallsyms符号表得到;当然,很多加固过的内核不允许普通用户读取这个文件。但如果内核是一个已知的build(标准的GNU/Linux发行版),这个地址可以轻松获得;和一堆偏移一样需要构建FAKE_CURRENT。

我们会覆盖proc_root.subdir,让她成为一个指向一个在用户空间能被控制的结构体proc_dir_entry。有点困难在于我们不能覆盖整个指针。别忘了我们的写操作是“覆盖8个0”。如果我们让proc_root.subdir变成0,我们不会去映射她,因为Linux内核不允许用户空间映射到地址0上(更确切的说发是,任何低于/proc/sys/vm/mmap_min_addr的地址,默认值一般是4k)。(Shawn:想想哪些0ld good hacking days,每天都有一堆NULL pointer deref是多么幸福活着无挑战的时光啊;-))。这意味着我们需要:

1. 映射16MB的内存到地址4096
2. 使用类似proc_dir_entry的方式来填充,把inode_operations字段指向用户空
间的地址FAKE_IOPS,name字段为字符串"A"。
3. 配置漏洞利用去覆盖proc_root.subdir的top 5 bytes。

之后,除非proc_root.subdir最低的3 bytes是0,我们可以确定在触发force_sig_info()覆盖后,proc_root.subdir会指向被控制的用户空间内存。当我们的进程调用open("/proc/A",...)时,FAKE_IOPS的指针会被调用。她们应该指向哪里呢?如果你认为答案是“指向我们的shellcode“,请再读一遍上面的分析。

我们需要让FAKE_IOPS指针指向一个stack pivot1序列。这再次假设了具体内核运行的版本情况。通常的"xchg %esp, %eax; ret"代码序列(2个字节,94 c3是在测试内核的地址0xffffffff8119f1ed)很好的可以用于64位内核的ROP。就算没能控制%rax,这个xchg指令操作32位的寄存器也能清掉%rsp的高32位而让%rsp着陆在用户空间的内存里。在最糟糕的情况下,我们可以分配低4GB的虚拟内存然后填充ROP链条。

在当前测试的内核(Fedora 20)有两种方法去deref在FAKE_IOPS的指针:

1. %rax:=FAKE_IOPS; call *SOME_OFFSET(%rax)
2. %rax:=FAKE_IOPS; %rax:=SOME_OFFSET(%rax); call *%rax 

第1种情况里,在%rsp和%rax交换值后,她会等于FAKE_IOPS。我们需要ROP链条驻扎在FAKE_IOPS的起始位置,这需要类似“add $A_LOT, %rsp; ret”的指令,然后在继续。

第2种情况里,%rsp会分配低32位的调用目标,即0x8119f1ed。我们需要准备在这个地址上的ROP链条。

计算一下%rax值有两者之一的已知值在特定的时间指向stack pivot序列,我们不需要ROP链条填充整个4GB内存,只需要上面的两个地址即可。第2种情况的ROP链条自身很简洁:

#!bash
unsigned long *stack=0x8119f1ed;
*stack++=0xffffffff81307bcdULL;  // pop rdi, ret
*stack++=0x407e0;                //cr4 with smep bit cleared
*stack++=0xffffffff8104c394ULL;  // mov rdi, cr4; pop %rbp; ret
*stack++=0xaabbccdd;             // placeholder for rbp
*stack++=actual_shellcode_in_usermode_pages;

0×09 插曲:SMAP


SMAP是Intel从第5代Core处理器推出的一个硬件特性。如果CR4控制寄存器的SMAP位被设置的话,CPU会拒绝用户空间的页被RING0访问(Shawn:个人理解,SMAP和SMEP最大的不同主要是SMEP针对代码段,而SMAP针对数据段)。Linux内核通常会默认开启SMAP。一个测试的内核模块(Core-M 5Y10a CPU)尝试访问用户空间然后crash了:

#!bash
[  314.099024] running with cr4=0x3407e0
[  389.885318] BUG: unable to handle kernel paging request at 00007f9d87670000
[  389.885455] IP: [ffffffffa0832029] test_write_proc+0x29/0x50 [smaptest]
[  389.885577] PGD 427cf067 PUD 42b22067 PMD 41ef3067 PTE 80000000408f9867
[  389.887253] Code: 48 8b 33 48 c7 c7 3f 30 83 a0 31 c0 e8 21 c1 f0 e0 44 89 e0 48 8b 

正如我们看到的,用户空间的页是正常的,但访问也报了页错误。Windows系统不太支持SMAP;Windows 10技术预览版build 9926的cr4=0x1506f8(SMEP启动,SMAP关闭);对比Linux内核(同样的测试硬件)你可以看到cr4的bit 21是没有设置的。这不奇怪,在Linux中,访问用户空间是通过调用copy_from_user(),copy_to_user()和类似函数显式执行的,所以执行这些操作时临时关闭SMAP是可行的。在Windows上,内核代码直接访问用户空间代码,只是包装了一层访问异常处理程序,所以要让SMAP工作正常需要调整所有的驱动,这是一项困难的工作。

0x0A SMAP to the rescue!


上面的漏洞利用方法依赖于在用户空间里准备特定的数据结构,然后强制内核认为她们是可信的内核数据。这种方法对于开启SMAP特性的内核不奏效 ---|| CPU会拒绝从用户空间读取恶意数据。我们能做的是构造所有需要用的数据结构,然后拷贝她们到内核。比如:

#!cpp
write(pipe_filedescriptor, evil_data, ...

之后evil_data会被拷贝到一个内核管道缓冲区里。我们可能需要猜测她的地址; some sort of heap spraying, combined with the fact that there is no spoon^W effective kernel ASLR[9], could work, although it is likely to be less reliable than exploitation without SMAP.

总之,还有最后一个障碍 ---|| 不要忘了我们需要设置用户空间的gs base去指向我们的漏洞利用的数据结构。在上面的场景(没有SMAP),我们使用arch_prctl(ARCH_SET_GS)系统调用,她是这样在内核里实现的:

#!bash
long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
{ 
         int ret = 0; 
         int doit = task == current;
         int cpu;

         switch (code) { 
         case ARCH_SET_GS:
                 if (addr >= TASK_SIZE_OF(task))
                         return -EPERM; 
                 ... honour the request otherwise

休斯顿,我们有一个麻烦 ---|| 我们不能使用这个API去设置gs base用户空间以上的内存!

最近的CPU有wrgsbase指令可以直接设置gs base,这是一个非特权级指令,但需要通过内核设置CR4控制寄存器中的FSGSBASE bit( no 16)来开启。Linux并没有设置这个位,因此用户空间不能使用这条指令。

在64位系统上,非系统级的GDT和LDT条目依然是8个字节长,base field是最大4GB-1,所以根本没有机会设置一个基地址的段在内核空间里。所以,除非我漏掉了能在内核里设置用户态gs base的其他方法,不然SMAP能保护CVE-2014-9322针对64位Linux内核任意代码执行的漏洞利用。

1 CVE-2014-9322 http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-9322

2 Upstream fix http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6f442be2fb22be02cafa606f1769fa1e6f894441

3 Intel Software Developer’s Manuals, http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html

[4] SMEP http://vulnfactory.org/blog/2011/06/05/smep-what-is-it-and-how-to-beat-it-on-linux/

[5] SMAP http://lwn.net/Articles/517475

[6] "pretend-it-was-#GP-in-userspace" https://lists.debian.org/debian-kernel/2014/12/msg00083.html

[7] Stack Pivoting https://trailofbits.files.wordpress.com/2010/04/practical-rop.pdf

[8] TSX improves timing attacks against KASLR http://labs.bromium.com/2014/10/27/tsx-improves-timing-attacks-against-kaslr/