[原创]某手反混淆识别与处理-Android安全-看雪安全社区

## 0x00 起因

最近在分析某手 Android 应用的一个 so 库时,发现里面大量函数使用了 `BR Xn` 这种寄存器间接跳转,而 `Xn` 的值不是简单赋值,而是通过一段专门构造的算术指令现算出来的。IDA 静态分析走到这种跳转就直接断了,F5 也出不了完整的伪代码。这篇笔记记录一下从发现特征、写脚本批量识别、到最终让 Hex-Rays 正常反编译的完整过程。

## 0x01 特征观察

拖进 IDA 之后,挑一个典型样本看:

```asm
.text:0000000000030010 Java_com_kjmp_framework_kjbox_j_n_a13
.text:0000000000030010                 STP             X0, X1, [SP,#var_20]!
.text:0000000000030014                 STP             X2, X30, [SP,#0x20+var_10]
.text:0000000000030018                 ADR             X1, qword_30038
.text:000000000003001C                 SUBS            X1, X1, #8
.text:0000000000030020                 MOV             X0, X1
.text:0000000000030024                 ADDS            X0, X0, #0x28
.text:0000000000030028                 STR             X0, [SP,#0x20+var_8]
.text:000000000003002C                 LDP             X2, X9, [SP,#0x20+var_10]
.text:0000000000030030                 LDP             X0, X1, [SP+0x20+var_20],#0x20
.text:0000000000030034                 BR              X9
.text:0000000000030038 qword_30038     DCQ 0x471E8E9763717214, 0xA70D17E1852B7BA3, ...
.text:0000000000030058 loc_30058       MOV             W8, #0x1B4C
...
```

关键的五条指令:

```asm
ADR   Xn, label     ; 取一个常量地址
SUBS  Xn, Xn, #imm  ; 减去一个立即数
MOV   Xm, Xn        ; 挪到另一个寄存器
ADDS  Xm, Xm, #off  ; 再加一个立即数
...
BR    Xk            ; 跳到 Xk 里算出来的地址
```

手推一下:`ADR` 拿到的是 `label` 的地址,减去 `imm`、加上 `off`,最终 `BR` 要跳的地址其实就是:

```
real_target = label - imm + offset
```

带进上面的例子:`label = 0x30038`,`imm = 8`,`offset = 0x28`,算出来 `real_target = 0x30038 - 8 + 0x28 = 0x30058`,正好是后面那段被数据块隔开的 `loc_30058`。也就是说,这段常量本身没什么实际意义,纯粹是用来在静态分析阶段藏住真实跳转目标的障眼法。

## 0x02 写脚本批量识别

人工一个个算显然不现实,写了个 IDAPython 脚本全局扫描,按上面五条指令的寄存器数据流关系做匹配:`ADR` 写的寄存器要能在 `SUBS` 里被读到,`SUBS` 写的寄存器要能在 `MOV` 里被读到,以此类推,最后在 `ADDS` 之后一定范围内找到 `BR`,算出 `real_target`,直接把地址标记在注释里。

```python
import idautils
import idc
import idaapi

def find_obfuscated_jumps_global():
    # 获取 .text 段的范围
    start_ea = idaapi.BADADDR
    end_ea = idaapi.BADADDR

# 遍历所有段，寻找代码段
    for seg_ea in idautils.Segments():
        seg_name = idc.get_segm_name(seg_ea)
        # 匹配常见的代码段名称
        if seg_name in [".text", "__text", "CODE"]:
            start_ea = idc.get_segm_start(seg_ea)
            end_ea = idc.get_segm_end(seg_ea)
            break
    
    # 如果没找到特定名称的段，则手动寻找第一个有执行权限的段
    if start_ea == idaapi.BADADDR:
        for seg_ea in idautils.Segments():
            if idc.get_segm_attr(seg_ea, idc.SEGATTR_PERM) & 1: # 1 = Executable
                start_ea = idc.get_segm_start(seg_ea)
                end_ea = idc.get_segm_end(seg_ea)
                print(f"[*] 未找到 .text，自动选择执行段: {idc.get_segm_name(seg_ea)}")
                break

if start_ea == idaapi.BADADDR:
        print("[!] 错误：找不到任何可执行的代码段。")
        return

print(f"[*] 开始全局扫描范围: {hex(start_ea)} - {hex(end_ea)}")
    scan_range(start_ea, end_ea)

def scan_range(start_ea, end_ea):
    found_count = 0
    curr = start_ea
    
    while curr < end_ea:
        # 特征 1: ADR Xn, <label>
        if idc.print_insn_mnem(curr) == "ADR":
            reg_dest = idc.get_operand_value(curr, 0)
            label_addr = idc.get_operand_value(curr, 1)
            
            # 特征 2: SUBS Xn, Xn, #imm
            p2 = idc.next_head(curr)
            if idc.print_insn_mnem(p2) == "SUBS" and idc.get_operand_value(p2, 1) == reg_dest:
                sub_val = idc.get_operand_value(p2, 2)
                
                # 特征 3: MOV Xm, Xn
                p3 = idc.next_head(p2)
                if idc.print_insn_mnem(p3) == "MOV" and idc.get_operand_value(p3, 1) == reg_dest:
                    reg_calc = idc.get_operand_value(p3, 0)
                    
                    # 特征 4: ADDS Xm, Xm, #offset
                    p4 = idc.next_head(p3)
                    if idc.print_insn_mnem(p4) == "ADDS" and idc.get_operand_value(p4, 1) == reg_calc:
                        offset_val = idc.get_operand_value(p4, 2)
                        
                        # 特征 5: 搜索后续的 BR 指令
                        br_addr = find_br_instruction(p4, 15)
                        
                        if br_addr:
                            # 公式计算：Target = Label - SubValue + Offset
                            real_target = label_addr - sub_val + offset_val
                            
                            print(f"[+] 匹配成功 @ {hex(curr)} -> 目标: {hex(real_target)}")
                            
                            # 辅助标记
                            idc.set_cmt(curr, f"Pattern Start: Target -> {hex(real_target)}", 0)
                            idc.set_cmt(br_addr, f"Jump to: {hex(real_target)}", 0)
                            # 设置背景颜色（淡蓝色 0xFFFFCC）
                            idc.set_color(curr, idc.CIC_ITEM, 0xFFFFCC)
                            
                            found_count += 1
                            curr = br_addr # 匹配成功后跳到 BR 指令继续
        
        curr = idc.next_head(curr)
    
    print(f"[*] 扫描结束，共发现 {found_count} 处特征。")

def find_br_instruction(start_ea, limit):
    temp = start_ea
    for _ in range(limit):
        temp = idc.next_head(temp)
        if temp == idc.BADADDR:
            break
        if idc.print_insn_mnem(temp) == "BR":
            return temp
    return None

if __name__ == "__main__":
    find_obfuscated_jumps_global()
```

跑起来之后,所有匹配到的位置都会打印出类似:

```
[+] 匹配成功 @ 0x30018 -> 目标: 0x30058 (BR @ 0x30034)
```

同时会在 `ADR` 处和 `BR` 处打上注释,`ADR` 那行背景标成淡黄色方便肉眼定位,`BR` 那行注明真实跳转地址。

## 0x03 想直接反编译,按 P 建函数失败

标记归标记,想让 Hex-Rays 正常出伪代码,还得先把 `BR Xn` 换成 `B real_target`,再让 IDA 把整个函数结构建对。

第一步不难,`BR` 换成 `B` 直接改字节码:根据 AArch64 的 `B` 指令编码(`imm26` 是相对当前地址的偏移,单位 4 字节,范围 ±128MB),算出 `imm26 = (real_target - br_ea) / 4`,拼出 `0x14000000 | (imm26 & 0x3FFFFFF)` 写回去就行。

问题出在第二步。把 `BR` patch 成 `B` 之后,选中整个函数范围按 P 建函数,IDA 直接报:

```
Command "MakeFunction" failed
```

原因是函数体中间被混淆器插了一段纯数据(就是前面 `ADR` 引用的那个常量池 `qword_30038`),`MakeFunction` 只认连续的代码字节区间,中间夹着数据就直接拒绝,不会跳过。

## 0x04 用 function tail chunk 解决

IDA 的函数模型本身支持"一个函数由不连续的几段代码组成":一个 owner chunk(主块)加若干个 tail chunk(尾块)。编译器优化(尾部合并、switch 分支散落各处)和这种人为插入数据的混淆手法都会用到这套机制,只是平时写"正常"代码基本碰不上。

解法就是不再指望 `MakeFunction` 一次性建完整个函数,而是分两步:

1. 把补丁后单独露出来的那条 `B` 指令(被数据块和"End of function"标记隔开,自己也是孤儿)挂到主函数上
2. 把数据块之后真正的跳转目标代码,也作为 tail chunk 挂到同一个主函数上

用到的核心 API 是 `ida_funcs.append_func_tail`。挂载完之后再对函数调用一次 `ida_funcs.reanalyze_function`,让 IDA 重新计算控制流图。

再按 F5,伪代码就正常出来了:

![](upload/attach/202607/922433_DW2YE5PZF78ACVC.webp)

这里用的版本是14.4.10.47824

## 0x05 完整脚本

```python
# -*- coding: utf-8 -*-

import idautils
import idc
import idaapi
import ida_bytes
import ida_funcs
import ida_auto

# =============================================================================
# 第一部分: 特征匹配
# =============================================================================

def find_br_instruction(start_ea, limit):
    """从 start_ea 之后开始,向下搜索最多 limit 条指令,寻找 BR 指令"""
    temp = start_ea
    for _ in range(limit):
        temp = idc.next_head(temp)
        if temp == idc.BADADDR:
            break
        if idc.print_insn_mnem(temp) == "BR":
            return temp
    return None

def match_pattern_at(curr):
    """
    尝试在 curr 处匹配 ADR -> SUBS -> MOV -> ADDS -> ... -> BR 特征。
    严格校验寄存器数据流(每一步都必须真正读到上一步写的寄存器),减少误判。
    匹配成功返回 (br_addr, real_target),否则返回 None。
    """
    if idc.print_insn_mnem(curr) != "ADR":
        return None

reg_dest = idc.get_operand_value(curr, 0)
    label_addr = idc.get_operand_value(curr, 1)

p2 = idc.next_head(curr)
    if idc.print_insn_mnem(p2) != "SUBS":
        return None
    if idc.get_operand_value(p2, 1) != reg_dest:
        return None
    sub_val = idc.get_operand_value(p2, 2)
    sub_dest_reg = idc.get_operand_value(p2, 0)

p3 = idc.next_head(p2)
    if idc.print_insn_mnem(p3) != "MOV":
        return None
    if idc.get_operand_value(p3, 1) != sub_dest_reg:
        return None
    reg_calc = idc.get_operand_value(p3, 0)

p4 = idc.next_head(p3)
    if idc.print_insn_mnem(p4) != "ADDS":
        return None
    if idc.get_operand_value(p4, 1) != reg_calc:
        return None
    offset_val = idc.get_operand_value(p4, 2)

br_addr = find_br_instruction(p4, 15)
    if br_addr is None:
        return None

real_target = label_addr - sub_val + offset_val
    return br_addr, real_target

# =============================================================================
# 第二部分: BR -> B 补丁
# =============================================================================

def patch_br_to_b(br_ea, real_target):
    """将 br_ea 处的 BR Xn 替换为 B real_target。仅改idb,不导出到原文件。"""
    delta = real_target - br_ea

if delta % 4 != 0:
        print("[!] %s: 跳转距离未4字节对齐(%d),无法用 B 表示" % (hex(br_ea), delta))
        return False

imm26 = delta // 4
    if imm26 < -(1 << 25) or imm26 > (1 << 25) - 1:
        print("[!] %s: 跳转距离 %s 超出 B 指令范围(±128MB)" % (hex(br_ea), hex(delta)))
        return False

encoding = 0x14000000 | (imm26 & 0x3FFFFFF)
    ida_bytes.patch_dword(br_ea, encoding)

idc.del_items(br_ea, idc.DELIT_SIMPLE, 4)
    idc.create_insn(br_ea)

idc.set_cmt(br_ea, "Patched: B -> %s" % hex(real_target), 0)
    print("[+] %s: BR 已替换为 B %s" % (hex(br_ea), hex(real_target)))
    return True

# =============================================================================
# 第三部分: 函数结构修复(tail chunk)
#   混淆器常在函数体中间插入数据块,导致跳转目标代码、以及补丁后孤立出来的
#   B 指令,在函数结构上变成"孤儿",需要手动挂载回主函数。
# =============================================================================

def ensure_code_at(ea):
    if not idc.is_code(idc.get_full_flags(ea)):
        idc.del_items(ea, idc.DELIT_SIMPLE, 4)
        ok = idc.create_insn(ea)
        if not ok:
            print("[!] %s 无法解析为合法指令" % hex(ea))
        ida_auto.auto_wait()

def attach_chunk(main_func_ea, chunk_start_ea, chunk_end_ea=None):
    """把一段孤立代码块作为 tail chunk 挂载到主函数上"""
    main_func = ida_funcs.get_func(main_func_ea)
    if main_func is None:
        print("[!] 找不到主函数 %s" % hex(main_func_ea))
        return False

created_temp = False
    if chunk_end_ea is None:
        existing = ida_funcs.get_func(chunk_start_ea)
        if existing is None:
            if not ida_funcs.add_func(chunk_start_ea):
                print("[!] 无法在 %s 自动确定函数边界,需要手动指定 chunk_end_ea" % hex(chunk_start_ea))
                return False
            existing = ida_funcs.get_func(chunk_start_ea)
            created_temp = True
        chunk_end_ea = existing.end_ea
        if created_temp:
            ida_funcs.del_func(chunk_start_ea)

ok = ida_funcs.append_func_tail(main_func, chunk_start_ea, chunk_end_ea)
    if ok:
        print("[+] 挂载 tail chunk %s-%s -> 主函数 %s" %
              (hex(chunk_start_ea), hex(chunk_end_ea), hex(main_func_ea)))
    else:
        print("[!] 挂载失败: %s-%s" % (hex(chunk_start_ea), hex(chunk_end_ea)))
    return ok

def fix_function_chunks(br_ea, real_target):
    """修复一次跳转对应的函数结构"""
    owner = ida_funcs.get_func(br_ea)
    if owner is None:
        ea = idc.prev_head(br_ea)
        for _ in range(50):
            if ea == idc.BADADDR:
                break
            owner = ida_funcs.get_func(ea)
            if owner:
                break
            ea = idc.prev_head(ea)

if owner is None:
        print("[!] %s 附近找不到可挂载的主函数,跳过" % hex(br_ea))
        return None

main_func_ea = owner.start_ea

if ida_funcs.get_func(br_ea) is None:
        attach_chunk(main_func_ea, br_ea, br_ea + 4)

ensure_code_at(real_target)
    target_func = ida_funcs.get_func(real_target)
    if target_func is None or target_func.start_ea != main_func_ea:
        attach_chunk(main_func_ea, real_target)

return main_func_ea

# =============================================================================
# 第四部分: 主扫描流程
# =============================================================================

def scan_range(start_ea, end_ea):
    found_count = 0
    touched_funcs = set()

curr = start_ea
    while curr < end_ea:
        result = match_pattern_at(curr)
        if result:
            br_addr, real_target = result
            print("[+] 匹配成功 @ %s -> 目标: %s (BR @ %s)" %
                  (hex(curr), hex(real_target), hex(br_addr)))

idc.set_cmt(curr, "Pattern Start: Target -> %s" % hex(real_target), 0)
            idc.set_color(curr, idc.CIC_ITEM, 0xFFFFCC)
            idc.set_cmt(br_addr, "Jump to: %s" % hex(real_target), 0)

if patch_br_to_b(br_addr, real_target):
                fea = fix_function_chunks(br_addr, real_target)
                if fea:
                    touched_funcs.add(fea)

found_count += 1
            curr = br_addr  # 匹配成功后跳到 BR 指令继续扫描

curr = idc.next_head(curr)

print("\n[*] 扫描结束,共发现并修复 %d 处特征。" % found_count)

for fea in touched_funcs:
        f = ida_funcs.get_func(fea)
        if f:
            ida_funcs.reanalyze_function(f)
    ida_auto.auto_wait()
    print("[*] 已对 %d 个函数重新分析,可以直接 F5 反编译。" % len(touched_funcs))

def run():
    start_ea = idaapi.BADADDR
    end_ea = idaapi.BADADDR

for seg_ea in idautils.Segments():
        seg_name = idc.get_segm_name(seg_ea)
        if seg_name in [".text", "__text", "CODE"]:
            start_ea = idc.get_segm_start(seg_ea)
            end_ea = idc.get_segm_end(seg_ea)
            break

if start_ea == idaapi.BADADDR:
        for seg_ea in idautils.Segments():
            if idc.get_segm_attr(seg_ea, idc.SEGATTR_PERM) & 1:
                start_ea = idc.get_segm_start(seg_ea)
                end_ea = idc.get_segm_end(seg_ea)
                print("[*] 未找到 .text,自动选择执行段: %s" % idc.get_segm_name(seg_ea))
                break

if start_ea == idaapi.BADADDR:
        print("[!] 错误: 找不到任何可执行的代码段。")
        return

print("[*] 开始全局扫描范围: %s - %s" % (hex(start_ea), hex(end_ea)))
    scan_range(start_ea, end_ea)

if __name__ == "__main__":
    run()
```

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

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

最新回复 (69) 1 2 3 ▶
iBa0 雪币： 1901 活跃值： (5928) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 490 粉丝 37 关注私信	iBa0 2 楼 66 2026-7-10 08:21 0
Gryffindoss 雪币： 635 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 126 粉丝 0 关注私信	Gryffindoss 3 楼 5566 2026-7-10 09:38 0
mb_qwgxafvv 雪币：能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 6 粉丝 0 关注私信	mb_qwgxafvv 4 楼 66 2026-7-10 09:59 0
wx_插曲雪币： 411 活跃值： (991) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 323 粉丝 24 关注私信	wx_插曲 5 楼 66 2026-7-10 13:27 0
Imxz 雪币： 110 活跃值： (9571) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 775 粉丝 9 关注私信	Imxz 6 楼 tql 2026-7-10 14:23 0
mb_kjzusjxu 雪币： 66 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 6 粉丝 0 关注私信	mb_kjzusjxu 7 楼 66666669 2026-7-10 14:28 0
koflfy 雪币： 102 活跃值： (4136) 能力值： ( LV4，RANK：50 ) 在线值：发帖 8 回帖 483 粉丝 5 关注私信	koflfy 1 8 楼 666 2026-7-10 14:30 0
JLkt45 雪币： 220 活跃值： (666) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 19 粉丝 0 关注私信	JLkt45 9 楼赞 2026-7-10 14:42 0
hanjiefang 雪币： 219 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 120 粉丝 0 关注私信	hanjiefang 10 楼 1 2026-7-10 15:09 0
mb_jnmxfjku 雪币： 109 活跃值： (820) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 149 粉丝 0 关注私信	mb_jnmxfjku 11 楼 666 2026-7-10 15:24 0
xingbing 雪币： 158 活跃值： (5791) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 1400 粉丝 2 关注私信	xingbing 12 楼学习 2026-7-10 15:35 0
Cure. 雪币： 60 活跃值： (170) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 41 粉丝 2 关注私信	Cure. 13 楼学习一下 2026-7-10 16:43 0
mb_iesvmzqc 雪币： 5208 活跃值： (6077) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 31 粉丝 1 关注私信	mb_iesvmzqc 14 楼已蒸馏 2026-7-10 17:15 0
mJqalJqN 雪币： 16 能力值： ( LV1，RANK：0 ) 在线值：发帖 4 回帖 124 粉丝 4 关注私信	mJqalJqN 15 楼 1 2026-7-10 17:21 0
lookzo 雪币： 216 活跃值： (3517) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 610 粉丝 3 关注私信	lookzo 16 楼 666 2026-7-10 18:32 0
咸鱼…… 雪币： 203 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 25 粉丝 0 关注私信	咸鱼…… 17 楼 6666 2026-7-11 01:05 0
git_84461osscv 雪币： 199 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 13 粉丝 0 关注私信	git_84461osscv 18 楼学习一下 2026-7-11 01:52 0
mb_jegknedl 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 27 粉丝 0 关注私信	mb_jegknedl 19 楼学习 2026-7-11 19:28 0
kingking888 雪币： 3235 活跃值： (6337) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 302 粉丝 6 关注私信	kingking888 20 楼 666 2026-7-12 16:54 0
S_602205 雪币： 0 活跃值： (1244) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 16 粉丝 0 关注私信	S_602205 21 楼 666 2026-7-12 17:01 0
mb_iiumogmn 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 33 粉丝 0 关注私信	mb_iiumogmn 22 楼感谢分享ARM64 BR混淆反混淆方法 2026-7-12 22:51 0
mb_qimctavn 雪币： 5327 活跃值： (6780) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 401 粉丝 1 关注私信	mb_qimctavn 23 楼 6 2026-7-13 07:54 0
冷瞳雪币： 0 活跃值： (1608) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 75 粉丝 1 关注私信	冷瞳 24 楼 66 2026-7-13 10:49 0
mb_ykavguun 雪币： 1307 活跃值： (1825) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 166 粉丝 0 关注私信	mb_ykavguun 25 楼 1 2026-7-13 12:24 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复