xuenixiang 发表于 2020-6-15 00:53:20

初探利用angr进行漏洞挖掘(下)


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

char bss={0};
int main(int argc, char const *argv[])
{
char buf={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
挖掘思路  这里分两步来分析如何挖掘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=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=malloc_list

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=malloc_list
  确保不会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=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=malloc_list

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的结果
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=

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("stdout:")
print(state.posix.dumps(1))
print("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=

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("stdout:")
print(state.posix.dumps(1))
print("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=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=malloc_list

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=

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("stdout:")
print(state.posix.dumps(1))
print("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=

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("stdout:")
print(state.posix.dumps(1))
print("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()

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

页: [1]
查看完整版本: 初探利用angr进行漏洞挖掘(下)