学逆向论坛

找回密码
立即注册

只需一步,快速开始

学逆向论坛»论坛 › 软件安全 › CTF专区 › 初探利用angr进行漏洞挖掘（下）
发新帖
xuenixiang

116

积分

0

好友

25

主题

[Pwn] 初探利用angr进行漏洞挖掘（下）

发表于 2020-6-15 00:53:20 | 查看: 5652| 回复: 0

相关题目：


前言　　接上一篇，继续来分析如何使用angr挖掘出UAF和double free漏洞
　　UAF，即use after free，一般是由未清空的堆指针再次被重用导致的漏洞，uaf有两种，一种是重用被free堆块进行写数据的操作，另一种是重用被free堆块进行读数据的操作
　　double free则是对同一块堆空间free操作两次而产生的漏洞，这种漏洞会导致内存破坏，根据不同的环境造成的破坏效果也不一样
　　同样以一个例子开头
#include <stdio.h>
#include <stdlib.h>

char bss[0x10]={0};
int main(int argc, char const *argv[])
{
char buf[0x10]={0};
int times=4;
unsigned long *ptr=&bss;
while(times--)
{
puts("input:");
read(0,buf,8);
switch(atoi(buf))
{
case 1: 
puts("malloc!");
*ptr=malloc(0x30);
// printf("%p,%p,%p\n", &ptr,ptr,*ptr);
break;
case 2:
if (*ptr)
{
puts("free!");
free(*ptr);

}
else
{
puts("fail to free");
return;
}

break;
case 3:
if (*ptr)
{
puts("edit!");
read(0,*ptr,8);

}
else
{
puts("fail to edit");
return;
}
break;

case 4:
if (*ptr)
{
puts("show!");
write(1,*ptr,8);

}
else
{
puts("fail to show");
return;
}
break;

}

}

return 0;
}

　　这种类型是典型的堆漏洞题型，一般通过菜单选项的方式，可以造成uaf读写和double free
　　如果用unconstrained状态来找漏洞的话，你会发现，即使遍历完所有路径也不会出一个unconstrained

初探利用angr进行漏洞挖掘（下）

初探利用angr进行漏洞挖掘（下）
挖掘思路　　这里分两步来分析如何挖掘double free和uaf
double free　　首先是挖掘double free，这种漏洞的成因很简单，就是free了同一个堆块两次，那么我们只需要使用某种方法记录下每次malloc和free的目标堆空间，就能判断出是否发生了double free
　　angr提供了hook的功能，可以任意hook glibc中的函数，通过hook malloc函数，使用全局变量malloc_list字典来记录每次得到的堆地址
from angr.sim_type import SimTypeTop,SimTypeLength

class malloc_hook(angr.procedures.libc.malloc.malloc):

def run(self, sim_size):
self.argument_types = {0: SimTypeLength(self.state.arch)}
self.return_type = self.ty_ptr(SimTypeTop(sim_size))
addr=self.state.heap._malloc(sim_size)#申请得到的堆块地址
size=self.state.solver.eval(sim_size)#申请得到的堆块大小

if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
else:
self.state.globals["malloc_list"]={}
malloc_list=self.state.globals["malloc_list"]

malloc_list[addr]=size#以字典的方式存储进路径全局变量
return addr

　　同样的，还需要hook free函数
class free_hook(angr.procedures.libc.free.free):      
def run(self, ptr):
self.argument_types = {0: self.ty_ptr(SimTypeTop())}
f_ptr=self.state.solver.eval(ptr)#即将要free的堆块地址

if "free_list" in self.state.globals:
free_list=self.state.globals["free_list"]
if f_ptr in free_list:
print("double free:")
print("stdout:\n",self.state.posix.dumps(1))
print("stdin:\n",self.state.posix.dumps(0))
else:
self.state.globals["free_list"]={}
free_list=self.state.globals["free_list"]
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
if f_ptr in malloc_list:
free_list[f_ptr]=malloc_list[f_ptr]

return self.state.heap._free(ptr)

　　首先要判断当前路径是否存在全局变量字典free_list，如果存在说明该路径至少调用了一次free函数，那么就直接遍历free_list，康康当前要被free的地址f_ptr是否存在于free_list中，如果存在了那么说明发生了 double free
　　如果不存在free_list，那么说明该路径下是第一次调用free函数，那么进行free_list字典的初始化，然后再判断即将要free的堆地址f_ptr 是否存在于malloc_list中，只有存在才能进行free_list[f_ptr]=malloc_list[f_ptr]
　　确保不会free一些奇怪的地址
　　完整angr脚本如下
import angr
from angr.sim_type import SimTypeTop,SimTypeLength
from angr import sim_options as so
class malloc_hook(angr.procedures.libc.malloc.malloc):

def run(self, sim_size):
self.argument_types = {0: SimTypeLength(self.state.arch)}
self.return_type = self.ty_ptr(SimTypeTop(sim_size))
addr=self.state.heap._malloc(sim_size)
size=self.state.solver.eval(sim_size)

if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
else:
self.state.globals["malloc_list"]={}
malloc_list=self.state.globals["malloc_list"]

malloc_list[addr]=size
return addr

class free_hook(angr.procedures.libc.free.free):
def run(self, ptr):
self.argument_types = {0: self.ty_ptr(SimTypeTop())}
f_ptr=self.state.solver.eval(ptr)

if "free_list" in self.state.globals:
free_list=self.state.globals["free_list"]
if f_ptr in free_list:
print("double free:")
print("stdout:\n",self.state.posix.dumps(1))
print("stdin:\n",self.state.posix.dumps(0))

else:
self.state.globals["free_list"]={}
free_list=self.state.globals["free_list"]
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
if f_ptr in malloc_list:
free_list[f_ptr]=malloc_list[f_ptr]

return self.state.heap._free(ptr)



if __name__ == '__main__':
filename="./heap1"

p = angr.Project(filename,auto_load_libs=False)#
p.hook_symbol('malloc',malloc_hook())
p.hook_symbol('free',free_hook())
extras = {so.REVERSE_MEMORY_NAME_MAP, so.TRACK_ACTION_HISTORY,so.ZERO_FILL_UNCONSTRAINED_MEMORY}
state=p.factory.entry_state(add_options=extras)
simgr = p.factory.simulation_manager(state,save_unconstrained=True)
simgr.use_technique(angr.exploration_techniques.Spiller())

while simgr.active:
simgr.step()

　　运行大概五分钟就出了几个double free的结果

初探利用angr进行漏洞挖掘（下）

初探利用angr进行漏洞挖掘（下）
uaf　　接下来就是挖掘UAF了，UAF的核心在于对已经free过的地址进行读或者写的操作，同样可以利用hook 的方法来记录已经free的地址，然后再通过angr提供的action的方法来查看对内存地址的读写操作，如果对应的读写操作地址恰好是已经free过的地址，那么可以认为是产生了UAF漏洞
　　新增两个函数专门用于检测UAF_R和UAF_W
def Check_UAF_R(state):
if "free_list" not in state.globals:
if "before_free" in state.globals:
before_free=state.globals["before_free"]
else:
state.globals["before_free"]=[]
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
for act in action_now:
if act not in before_free:
before_free.append(act)
else:
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
action=[i for i in action_now if i not in before_free]

malloc_list=state.globals["malloc_list"]
free_list=state.globals["free_list"]

for act in action:
if act.type=='mem' and act.action=='read' :
addr=check_addr(state,act)
if addr==0:
print("error addr:",act.addr)
break

for f in free_list:
if f==addr:
print("\n[========find a UAF read========]")
print("[UAF-R]stdout:")
print(state.posix.dumps(1))
print("[UAF-R]trigger arbitrary read input:")
print(state.posix.dumps(0))
break

def Check_UAF_W(state):
if "free_list" not in state.globals:
if "before_free" in state.globals:
before_free=state.globals["before_free"]
else:
state.globals["before_free"]=[]
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
for act in action_now:
if act not in before_free:
before_free.append(act)

else:
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
action=[i for i in action_now if i not in before_free]

malloc_list=state.globals["malloc_list"]
free_list=state.globals["free_list"]

for act in action:
if act.type=='mem' and act.action=='write' :
addr=check_addr(state,act)
if addr==0:
print("error:",act.addr)
break

for f in free_list:
if f==addr:
print("\n[========find a UAF write========]")
print("[UAF-W]stdout:")
print(state.posix.dumps(1))
print("[UAF-W]trigger arbitrary write input:")
print(state.posix.dumps(0))f
break

　　简单说一下思路，就是首先判断当前路径有没有执行过free函数，也就是通过判断有没有free_list字典，如果有，那么说明已经调用过free了，直接进入action判断，先从action的类型开始，必须得是对mem操作的write类型，然后对操作地址addr进行检测，判断addr是否在free_list中，如果在那么说明就是UAF的写数据操作了
　　如果当前路径没有free_list字典，那么说明还没有调用过free函数，因此把目前为止经过的action数组存储起来，存到state.globals["before_free"]中，这样一来，在调用过一次free后，取两个列表state.globals["before_free"]和action_now=reversed(state.history.actions.hardcopy)，得到在action_now但不在before_free中的新列表action，这是为了去除多余的无效action，便于直接从第一次调用了free后开始检测UAF，毕竟没有调用过free函数说不可能存在UAF漏洞的
　　最后加上之前的double free检测功能的完整代码如下
import angr
from angr.sim_type import SimTypeTop,SimTypeLength
from angr import sim_options as so
class malloc_hook(angr.procedures.libc.malloc.malloc):

def run(self, sim_size):
self.argument_types = {0: SimTypeLength(self.state.arch)}
self.return_type = self.ty_ptr(SimTypeTop(sim_size))
addr=self.state.heap._malloc(sim_size)
size=self.state.solver.eval(sim_size)

if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
else:
self.state.globals["malloc_list"]={}
malloc_list=self.state.globals["malloc_list"]

malloc_list[addr]=size
return addr

class free_hook(angr.procedures.libc.free.free):
def run(self, ptr):
self.argument_types = {0: self.ty_ptr(SimTypeTop())}
f_ptr=self.state.solver.eval(ptr)

if "free_list" in self.state.globals:
free_list=self.state.globals["free_list"]
if f_ptr in free_list:
print("double free:")
print("stdout:\n",self.state.posix.dumps(1))
print("stdin:\n",self.state.posix.dumps(0))

else:
self.state.globals["free_list"]={}
free_list=self.state.globals["free_list"]
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
if f_ptr in malloc_list:
free_list[f_ptr]=malloc_list[f_ptr]

return self.state.heap._free(ptr)

def Check_UAF_R(state):
if "free_list" not in state.globals:
if "before_free" in state.globals:
before_free=state.globals["before_free"]
else:
state.globals["before_free"]=[]
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
for act in action_now:
if act not in before_free:
before_free.append(act)
else:
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
action=[i for i in action_now if i not in before_free]

malloc_list=state.globals["malloc_list"]
free_list=state.globals["free_list"]

for act in action:
if act.type=='mem' and act.action=='read' :
addr=check_addr(state,act)
if addr==0:
print("error addr:",act.addr)
break

for f in free_list:
if f==addr:
print("\n[========find a UAF read========]")
print("[UAF-R]stdout:")
print(state.posix.dumps(1))
print("[UAF-R]trigger arbitrary read input:")
print(state.posix.dumps(0))
break

def Check_UAF_W(state):
if "free_list" not in state.globals:
if "before_free" in state.globals:
before_free=state.globals["before_free"]
else:
state.globals["before_free"]=[]
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
for act in action_now:
if act not in before_free:
before_free.append(act)

else:
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
action=[i for i in action_now if i not in before_free]

malloc_list=state.globals["malloc_list"]
free_list=state.globals["free_list"]

for act in action:
if act.type=='mem' and act.action=='write' :
addr=check_addr(state,act)
if addr==0:
print("error:",act.addr)
break

for f in free_list:
if f==addr:
print("\n[========find a UAF write========]")
print("[UAF-W]stdout:")
print(state.posix.dumps(1))
print("[UAF-W]trigger arbitrary write input:")
print(state.posix.dumps(0))f
break

if __name__ == '__main__':
filename="./heap1"

p = angr.Project(filename,auto_load_libs=False)#
p.hook_symbol('malloc',malloc_hook())
p.hook_symbol('free',free_hook())
extras = {so.REVERSE_MEMORY_NAME_MAP, so.TRACK_ACTION_HISTORY,so.ZERO_FILL_UNCONSTRAINED_MEMORY}
state=p.factory.entry_state(add_options=extras)
simgr = p.factory.simulation_manager(state,save_unconstrained=True)
simgr.use_technique(angr.exploration_techniques.Spiller())

while simgr.active:
for act in simgr.active:
Check_UAF_R(act)
Check_UAF_W(act)
simgr.step()

　　运行一波，结果如图所示

初探利用angr进行漏洞挖掘（下）

初探利用angr进行漏洞挖掘（下）
　　我这个运气算是比较好的，很多时候不一定能一开始就跑出三个不同类型的漏洞，大部分的情况是会产生大量的重复漏洞情况
　　那么如果去除重复的漏洞类型呢？
　　我这里使用了一种编辑算法，根据每条路径的函数调用链来判断路径的相似度有多高，默认设置的编辑距离是3，这样能去除大部分重复的漏洞，但这种方法仍然是治标不治本的，当代码足够复杂的时候即使是重复路径，编辑距离也很可能超过3，只能说尽量减少了很多，看起来没那么恶心
　　具体代码就不在这里贴出来了，有兴趣可看俺的GitHub
总结　　以上就是本人利用angr挖掘简单double free和uaf的思路和心得，如果有师傅有更骚的操作，也望不啬赐教
　　虽然俺这里就两篇分析了栈和堆的漏洞，实际上我还实现了其他的一些漏洞或者说代码错误检测，有兴趣的师傅可以康康俺的GitHub，我都传上去了，不过跟我这两篇内贴出来的代码不太一样，反正原理肯定是一样的（代码写的比较难看23333看不懂别打我呜呜呜）
　　利用angr实现的这些漏洞挖掘的操作总体来说还是比较鸡肋的，只能说算是一种思想方法，可能唯一的用途是挖掘ctf中的简单pwn题，或者说在AEG的时候可以优化一下找漏洞的思路
　　然而在实际软件的漏洞挖掘中就基本没卵用了，因为基本上一开angr跑不了多久就路径爆炸内存爆炸了，angr的符号执行似乎比较适合粒度细的代码领域，一旦复杂起来，路径就会呈几何速度增长，俺在测试的时候可是足足分配了4g内存给虚拟机的
　　继续努力8，康康以后能不能把符号执行运用到实际挖洞上

温馨提示：
1.如果您喜欢这篇帖子，请给作者点赞评分，点赞会增加帖子的热度，评分会给作者加学币。(评分不会扣掉您的积分，系统每天都会重置您的评分额度)。
2.回复帖子不仅是对作者的认可，还可以获得学币奖励，请尊重他人的劳动成果，拒绝做伸手党！
3.发广告、灌水回复等违规行为一经发现直接禁言，如果本帖内容涉嫌违规，请点击论坛底部的举报反馈按钮，也可以在【投诉建议】板块发帖举报。
利用, 进行, 漏洞挖掘

相关帖子
返回列表

小黑屋|手机版|站务邮箱|学逆向论坛 ( 粤ICP备2021023307号 )|网站地图

GMT+8, 2024-11-22 00:54 , Processed in 0.134339 second(s), 42 queries .

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表