[原创]非标准OLLVM-fla反混淆分析还原-Android安全-看雪-安全社区|安全招聘|kanxue.com

[原创]非标准OLLVM-fla反混淆分析还原

发表于: 2025-4-21 01:23 24138

[原创]非标准OLLVM-fla反混淆分析还原

九天666

2025-4-21 01:23

24138

基于angr和idapython的非标准OLLVM-fla反混淆分析还原

本文章主要是采用angr框架和idapython脚本相结合,实现对非标准ollvm-fla控制流平坦化反混淆的分析和处理,以及对angr和idapython相关api进项讲解。

要解决fla的混淆,需要实现三大步骤:

步骤1,3相对简单,这里可以看大家的喜好,愿意用angr也是可以的,我倾向于在分析fla混淆的时候能够实时的观测到修改块的实时现象,我就采用了idapython脚本处理。

这里主要说的是步骤2,比如,当我们拿到了所有真实块,我们应该怎么去找到真是块之间的连接关系。遇到混淆程度不高的,可以尝试体力活修改。那么遇到下面的这种混淆,请问阁下该如何应对。

所以,这里我们需要用到angr的一个强大功能:符号执行（angr更多的原理需自行百度查阅）

这里又衍生出一个新问题,什么是符号执行？

它的运行和unidbg类似,都是通过模拟执行,但是不同的是,unidbg的模拟执行需要传入具体的数值,而angr可以不需要。

比如下面一个简单的加法函数,unidbg要模拟执行它,就需要传入a和b具体的数值,假设传入a=1,b=2,这里unidbg的执行结果就是3。

而angr不需要,它执行直接传入符号a和b,注意这里是符号,不是具体的值,最后通过模拟执行,输出结果a+b。

所以我们就是利用angr符号执行的特性,用到其中主要的路径探索的能力,当执行到第一个真实块A的时候 ,把它标记为主块,然后让其继续运行,当它碰到的第一个真实块B的时候,这里就是A的后继块,那么A和B的连接关系就被我们给找到了。这里也要注意到angr的一个路径爆炸的问题,后面会说怎么去规避。

此函数作为本章内容的分析目标,这是一个非标准的ollvm，其有两个循环头

反混淆的第一步,找到函数的所有真实块。用idapython脚本处理

通过循环头我们可以直接获取到所有对应的真实块

采用广度搜索的原理实现循环头的获取

这里要处理标准fla和非标准fla的获取方式

非标准fla的循环头地址和汇聚块的地址是相等的

标准fla的循环头地址和汇聚块的地址是不相等的，其循环头的前驱只有两个基本块,一个是序言块,一个是汇聚块。

有了汇聚块,就可以通过block所属的preds()方法获得所有的前驱块,也就是它的真实块。标准fla还得注意循环头的前驱块中，需要保留序言块

这个真实块的获取也需要注意,有的会出现多个基本块的尾部指令是相同的,ida会把它单独提取出来共享,如果我们直接使用0x42288的基本块作为真实块,会出现真实块遗漏,导致反混淆的代码不全。所以这里需要取0x42288的所有前驱作为真实块。

ret块的获取

像标准fla,我们就需要0xA66C作为ret块

非标准fla,我们就需要0x42AB0作为ret块,为什么不选择0x42AC4为ret块呢?有两个原因:1.0x42AB0块中出有变量初始化的指令,如果直接选择0x42AC4,会导致反汇编后的真实代码遗漏。2.0x42AE4这条分支也没有后继。

从这里也可以引申出为社么标准fla要选择0xA66C作为ret块,如果选择0x96EC,因为0x9700分支有后继,还是会存在混淆代码，导致反混淆无效,虽然去除了一部分,但是还是无法直观分析代码。

调用后,通过颜色标记了所有的真实块

反混淆的第二步,找到函数的所有真实块连接关系。用angr处理

这里就解决前面说到的在探索路径时遇到的路径爆炸的问题,一般常出现在一个循环里带一个if条件判断,这个时候angr就会由一条路径分裂出两条路径,这两条路径分别是if为true时的路径,和为false的路径,然后继续执行循环循环,此时2条路径就会变成4条路径,继续循环,4条路径就会出现8条路径......所以遇到这种情况,路径会以指数的形式增加,最后路径会膨胀到非常大,导致程序卡死。

real_blocks是我上面获取到的所有真实块

所以接下来我采用的方式是,不让它整个程序一次性执行完,而是每次取一个真实块地址real_blocks[0],作为主块A,让其运行,当再次遇到的一个B地址在我保存的真实块地址里时我就停止运行,把这个块连接A->B保存下来。然后再取real_blocks[1]为主块,从头开始继续运行,再次遇到的一个地址在真实块地址里就停止运行。重复这个操作,我也就不用担心路径爆炸的问题,并且也会获得所有真实块的连接关系。

在一般情况下，加载程序都会将 auto_load_libs 置为 False ，这是因为如果将外部库一并加载，那么 Angr 就也会跟着一起去分析那些库了，这对性能的消耗是比较大的。

在序言块里会有许多寄存器的赋值操作,这些都是一些基本块的条件判断,通过寄存器值判断应该走哪条路径

典型的就是以基本块最后一条指令的B.EQ，B.GT等等作为判断,这些都是子分发器。

通过hook操作,当程序执行到主序言块的最后一条指令时,将pc寄存器赋值为真实块的值,这样可以避免执行大量的无用指令,减少性能消耗,节约更多的时间。

这里主要处理主序言块所有的真实块的操作,相关流程:

这个是第二个循环头的序言块,后面就叫它子序言块

这里也是一样用hook操作,改变pc寄存器的值。但是这里多了一步hook,多的 proj.hook(first_block_last_ins.address, jump_to_child_prologue_address, first_block_last_ins.size)这个hook是为了初始化子序言块里的寄存器值,因为子序言块0x42258里也有一些条件判断的寄存器赋值操作。

所以这里的流程是:

构建流程分析完了,这里就直接贴上相关脚本,脚本里也注释了相关代码的作用

反混淆的第三步,重建真实块之间的控制流。用idapython处理

重建控制流主要对两种方式进行处理

1.带csel指令的分支跳转

2.无分支跳转

脚本里写好了相关注释,这里直接贴代码

查看重建结果,可以看到已经反混淆成功了

针对上述的脚本最后也是归纳到一起了,内容较多,就不贴代码了,脚本文件会放置在github地址下载

使用的时候只需要提供函数地址即可

1.cfg图

2.cfg图

ollvm-fla的混淆围绕三大步骤展开可以实现反混淆,脚本不是全部通用,如果遇到混淆程度非常复杂的,还得需要针对性去完善相关功能。

分析样本可以用上篇文章的

相关文件下载地址:81aK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6B7K9i4g2@1K9h3q4F1y4U0j5$3i4K6u0r3P5r3c8W2k6X3I4S2i4K6u0W2k6$3W2@1

int add(int a ,int b){
    return  a+b;
}

int add(int a ,int b){

return a+b;

}

blocks = idaapi.FlowChart(idaapi.get_func(func_ea))

def find_loop_heads(func):
    loop_heads = set()
    queue = deque()
    block = get_block_by_address(func)
    queue.append((block, []))
    while len(queue) > 0:
        cur_block, path = queue.popleft()
        if cur_block.start_ea in path:
            loop_heads.add(cur_block.start_ea)
            continue
        path = path+ [cur_block.start_ea]
        queue.extend((succ, path) for succ in cur_block.succs())
    all_loop_heads = list(loop_heads)
    all_loop_heads.sort()#升序排序,保证函数开始的主循环头在第一个
    return all_loop_heads

def find_loop_heads(func):

loop_heads = set()

queue = deque()

block = get_block_by_address(func)

queue.append((block, []))

while len(queue) > 0:

cur_block, path = queue.popleft()

if cur_block.start_ea in path:

loop_heads.add(cur_block.start_ea)

continue

path = path+ [cur_block.start_ea]

queue.extend((succ, path) for succ in cur_block.succs())

all_loop_heads = list(loop_heads)

all_loop_heads.sort()#升序排序,保证函数开始的主循环头在第一个

return all_loop_heads

def find_converge_addr(loop_head_addr):
    converge_addr = None
    block = get_block_by_address(loop_head_addr)
    preds = block.preds()
    pred_list = list(preds)
    if len(pred_list) == 2:#循环头的前驱有两个基本块,这种一般是标准ollvm
        for pred in pred_list:
            tmp_list = list(pred.preds())
            if len(tmp_list) >1:#
                converge_addr = pred.start_ea
    else:#非标准ollvm
        converge_addr= loop_head_addr
    return converge_addr

def find_converge_addr(loop_head_addr):

converge_addr = None

block = get_block_by_address(loop_head_addr)

preds = block.preds()

pred_list = list(preds)

if len(pred_list) == 2:#循环头的前驱有两个基本块,这种一般是标准ollvm

for pred in pred_list:

tmp_list = list(pred.preds())

if len(tmp_list) >1:#

converge_addr = pred.start_ea

else:#非标准ollvm

converge_addr= loop_head_addr

return converge_addr

real_blocks = []
 
if loop_head_addr != converge_addr:
    loop_head_preds_addr.remove(converge_addr)#移除汇聚块,剩下的一个是序言块
    real_blocks.extend(loop_head_preds_addr)
 
converge_block = get_block_by_address(converge_addr)
list_preds = list(converge_block.preds())
for pred_block in list_preds:
    if pred_block.start_ea == loop_head_addr:#过滤循环头
        continue
    end_ea = pred_block.end_ea
    last_ins_ea = idc.prev_head(end_ea)
    mnem = idc.print_insn_mnem(last_ins_ea)  # 获取基本块最后一条指令的操作符
 
    size = get_basic_block_size(pred_block)
    if size > 4 and "B." not in mnem:
        start_ea = pred_block.start_ea
        mnem = idc.print_insn_mnem(start_ea)
        if mnem == "CSEL":
            csel_preds = pred_block.preds()
            for csel_pred in csel_preds:
                real_blocks.append(csel_pred.start_ea)
        else:
            real_blocks.append(pred_block.start_ea)

real_blocks = []

if loop_head_addr != converge_addr:

loop_head_preds_addr.remove(converge_addr)#移除汇聚块,剩下的一个是序言块

real_blocks.extend(loop_head_preds_addr)

converge_block = get_block_by_address(converge_addr)

list_preds = list(converge_block.preds())

for pred_block in list_preds:

if pred_block.start_ea == loop_head_addr:#过滤循环头

continue

end_ea = pred_block.end_ea

last_ins_ea = idc.prev_head(end_ea)

mnem = idc.print_insn_mnem(last_ins_ea) # 获取基本块最后一条指令的操作符

size = get_basic_block_size(pred_block)

if size > 4 and "B." not in mnem:

start_ea = pred_block.start_ea

mnem = idc.print_insn_mnem(start_ea)

if mnem == "CSEL":

csel_preds = pred_block.preds()

for csel_pred in csel_preds:

real_blocks.append(csel_pred.start_ea)

else:

real_blocks.append(pred_block.start_ea)

start_ea = pred_block.start_ea
mnem = idc.print_insn_mnem(start_ea)
if mnem == "CSEL":
    csel_preds = pred_block.preds()
    for csel_pred in csel_preds:
        real_blocks.append(csel_pred.start_ea)

start_ea = pred_block.start_ea

mnem = idc.print_insn_mnem(start_ea)

if mnem == "CSEL":

csel_preds = pred_block.preds()

for csel_pred in csel_preds:

real_blocks.append(csel_pred.start_ea)

from collections import deque
import idaapi
import idc
 
def get_block_by_address(ea):
    # 获取地址所在的函数
    func = idaapi.get_func(ea)
    blocks = idaapi.FlowChart(func)
    for block in blocks:
        if block.start_ea <= ea < block.end_ea:
            return block
    return None
 
def find_loop_heads(func):
    loop_heads = set()
    queue = deque()
    block = get_block_by_address(func)
    queue.append((block, []))
    while len(queue) > 0:
        cur_block, path = queue.popleft()
        if cur_block.start_ea in path:
            loop_heads.add(cur_block.start_ea)
            continue
        path = path+ [cur_block.start_ea]
        queue.extend((succ, path) for succ in cur_block.succs())
    all_loop_heads = list(loop_heads)
    all_loop_heads.sort()#升序排序,保证函数开始的主循环头在第一个
    return all_loop_heads
 
def find_converge_addr(loop_head_addr):
    converge_addr = None
    block = get_block_by_address(loop_head_addr)
    preds = block.preds()
    pred_list = list(preds)
    if len(pred_list) == 2:#循环头的前驱有两个基本块,这种一般是标准ollvm
        for pred in pred_list:
            tmp_list = list(pred.preds())
            if len(tmp_list) >1:#
                converge_addr = pred.start_ea
    else:#非标准ollvm
        converge_addr= loop_head_addr
    return converge_addr
 
def get_basic_block_size(bb):
    return bb.end_ea - bb.start_ea
 
def add_block_color(ea):
    block = get_block_by_address(ea)
    curr_addr = block.start_ea
    while curr_addr <block.end_ea:
        idc.set_color(curr_addr,idc.CIC_ITEM,0xffcc33)
        curr_addr = idc.next_head(curr_addr)
 
#清除函数中的颜色渲染
def del_func_color(curr_addr):
    end_ea = idc.find_func_end(curr_addr)
    while curr_addr < end_ea:
        idc.set_color(curr_addr, idc.CIC_ITEM, 0xffffffff)
        curr_addr = idc.next_head(curr_addr)
 
def find_ret_block_addr(blocks):
    for block in blocks:
        succs = block.succs()  # 获取后继块
        succs_list = list(succs)  # 转为list结构
 
        end_ea = block.end_ea
        last_ins_ea = idc.prev_head(end_ea)
        mnem = idc.print_insn_mnem(last_ins_ea)
 
        if len(succs_list) == 0:
            if mnem == "RET":
                # 如果直接去把RET指令所在的块作为返回块的表示 最后可能会出现反混淆代码赋值错误
                # 所以这里取RET指令的前驱块并且前驱块的大小不能只有一条指令,一般这个块都是有分支的
                ori_ret_block = block
                while True:
                    tmp_block = block.preds()
                    pred_list = list(tmp_block)
                    if len(pred_list) == 1:
                        block = pred_list[0]
                        if get_basic_block_size(block) == 4:
                            continue
                        else:
                            break
                    else:
                        break
 
                # 此处while循环是为了解决当上述的ret块作为子分发器时,需要重新更改ret块为带ret指令的块
                block2 = block
                num = 0
                i = 0
                while True:
                    i += 1
                    succs_block = block2.succs()
                    for succ in succs_block:
                        child_succs = succ.succs()
                        succ_list = list(child_succs)
                        if len(succ_list) != 0:
                            block2 = succ
                            num += 1
                    if num > 2:
                        block = ori_ret_block
                        break
                    if i > 2:
                        break
                return block.start_ea
 
def find_all_real_block(func_ea):
 
    blocks = idaapi.FlowChart(idaapi.get_func(func_ea))
 
    loop_heads = find_loop_heads(func_ea)#获取所有循环头 非标准ollvm出现在多个主分发器
    print(f"循环头数量:{len(loop_heads)}----{[hex(loop_head) for loop_head in loop_heads]}")
 
    all_real_block=[]
    for loop_head_addr in loop_heads:
        loop_head_block = get_block_by_address(loop_head_addr)#获取循环头
        loop_head_preds = list(loop_head_block.preds())#获取循环头的所有前驱块
        loop_head_preds_addr = [loop_head_pred.start_ea for loop_head_pred in loop_head_preds]#把所有前驱块转为数组
 
        converge_addr = find_converge_addr(loop_head_addr)#获取汇聚块地址
 
        real_blocks = []
 
        if loop_head_addr != converge_addr:
            loop_head_preds_addr.remove(converge_addr)#移除汇聚块,剩下的一个是序言块
            real_blocks.extend(loop_head_preds_addr)
 
        converge_block = get_block_by_address(converge_addr)
        list_preds = list(converge_block.preds())
        for pred_block in list_preds:     
            end_ea = pred_block.end_ea
            last_ins_ea = idc.prev_head(end_ea)
            mnem = idc.print_insn_mnem(last_ins_ea)  # 获取基本块最后一条指令的操作符
 
            size = get_basic_block_size(pred_block)
            if size > 4 and "B." not in mnem:
                start_ea = pred_block.start_ea
                mnem = idc.print_insn_mnem(start_ea)
                if mnem == "CSEL":
                    csel_preds = pred_block.preds()
                    for csel_pred in csel_preds:
                        real_blocks.append(csel_pred.start_ea)
                else:
                    real_blocks.append(pred_block.start_ea)
 
        real_blocks.sort()#排序后第一个元素始终序言块
        all_real_block.append(real_blocks)
        print("子循环头:", [hex(child_block_ea) for child_block_ea in real_blocks])
 
    #获取return块
    ret_addr = find_ret_block_addr(blocks)
    all_real_block.append(ret_addr)
    print("all_real_block:",all_real_block)
 
    all_real_block_list = []
    for real_blocks in all_real_block:
        if isinstance(real_blocks, list):  # 如果是列表，用 extend
            all_real_block_list.extend(real_blocks)
        else:  # 如果不是列表，用 append
            all_real_block_list.append(real_blocks)
 
    for real_block_ea in all_real_block_list:
        # idc.add_bpt(real_block_ea)#断点
        add_block_color(real_block_ea)#渲染颜色
 
    print("\n所有真实块获取完成")
    print("===========INT===============")
    print(all_real_block_list)
    print("===========HEX===============")
    print(f"数量:{len(all_real_block_list)}")
    print([hex(real_block_ea) for real_block_ea in all_real_block_list],"\n")
 
    #移除ret地址和主序言块相关真实块,保留子序言块相关的真实块
    all_child_prologue_addr = all_real_block.copy()
    all_child_prologue_addr.remove(ret_addr)
    all_child_prologue_addr.remove(all_child_prologue_addr[0])
    print("所有子序言块相关的真实块地址:",all_child_prologue_addr)
 
    all_child_prologue_last_ins_ea = []
    for child_prologue_array in all_child_prologue_addr:
        child_prologue_addr = child_prologue_array[0]
        child_prologue_block = get_block_by_address(child_prologue_addr)
        child_prologue_end_ea = child_prologue_block.end_ea
        child_prologue_last_ins_ea = idc.prev_head(child_prologue_end_ea)
        all_child_prologue_last_ins_ea.append(child_prologue_last_ins_ea)
    # print("所有子序言块的最后一条指令的地址:", [hex(ea) for ea in all_child_prologue_last_ins_ea])
    print("所有子序言块的最后一条指令的地址:", all_child_prologue_last_ins_ea)
    return all_real_block,all_child_prologue_addr,all_child_prologue_last_ins_ea
 
func_ea = 0x41D08
reals = find_all_real_block(func_ea)

from collections import deque

import idaapi

import idc

def get_block_by_address(ea):

# 获取地址所在的函数

func = idaapi.get_func(ea)

blocks = idaapi.FlowChart(func)

for block in blocks:

if block.start_ea <= ea < block.end_ea:

return block

return None

def find_loop_heads(func):

loop_heads = set()

queue = deque()

block = get_block_by_address(func)

queue.append((block, []))

while len(queue) > 0:

cur_block, path = queue.popleft()

if cur_block.start_ea in path:

loop_heads.add(cur_block.start_ea)

continue

path = path+ [cur_block.start_ea]

queue.extend((succ, path) for succ in cur_block.succs())

all_loop_heads = list(loop_heads)

all_loop_heads.sort()#升序排序,保证函数开始的主循环头在第一个

return all_loop_heads

def find_converge_addr(loop_head_addr):

converge_addr = None

block = get_block_by_address(loop_head_addr)

preds = block.preds()

pred_list = list(preds)

if len(pred_list) == 2:#循环头的前驱有两个基本块,这种一般是标准ollvm

for pred in pred_list:

tmp_list = list(pred.preds())

if len(tmp_list) >1:#

converge_addr = pred.start_ea

else:#非标准ollvm

converge_addr= loop_head_addr

return converge_addr

def get_basic_block_size(bb):

return bb.end_ea - bb.start_ea

def add_block_color(ea):

block = get_block_by_address(ea)

curr_addr = block.start_ea

while curr_addr <block.end_ea:

idc.set_color(curr_addr,idc.CIC_ITEM,0xffcc33)

curr_addr = idc.next_head(curr_addr)

#清除函数中的颜色渲染

def del_func_color(curr_addr):

end_ea = idc.find_func_end(curr_addr)

while curr_addr < end_ea:

idc.set_color(curr_addr, idc.CIC_ITEM, 0xffffffff)

curr_addr = idc.next_head(curr_addr)

def find_ret_block_addr(blocks):

for block in blocks:

succs = block.succs() # 获取后继块

succs_list = list(succs) # 转为list结构

end_ea = block.end_ea

last_ins_ea = idc.prev_head(end_ea)

mnem = idc.print_insn_mnem(last_ins_ea)

if len(succs_list) == 0:

if mnem == "RET":

# 如果直接去把RET指令所在的块作为返回块的表示最后可能会出现反混淆代码赋值错误

# 所以这里取RET指令的前驱块并且前驱块的大小不能只有一条指令,一般这个块都是有分支的

ori_ret_block = block

while True:

tmp_block = block.preds()

pred_list = list(tmp_block)

if len(pred_list) == 1:

block = pred_list[0]

if get_basic_block_size(block) == 4:

continue

else:

break

else:

break

# 此处while循环是为了解决当上述的ret块作为子分发器时,需要重新更改ret块为带ret指令的块

block2 = block

num = 0

i = 0

while True:

i += 1

succs_block = block2.succs()

for succ in succs_block:

child_succs = succ.succs()

succ_list = list(child_succs)

if len(succ_list) != 0:

block2 = succ

num += 1

if num > 2:

block = ori_ret_block

break

if i > 2:

break

return block.start_ea

def find_all_real_block(func_ea):

blocks = idaapi.FlowChart(idaapi.get_func(func_ea))

loop_heads = find_loop_heads(func_ea)#获取所有循环头非标准ollvm出现在多个主分发器

print(f"循环头数量:{len(loop_heads)}----{[hex(loop_head) for loop_head in loop_heads]}")

all_real_block=[]

for loop_head_addr in loop_heads:

loop_head_block = get_block_by_address(loop_head_addr)#获取循环头

loop_head_preds = list(loop_head_block.preds())#获取循环头的所有前驱块

loop_head_preds_addr = [loop_head_pred.start_ea for loop_head_pred in loop_head_preds]#把所有前驱块转为数组

converge_addr = find_converge_addr(loop_head_addr)#获取汇聚块地址

real_blocks = []

if loop_head_addr != converge_addr:

loop_head_preds_addr.remove(converge_addr)#移除汇聚块,剩下的一个是序言块

real_blocks.extend(loop_head_preds_addr)

converge_block = get_block_by_address(converge_addr)

list_preds = list(converge_block.preds())

for pred_block in list_preds:

end_ea = pred_block.end_ea

last_ins_ea = idc.prev_head(end_ea)

mnem = idc.print_insn_mnem(last_ins_ea) # 获取基本块最后一条指令的操作符

size = get_basic_block_size(pred_block)

if size > 4 and "B." not in mnem:

start_ea = pred_block.start_ea

mnem = idc.print_insn_mnem(start_ea)

if mnem == "CSEL":

csel_preds = pred_block.preds()

for csel_pred in csel_preds:

real_blocks.append(csel_pred.start_ea)

else:

real_blocks.append(pred_block.start_ea)

real_blocks.sort()#排序后第一个元素始终序言块

all_real_block.append(real_blocks)

print("子循环头:", [hex(child_block_ea) for child_block_ea in real_blocks])

#获取return块

ret_addr = find_ret_block_addr(blocks)

all_real_block.append(ret_addr)

print("all_real_block:",all_real_block)

all_real_block_list = []

for real_blocks in all_real_block:

if isinstance(real_blocks, list): # 如果是列表，用 extend

all_real_block_list.extend(real_blocks)

else: # 如果不是列表，用 append

all_real_block_list.append(real_blocks)

for real_block_ea in all_real_block_list:

# idc.add_bpt(real_block_ea)#断点

add_block_color(real_block_ea)#渲染颜色

print("\n所有真实块获取完成")

print("===========INT===============")

print(all_real_block_list)

print("===========HEX===============")

print(f"数量:{len(all_real_block_list)}")

print([hex(real_block_ea) for real_block_ea in all_real_block_list],"\n")

#移除ret地址和主序言块相关真实块,保留子序言块相关的真实块

all_child_prologue_addr = all_real_block.copy()

all_child_prologue_addr.remove(ret_addr)

all_child_prologue_addr.remove(all_child_prologue_addr[0])

print("所有子序言块相关的真实块地址:",all_child_prologue_addr)

all_child_prologue_last_ins_ea = []

for child_prologue_array in all_child_prologue_addr:

child_prologue_addr = child_prologue_array[0]

child_prologue_block = get_block_by_address(child_prologue_addr)

child_prologue_end_ea = child_prologue_block.end_ea

child_prologue_last_ins_ea = idc.prev_head(child_prologue_end_ea)

all_child_prologue_last_ins_ea.append(child_prologue_last_ins_ea)

# print("所有子序言块的最后一条指令的地址:", [hex(ea) for ea in all_child_prologue_last_ins_ea])

print("所有子序言块的最后一条指令的地址:", all_child_prologue_last_ins_ea)

return all_real_block,all_child_prologue_addr,all_child_prologue_last_ins_ea

func_ea = 0x41D08

reals = find_all_real_block(func_ea)

proj = angr.Project(file_path, auto_load_libs=False)#加载so
base = proj.loader.min_addr#so基地址
func_addr = base + func_offset#函数地址
init_state = proj.factory.blank_state(addr=func_addr)#获取函数地址状态
init_state.options.add(angr.options.CALLLESS)

proj = angr.Project(file_path, auto_load_libs=False)#加载so

base = proj.loader.min_addr#so基地址

回复或点赞可查看完整内容

[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课

最后于 2025-4-21 01:24 被九天666编辑，原因：

#混淆加固 #脱壳反混淆 #源码框架 #工具脚本

收藏・170

免费・125

支持

赞赏记录

参与人

雪币

留言

时间

浮夸进进

感谢你的积极参与，期待更多精彩内容！

13小时前

ngiokweng

感谢你的贡献，论坛因你而更加精彩！

1天前

老小白

感谢你的积极参与，期待更多精彩内容！

1天前

houjingyi

你的帖子非常有用，感谢分享！

1天前

逆天而行

期待更多优质内容的分享，论坛有你更精彩！

4天前

nothing233

感谢你分享这么好的资源！

4天前

mb_rwavajxh

感谢你的贡献，论坛因你而更加精彩！

4天前

mb_cfhozukd

感谢你的贡献，论坛因你而更加精彩！

5天前

Gift1a

谢谢你的细致分析，受益匪浅！

5天前

mb_nazusqig

为你点赞！

6天前

braintrust

非常支持你的观点！

6天前

Mars@PDlabs

为你点赞！

2025-6-9 15:58

mb_bcgnztsa

谢谢你的细致分析，受益匪浅！

2025-6-9 15:31

mb_hwynyvpk

这个讨论对我很有帮助，谢谢！

2025-6-9 07:40

太岁又沐风

感谢你分享这么好的资源！

2025-6-6 17:54

马来

谢谢你的细致分析，受益匪浅！

2025-5-30 21:20

wx_funcrever

你的帖子非常有用，感谢分享！

2025-5-27 14:55

疯子Tear

感谢你分享这么好的资源！

2025-5-27 14:44

清风jw

你的分享对大家帮助很大，非常感谢！

2025-5-27 11:30

AEVE

感谢你的积极参与，期待更多精彩内容！

2025-5-27 09:34

mb_qvxwrrpg

为你点赞！

2025-5-26 00:01

NPC2000

感谢你分享这么好的资源！

2025-5-25 00:00

周游列国

感谢你分享这么好的资源！

2025-5-24 23:08

青史无疆

谢谢你的细致分析，受益匪浅！

2025-5-24 14:48

longerp

你的分享对大家帮助很大，非常感谢！

2025-5-24 10:23

konf

感谢你的积极参与，期待更多精彩内容！

2025-5-24 09:41

帝星捧月

期待更多优质内容的分享，论坛有你更精彩！

2025-5-23 15:42

mb_uktygsmq

谢谢你的细致分析，受益匪浅！

2025-5-22 21:08

东方玻璃

感谢你的贡献，论坛因你而更加精彩！

2025-5-22 19:36

b!@nk

感谢你分享这么好的资源！

2025-5-22 16:53

wx_Q道长

为你点赞！

2025-5-22 16:44

str1k3

感谢你的积极参与，期待更多精彩内容！

2025-5-21 11:50

coreofthesun

你的分享对大家帮助很大，非常感谢！

2025-5-21 11:48

nulles

你的分享对大家帮助很大，非常感谢！

2025-5-20 19:29

git_79471guojiangFighting

感谢你的贡献，论坛因你而更加精彩！

2025-5-20 18:30

醉染

这个讨论对我很有帮助，谢谢！

2025-5-20 09:42

mb_iprwpcbb

你的帖子非常有用，感谢分享！

2025-5-19 17:12

祝今朝

你的帖子非常有用，感谢分享！

2025-5-19 12:30

方北七

你的分享对大家帮助很大，非常感谢！

2025-5-15 22:01

是气球呀

谢谢你的细致分析，受益匪浅！

2025-5-15 14:27

just赋予

这个讨论对我很有帮助，谢谢！

2025-5-14 14:39

Steesha

非常支持你的观点！

2025-5-13 21:48

wx_Kiyose

你的分享对大家帮助很大，非常感谢！

2025-5-13 14:10

falconnnn

非常支持你的观点！

2025-5-13 10:41

櫬木汐

感谢你的贡献，论坛因你而更加精彩！

2025-5-12 20:56

sergiojune

为你点赞！

2025-5-12 16:53

Hur1k

谢谢你的细致分析，受益匪浅！

2025-5-12 16:35

kishou_yusa

感谢你的贡献，论坛因你而更加精彩！

2025-5-12 10:15

linkin5epk

期待更多优质内容的分享，论坛有你更精彩！

2025-5-11 23:04

黄小黑

你的分享对大家帮助很大，非常感谢！

2025-5-10 22:19

juice4fun

非常支持你的观点！

2025-5-9 16:34

轻快笑着行

你的帖子非常有用，感谢分享！

2025-5-8 11:16

快乐的小跳蛙

非常支持你的观点！

2025-5-8 09:22

musktime

期待更多优质内容的分享，论坛有你更精彩！

2025-5-7 16:51

tlsn

感谢你的积极参与，期待更多精彩内容！

2025-5-7 09:32

BlueEffie

这个讨论对我很有帮助，谢谢！

2025-5-6 18:50

mb_qqnashwi

你的帖子非常有用，感谢分享！

2025-5-4 19:08

小秃秃驴

感谢你分享这么好的资源！

2025-5-4 15:12

炸鸡真好吃

感谢你分享这么好的资源！

2025-5-3 08:47

jw8888

非常支持你的观点！

2025-5-3 02:53

Qira

谢谢你的细致分析，受益匪浅！

2025-5-1 22:16

拾海

你的帖子非常有用，感谢分享！

2025-5-1 10:30

dsr000

感谢你分享这么好的资源！

2025-5-1 09:22

自己能

你的分享对大家帮助很大，非常感谢！

2025-4-28 17:59

richor

非常支持你的观点！

2025-4-28 17:37

yezheyu

这个讨论对我很有帮助，谢谢！

2025-4-28 15:37

mb_dtidoewd

为你点赞！

2025-4-28 14:19

Shangwendada

为你点赞！

2025-4-28 10:23

wx_益达

你的分享对大家帮助很大，非常感谢！

2025-4-28 10:21

Dr_Knox

你的帖子非常有用，感谢分享！

2025-4-27 20:00

沈聽白

你的帖子非常有用，感谢分享！

2025-4-27 15:32

梓曰

为你点赞！

2025-4-27 14:28

hbji

感谢你的贡献，论坛因你而更加精彩！

2025-4-27 11:32

奇奇怪怪

感谢你的贡献，论坛因你而更加精彩！

2025-4-27 10:33

crackwiki

为你点赞！

2025-4-26 19:49

陈可牛

感谢你的积极参与，期待更多精彩内容！

2025-4-26 19:24

wx_嗨

感谢你的积极参与，期待更多精彩内容！

2025-4-25 18:12

lrhtony

你的分享对大家帮助很大，非常感谢！

2025-4-25 17:18

软件君子

你的分享对大家帮助很大，非常感谢！

2025-4-25 14:40

mb_ygbywaup

谢谢你的细致分析，受益匪浅！

2025-4-25 10:30

nevinhappy

感谢你的贡献，论坛因你而更加精彩！

2025-4-24 19:32

wx_byte

为你点赞！

2025-4-24 17:53

混

你的分享对大家帮助很大，非常感谢！

2025-4-24 10:39

你瞒我瞒

感谢你分享这么好的资源！

2025-4-24 09:20

wx_十二_866

你的帖子非常有用，感谢分享！

2025-4-24 09:02

神逗士

这个讨论对我很有帮助，谢谢！

2025-4-24 00:32

冲冲冲

感谢你分享这么好的资源！

2025-4-23 22:50

哈哥

为你点赞！

2025-4-23 21:18

天水姜伯约

感谢你的贡献，论坛因你而更加精彩！

2025-4-23 19:32

git_23169ayanerusakura

非常支持你的观点！

2025-4-23 18:50

wx_SKY_105

为你点赞！

2025-4-23 11:28

gusong

感谢你分享这么好的资源！

2025-4-23 09:59

yhock

感谢你的积极参与，期待更多精彩内容！

2025-4-23 09:26

mb_rveckyle

你的帖子非常有用，感谢分享！

2025-4-22 15:36

mb_ifqtwleh

感谢你分享这么好的资源！

2025-4-22 13:37

mb_bppcorlj

为你点赞！

2025-4-22 11:39

Ram98

为你点赞！

2025-4-22 10:49

wogao

谢谢你的细致分析，受益匪浅！

2025-4-22 10:43

mb_dajiayec

为你点赞！

2025-4-22 09:48

qqizai

感谢你的贡献，论坛因你而更加精彩！

2025-4-22 09:19

怜渠客

感谢你的贡献，论坛因你而更加精彩！

2025-4-22 08:53

沫水.

你的分享对大家帮助很大，非常感谢！

2025-4-21 20:19

陈某人

感谢你分享这么好的资源！

2025-4-21 20:18

龙飞雪

感谢你的贡献，论坛因你而更加精彩！

2025-4-21 18:56

doduhuang

期待更多优质内容的分享，论坛有你更精彩！

2025-4-21 18:12

涙涙涙

期待更多优质内容的分享，论坛有你更精彩！

2025-4-21 17:25

梦_魇

非常支持你的观点！

2025-4-21 17:18

顽劣

为你点赞！

2025-4-21 16:02

熊趴趴来

感谢你的积极参与，期待更多精彩内容！

2025-4-21 15:42

huangyalei

感谢你分享这么好的资源！

2025-4-21 12:50

New对象处

你的分享对大家帮助很大，非常感谢！

2025-4-21 11:36

Je2em1ah

感谢你的积极参与，期待更多精彩内容！

2025-4-21 11:12

岁月。

这个讨论对我很有帮助，谢谢！

2025-4-21 10:33

令狐双

感谢你分享这么好的资源！

2025-4-21 10:24

mb_wpitiize

期待更多优质内容的分享，论坛有你更精彩！

2025-4-21 10:15

mb_nymhrhcn

这个讨论对我很有帮助，谢谢！

2025-4-21 10:14

sossai

谢谢你的细致分析，受益匪浅！

2025-4-21 10:10

mryoufx

感谢你的积极参与，期待更多精彩内容！

2025-4-21 10:08

cppasm

这个讨论对我很有帮助，谢谢！

2025-4-21 09:49

mb_asiwnxyv

为你点赞！

2025-4-21 09:48

mb_ryldhvhu

非常支持你的观点！

2025-4-21 09:43

逆向狗都不学

谢谢你的细致分析，受益匪浅！

2025-4-21 09:38

cobe

这个讨论对我很有帮助，谢谢！

2025-4-21 09:32

wx_ㅤ_683

感谢你的积极参与，期待更多精彩内容！

2025-4-21 09:11

pexillove

期待更多优质内容的分享，论坛有你更精彩！

2025-4-21 07:43

最新回复 (86) 1 2 3 4 ▶
wx_插曲雪币： 20 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 48 粉丝 0 关注私信	wx_插曲 2 楼牛逼大佬 2025-4-21 05:31 0
fireworld 雪币： 590 活跃值： (1462) 能力值： ( LV2，RANK：10 ) 在线值：发帖 7 回帖 351 粉丝 1 关注私信	fireworld 3 楼感谢楼主分享 2025-4-21 06:01 0
mb_vjpiriil 雪币： 70 活跃值： (731) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 16 粉丝 0 关注私信	mb_vjpiriil 4 楼 666 2025-4-21 06:32 0
fujing 雪币： 3464 活跃值： (4924) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 119 粉丝 4 关注私信	fujing 5 楼看看技术贴 2025-4-21 07:34 0
猫子雪币： 439 活跃值： (1903) 能力值： ( LV3，RANK：30 ) 在线值：发帖 5 回帖 358 粉丝 2 关注私信	猫子 6 楼学习一下 2025-4-21 07:44 0
丶咖啡猫丶雪币： 2148 活跃值： (2012) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 67 粉丝 0 关注私信	丶咖啡猫丶 7 楼大佬666 2025-4-21 09:19 0
cobe 雪币： 148 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 28 粉丝 0 关注私信	cobe 8 楼 666 2025-4-21 09:32 0
mb_ncfbmciq 雪币： 16 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 3 粉丝 0 关注私信	mb_ncfbmciq 9 楼大佬牛B 2025-4-21 09:36 0
mb_erlnpqnh 雪币： 2 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 11 粉丝 0 关注私信	mb_erlnpqnh 10 楼 666 2025-4-21 09:37 0
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 341 粉丝 3 关注私信	mb_ldbucrik 11 楼感谢分享，大佬yyds 2025-4-21 09:52 0
4Chan 雪币： 375 活跃值： (2676) 能力值： ( LV3，RANK：30 ) 在线值：发帖 9 回帖 56 粉丝 12 关注私信	4Chan 12 楼 666 2025-4-21 09:55 0
MaYil 雪币： 7761 活跃值： (5157) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 287 粉丝 2 关注私信	MaYil 13 楼感谢分享 2025-4-21 10:25 0
西瓜帅雪币： 721 活跃值： (1462) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 23 粉丝 1 关注私信	西瓜帅 14 楼感谢分享 2025-4-21 11:10 0
uni7corn 雪币：活跃值： (935) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 26 粉丝 0 关注私信	uni7corn 15 楼感谢分享 2025-4-21 11:36 0
dextoart 雪币： 16 活跃值： (1177) 能力值： ( LV2，RANK：10 ) 在线值：发帖 4 回帖 42 粉丝 4 关注私信	dextoart 16 楼 666 2025-4-21 13:04 0
A冷忆雪币： 3 活跃值： (711) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 17 粉丝 3 关注私信	A冷忆 17 楼 666 2025-4-21 13:13 0
wulibeiai 雪币： 180 活跃值： (816) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 5 粉丝 1 关注私信	wulibeiai 18 楼 666 2025-4-21 13:28 0
ptr1234565 雪币： 716 活跃值： (1010) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 2 粉丝 0 关注私信	ptr1234565 19 楼 666 2025-4-21 14:39 0
New对象处雪币： 119 活跃值： (5392) 能力值： ( LV3，RANK：20 ) 在线值：发帖 4 回帖 151 粉丝 20 关注私信	New对象处 20 楼 6 2025-4-21 14:45 0
mb_cbgtaveo 雪币： 90 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 39 粉丝 0 关注私信	mb_cbgtaveo 21 楼 66666666666 2025-4-21 15:43 0
风远丶扬雪币： 229 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 3 粉丝 0 关注私信	风远丶扬 22 楼 666 2025-4-21 17:21 1
koflfy 雪币： 102 活跃值： (2785) 能力值： ( LV4，RANK：50 ) 在线值：发帖 8 回帖 415 粉丝 5 关注私信	koflfy 1 23 楼大佬牛逼 2025-4-21 17:29 0
hacker521 雪币： 1449 活跃值： (2716) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 130 粉丝 29 关注私信	hacker521 24 楼牛逼大佬 2025-4-21 17:36 0
Imxz 雪币： 104 活跃值： (5701) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 208 粉丝 5 关注私信	Imxz 25 楼太牛了哥们 2025-4-21 18:03 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

九天666

发帖

回帖

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (86) 1 2 3 4 ▶
wx_插曲雪币： 20 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 48 粉丝 0 关注私信	wx_插曲 2 楼牛逼大佬 2025-4-21 05:31 0
fireworld 雪币： 590 活跃值： (1462) 能力值： ( LV2，RANK：10 ) 在线值：发帖 7 回帖 351 粉丝 1 关注私信	fireworld 3 楼感谢楼主分享 2025-4-21 06:01 0
mb_vjpiriil 雪币： 70 活跃值： (731) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 16 粉丝 0 关注私信	mb_vjpiriil 4 楼 666 2025-4-21 06:32 0
fujing 雪币： 3464 活跃值： (4924) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 119 粉丝 4 关注私信	fujing 5 楼看看技术贴 2025-4-21 07:34 0
猫子雪币： 439 活跃值： (1903) 能力值： ( LV3，RANK：30 ) 在线值：发帖 5 回帖 358 粉丝 2 关注私信	猫子 6 楼学习一下 2025-4-21 07:44 0
丶咖啡猫丶雪币： 2148 活跃值： (2012) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 67 粉丝 0 关注私信	丶咖啡猫丶 7 楼大佬666 2025-4-21 09:19 0
cobe 雪币： 148 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 28 粉丝 0 关注私信	cobe 8 楼 666 2025-4-21 09:32 0
mb_ncfbmciq 雪币： 16 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 3 粉丝 0 关注私信	mb_ncfbmciq 9 楼大佬牛B 2025-4-21 09:36 0
mb_erlnpqnh 雪币： 2 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 11 粉丝 0 关注私信	mb_erlnpqnh 10 楼 666 2025-4-21 09:37 0
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 341 粉丝 3 关注私信	mb_ldbucrik 11 楼感谢分享，大佬yyds 2025-4-21 09:52 0
4Chan 雪币： 375 活跃值： (2676) 能力值： ( LV3，RANK：30 ) 在线值：发帖 9 回帖 56 粉丝 12 关注私信	4Chan 12 楼 666 2025-4-21 09:55 0
MaYil 雪币： 7761 活跃值： (5157) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 287 粉丝 2 关注私信	MaYil 13 楼感谢分享 2025-4-21 10:25 0
西瓜帅雪币： 721 活跃值： (1462) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 23 粉丝 1 关注私信	西瓜帅 14 楼感谢分享 2025-4-21 11:10 0
uni7corn 雪币：活跃值： (935) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 26 粉丝 0 关注私信	uni7corn 15 楼感谢分享 2025-4-21 11:36 0
dextoart 雪币： 16 活跃值： (1177) 能力值： ( LV2，RANK：10 ) 在线值：发帖 4 回帖 42 粉丝 4 关注私信	dextoart 16 楼 666 2025-4-21 13:04 0
A冷忆雪币： 3 活跃值： (711) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 17 粉丝 3 关注私信	A冷忆 17 楼 666 2025-4-21 13:13 0
wulibeiai 雪币： 180 活跃值： (816) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 5 粉丝 1 关注私信	wulibeiai 18 楼 666 2025-4-21 13:28 0
ptr1234565 雪币： 716 活跃值： (1010) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 2 粉丝 0 关注私信	ptr1234565 19 楼 666 2025-4-21 14:39 0
New对象处雪币： 119 活跃值： (5392) 能力值： ( LV3，RANK：20 ) 在线值：发帖 4 回帖 151 粉丝 20 关注私信	New对象处 20 楼 6 2025-4-21 14:45 0
mb_cbgtaveo 雪币： 90 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 39 粉丝 0 关注私信	mb_cbgtaveo 21 楼 66666666666 2025-4-21 15:43 0
风远丶扬雪币： 229 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 3 粉丝 0 关注私信	风远丶扬 22 楼 666 2025-4-21 17:21 1
koflfy 雪币： 102 活跃值： (2785) 能力值： ( LV4，RANK：50 ) 在线值：发帖 8 回帖 415 粉丝 5 关注私信	koflfy 1 23 楼大佬牛逼 2025-4-21 17:29 0
hacker521 雪币： 1449 活跃值： (2716) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 130 粉丝 29 关注私信	hacker521 24 楼牛逼大佬 2025-4-21 17:36 0
Imxz 雪币： 104 活跃值： (5701) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 208 粉丝 5 关注私信	Imxz 25 楼太牛了哥们 2025-4-21 18:03 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复