Note
Search…
⌃K

angr_进阶

载入二进制文件

载入二进制文件使用angr.Project函数,它的第一个参数是待载入文件的路径,后面还有很多的可选参数:
p = angr.Project("test",auto_load_libs = False)
auto_load_libs设置是否自动载入依赖的库,如果设置为True的话会自动载入依赖的库,然后分析到库函数调用时也会进入库函数,这样会增加分析的工作量,也有可能会跑挂。
如果auto_load_libs为true,那么程序如果调用到库函数的话就会直接调用真正的库函数,如果有的库函数逻辑比较复杂,可能分析程序就跑不出来了= = 同时angr使用python实现了很多的库函数(保存在angr.SIM_PROCEDURES),默认情况下会使用列表内不得函数来替换实际的函数调用,如果不在列表内才会进入到真正的library。跑windows程序由于环境复杂性太大,最好使其为False.
如果auto_load_libs为false,程序调用函数时,会直接返回一个 不受约束 的符号值。

喂参数给程序

创建init_state之前生成位向量符号argv1 ,作为程序的参数。
argv1 = claripy.BVS("argv1",100*8)
initial_state = p.factory.entry_state(args=["./crackme1",argv1])

正常输入

早期版本的angr是使用init_state.posix.files[0].read_from(1)逐字节读取喂给的参数,并且进行约束。
现在几乎都是使用新版本的angr,在创建init_state时使用
initial_state = p.factory.entry_state(
addr=0x401000,
stdin=flag,
)
其中addr与stdin都是可选参数。
entry_state:做一些初始化工作,然后在程序的默认入口(也可以指定addr)停下。在创建完entry_state,之后就可以通过这个state对象,获取或者修改此时程序的运行状态。
flag是使用claripy的 BVS() 方法生成的位向量符号,做为stdin输入,若没有传递stdin参数,那angr默认程序的输入为标准输入。
对于C++的程序,state时需要使用full_init_state方法并,设置unicorn引擎
initial_state = p.factory.full_init_state(
add_options=angr.options.unicorn,
stdin=flag,
)

一些约束

BV:bitvector 构造符号值或具体值的一个比特容器,它具有大小。这些值并不是简单数值(不可以直接参与算术运算),它是一个bit序列,可以用有界整数(可以直接参与算术运算)来解释。 例:
建立一个32bit的符号值容器 "x":
claripy.BVS('x',32)
建立一个32bit的具体值(0xc001b3475)容器:
claripy.BVV(0xc001b3a75,32)
建立一个32bit的步进值,从1000到2000能被10整除的数:
claripy.SI(name='x',bits=32,lower_bound=1000,upper_bound=2000,stride=10)
下面类似z3的使用,直接使用claripy创建向量,flag_chars是一个BVS类型的list,这样创建便于对每字节数据做约束. flag用了Concat方法将list转化成一个完整的BVS向量,并在末尾加换行符。
flag_chars = [claripy.BVS('flag_%d' % i, 8) for i in range(32)]
flag = claripy.Concat(*flag_chars+ [claripy.BVV(b'\n')])
或者也可以建立一个长度为 flag_length * 8的符号值容器flag_val = claripy.BVS('flag', flag_length * 8)
然后将其转化成数组形式flag = flag_val.chop(8),这样就可以通过数组的方式访问flag[i].
添加约束,提高数据的生成效率:
可使用initial_state.add_constraints()也可使用initial_state.solver.add()
for k in flag_chars:
cond_0 = k >= ord('0')
cond_1 = k <= ord('9')
cond_2 = k >= ord('a')
cond_3 = k <= ord('f')
cond_4 = initial_state.solver.And(cond_0, cond_1)
cond_5 = initial_state.solver.And(cond_2, cond_3)
cond_6 = initial_state.solver.Or(cond_4, cond_5)
initial_state.solver.add(cond_6)

优化执行

大多数情况下,添加该参数可提高脚本运行效率。simulation.one_active.options.add(angr.options.LAZY_SOLVES)

任意位置加载程序

1.有些时候程序的输入数据被分类很多组,或者程序获取输入的逻辑实现的很复杂,严重干扰了angr分析,这时候就要跳过那些输入指令,加载程序,提高符号执行效率。
创建initial_state时,使用factory的blank_state方法,传入地址,表示从该地址的状态开始。
start_address = 0x40083E
initial_state = p.factory.blank_state(addr=start_address)
2.之后就可以对寄存器,地址,做hook设置。
initial_state.memory.store(addr_in , bvs , endness='Iend_BE') 将你创建的BVS符号向量载入addr内存地址,第三个参数可以不用加,默认是大端的方式。
Variables:
LE – little endian, least significant byte is stored at lowest address
BE – big endian, most significant byte is stored at lowest address
ME – Middle-endian. Yep.
recv = initial_state.memory.load(addr_out, size) 将addr地址处的数据取出size字节放到recv对象
initial_state.regs.rax = 0x1122334455667788 给寄存器赋值,或者取出寄存器的值。
initial_state.stack_push(0x1234) 往栈中压入一个值
initial_state.mem[initial_state.regs.esp+12:].dword = 0x25 在一个内存地址处 载入一个dword类型的数 ......
3.修复程序并执行
手动修复,给缺失的内存数据填入BVS符号。
比如我们的输入是在栈中
lea rax, [rbp-70h]
mov rsi, rax
mov edi, offset aS ; "%s"
mov eax, 0
call ___isoc99_scanf
我们将程序入口设置到scanf下方,现在我们需要了解,我们跳过的那些指令是如何调整栈空间的,我们要注入的符号位向量的确切的位置。从前面的分析可知,我们要注入的位置是 [RBP - 0x70] ,因此在压栈前我们我要填充栈,但是我们首先应当告诉 ebp 它应该是指向内存的什么位置。因此我们要用angr处理函数开头(我们跳过的部分): MOV RBP, RSP 。之后我们需要减小帧指针的值(模拟 sub esp, XXX),并将BVS写到RBP-0x70的位置
修复函数如下:
initial_state.regs.rbp = initial_state.regs.rsp
bind_addr = initial_state.regs.rsp-0x70
initial_state.regs.rsp-=0x70
initial_state.memory.store(bind_addr, data)
对于更复杂的情况,比如当前位置的一个子函数加载程序后,涉及到从子函数中退出,会用到返回地址,栈帧,我们就必需要手动构造一个完整的栈结构。

开启PIE

对于开启PIE的程序,程序的基址固定在0x400000处,提取使用时应该加上该值。

反调试与hook

一些函数对结果没有影响,可直接将函数hook返回0,如printf类:
p.hook_symbol('printf',angr.SIM_PROCEDURES['stubs']['ReturnUnconstrained'](return_value=0),replace = True)
另外,对于代码自修改程序,需要使用如下的方式
p = angr.Project("crackme", support_selfmodifying_code=True)
对于静态链接的程序,需要hook函数地址为libc函数 或者有时需要自己优化函数。
p.hook(0x804f350, angr.SIM_PROCEDURES['libc']['scanf']())
p.hook(0x8048d10, angr.SIM_PROCEDURES['glibc']['__libc_start_main']())
class my_function(angr.SimProcedure)
def run(self,a):
return a+24
p.hook(addr, hook= my_function())
hook到一些关键函数上,达到控制效果。
优化scanf就可以达到和控制返回值类似的效果。
flag_chars = [claripy.BVS('flag_%d' % i, 32) for i in range(13)]
class my_scanf(angr.SimProcedure):
def run(self, fmt, ptr): # pylint: disable=arguments-differ,unused-argument
self.state.mem[ptr].dword = flag_chars[self.state.globals['scanf_count']]
self.state.globals['scanf_count'] += 1
proj.hook_symbol('__isoc99_scanf', my_scanf(), replace=True)
simulation.one_active.options.add(angr.options.LAZY_SOLVES)
simulation.one_active.globals['scanf_count'] = 0
这样程序每次调用scanf时,其实就是在执行my_scanf就会将flag_chars[i]存储到self.state.mem[ptr]当中,这其中ptr参数,其实就是本身scanf函数传递进来的rdi也,为了控制下标,我们设置了一个全局符号变量scanf_count。因为上面演示代码中程序中存在多处scanf输入。
或者如下面这样,让其自己获取输入的
class my_scanf(angr.SimProcedure): # 固有格式
def run(self,fmt,n): # 参数为 (self + 该函数实际参数)
simfd = self.state.posix.get_fd(0) # 创建一个标准输入对对象
data,real_size = simfd.read_data(4) # 注意该函数返回两个值 第一个是读到的数据内容 第二个数内容长度
self.state.memory.store(n,data) # 将数据保存到相应参数内
return 1 # 返回原本函数该返回的东西
p.hook_symbol('__isoc99_scanf',my_scanf(),replace = True)
# 这里%d对应int 是4个字节 但是读取到一个int所以返回1 所以这完全是模拟的原来的函数

路径探索

最后通过传入参数 initial_state 调用 simgr 函数创建 Simulation Manager 对象,在通过simulation执行explore方法找路径。
simulation = p.factory.simgr(initial_state)
simulation.explore(find=addr1,void=addr2)
地址可传入list的形式
yes=[0x400567,0x400756,0x400835]
no=[0x400435,0x400342,0x400526]
simulation.explore(find=yes,void=no)
如果路径很多的情况下可这样处理
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Good Job.' in stdout_output:
return True
else :
return False
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.' in stdout_output:
return True
else :
return False
simulation.explore(find=is_successful, avoid=should_abort)

打印值

if simulation.found:
solution_state = simulation.found[0]
print solution_state.posix.dumps(sys.stdin.fileno()).strip('\0\n') //打印标准输入的值(未定义BVS)
print solution_state.solver.eval(flag, cast_to=bytes) //打印定义的BVS的值
else:
raise Exception('Could not find the solution')

过滤输出

过滤found后结果的输出
found的地址刚好设置在puts函数打印正确结果处, 此时的状态时,put将要打印edi寄存器的值. 取出edi里面的地址,暂且命名为flag_addr 取出flag_addr地址处的40字节的数据到flag对象,再进行约束
found = simulation.found[0]
flag_addr = found.regs.rdi
found.add_constraints(found.memory.load(flag_addr, 5) == int(binascii.hexlify(b"flag{"), 16))
flag = found.memory.load(flag_addr, 40)
for i in range(5, 5+32):
cond_0 = flag.get_byte(i) >= ord('0')
cond_1 = flag.get_byte(i) <= ord('9')
cond_2 = flag.get_byte(i) >= ord('a')
cond_3 = flag.get_byte(i) <= ord('f')
cond_4 = found.solver.And(cond_0, cond_1)
cond_5 = found.solver.And(cond_2, cond_3)
found.add_constraints(found.solver.Or(cond_4, cond_5))
found.add_constraints(flag.get_byte(32+5) == ord('}'))
最后将结果通过eval输出即可. flag_str = found.solver.eval(flag, cast_to=bytes)
Last modified 1yr ago