[原创]26企鹅ollvm混淆去除-Android安全-看雪安全社区

## 前言

主播主播，你在这里直播([OLLVM学姐攻略手册](https://bbs.kanxue.com/thread-292658.htm))打靶场啥意思，卡了卡了 我的我的兄弟。D810这玩意在当前样本不好使，具体原因本文不深究。本文主要讲解样本的FLA分析思路，根据汇编代码提取特征并且编写脚本处理。

![image](upload/attach/202609/951483_FUE99JRURVVKJE6.png)

去除前后对比：

![image](upload/attach/202609/951483_XF3Y9GEE5KREQDX.png)

![image](upload/attach/202609/951483_697CRE8M98MD2R9.png)

‍

![image](upload/attach/202609/951483_MS2KNVSG84BMHXK.png)

## BCF去除

这里很简单直接快速过了不仔细说了。

首先第一件事情就是去找不透明谓词的表达式 尽可能把不同的组合的都找齐全

表达式1：

```c
((((_BYTE)dword_68068 - 1) * (_BYTE)dword_68068) & 1) == 0 || dword_6807C < 10
```

依旧带入值进行计算 dword_68068设为2 带入可得

```c
((( 2- 1) * 2) & 1) == 0 || dword_6807C < 10
```

化简得到 按位与 结果为0 0等于0 所以左边恒为真 接着就是逻辑或 左边为真 就得看右边了 dword_6807C不知道具体值

```c
(( 2 & 1) == 0 || dword_6807C < 10
```

去看dword_6807C的交叉引用 看看有没有写入赋值的片段 如果没有 就是初始值为0

根据类型来排序 清一色的offset和read 一个write没有

![image](upload/attach/202609/951483_HVKFKFEPYVH9QM6.png)

那么意味着这个表达式恒为真

```c
.bss:000000000006807C dword_6807C     % 4
```

汇编代码1：

```c
.text:0000000000006C70                 ADRP            X8, #off_61D30@PAGE
.text:0000000000006C74                 LDR             X8, [X8,#off_61D30@PAGEOFF] ; dword_68068
.text:0000000000006C78                 ADRP            X9, #off_61F18@PAGE
.text:0000000000006C7C                 LDR             W8, [X8]
.text:0000000000006C80                 LDR             X9, [X9,#off_61F18@PAGEOFF] ; dword_6807C
.text:0000000000006C84                 SUB             W10, W8, #1
.text:0000000000006C88                 LDR             W9, [X9]
.text:0000000000006C8C                 MUL             W8, W10, W8
.text:0000000000006C90                 TST             W8, #1
.text:0000000000006C94                 MOV             W8, #0xEBC3
.text:0000000000006C98                 CCMP            W9, #0xA, #8, NE
.text:0000000000006C9C                 MOV             W9, #0x29F8
.text:0000000000006CA0                 MOVK            W8, #0x1DC4,LSL#16
.text:0000000000006CA4                 MOVK            W9, #0x389F,LSL#16
.text:0000000000006CA8                 CSEL            W20, W9, W8, LT
.text:0000000000006CAC                 B               loc_53EC
```

表达式2：

```c
(dword_6807C > 9) ^ (((_BYTE)dword_68068 - 1) * (_BYTE)dword_68068) & 1
| !((dword_6807C > 9) | (((_BYTE)dword_68068 - 1) * (_BYTE)dword_68068) & 1)
```

太长了懒得分析 用python直接跑出来结果就行

```c
dword_6807C = 0
dword_6806 = 2

cond1 = (dword_6807C > 9)

cond2 = (((dword_6806 - 1) * dword_6806) % 2) != 0

a = not (cond1 and cond2)

print(a)  # 输出: True
```

这个表达式也是恒为真

汇编代码2：

```c
.text:0000000000007704                 ADRP            X8, #off_61D30@PAGE
.text:0000000000007708                 LDR             X8, [X8,#off_61D30@PAGEOFF] ; dword_68068
.text:000000000000770C                 ADRP            X9, #off_61F18@PAGE
.text:0000000000007710                 LDR             W8, [X8]
.text:0000000000007714                 LDR             X9, [X9,#off_61F18@PAGEOFF] ; dword_6807C
.text:0000000000007718                 SUB             W10, W8, #1
.text:000000000000771C                 LDR             W9, [X9]
.text:0000000000007720                 MUL             W8, W10, W8
.text:0000000000007724                 AND             W8, W8, #1
.text:0000000000007728                 CMP             W9, #9
.text:000000000000772C                 CSET            W9, GT
.text:0000000000007730                 EOR             W10, W9, W8
.text:0000000000007734                 ORR             W8, W9, W8
.text:0000000000007738                 EOR             W8, W8, #1
.text:000000000000773C                 ORR             W8, W10, W8
.text:0000000000007740                 CMP             W8, #0
.text:0000000000007744                 MOV             W8, #0xCE79
.text:0000000000007748                 MOV             W9, #0x900D
.text:000000000000774C                 MOVK            W8, #0x8F08,LSL#16
.text:0000000000007750                 MOVK            W9, #0x4CC9,LSL#16
.text:0000000000007754                 CSEL            W20, W8, W9, NE
.text:0000000000007758                 B               loc_53EC
```

手工分析已经证明谓词恒真，那这一整坨（ADRP 到 CSEL 之前）算出来的东西全是死的。但不能全删，因为最后那条 `CSEL W20, W9, W8, LT` 是在给状态寄存器写值，	只需要把 `CSEL W20, W9, W8, LT` 换成 `MOV W20, W9`。前面那十几条计算指令一条都不用动

接下来就是找锚点，两段的开头都是：

```java
ADRP  X8, #off_61D30@PAGE
LDR   X8, [X8,#off_61D30@PAGEOFF]
```

`off_61D30` 是 GOT 表项，链接期就定死了，只有这个谓词会去读它 **。**

ADRP 和 LDR 两条指令都会对 `off_61D30` 产生 xref，不过滤的话同一个谓词会被处理两遍。只认 ADRP，一个谓词就只进一次。

#### patch

只改 CSEL 那一条

```python
import idautils, idc, ida_bytes, ida_auto

for x in idautils.XrefsTo(idc.get_name_ea_simple("off_61D30")):
    ea = x.frm
    if idc.print_insn_mnem(ea).upper() != "ADRP":
        continue
    for _ in range(40):
        ea = idc.next_head(ea)
        mn = idc.print_insn_mnem(ea).upper()
        if mn == "CSEL":
            break
        if mn in ("B", "BL", "RET"):
            ea = None
            break
    if not ea or idc.print_operand(ea, 0).upper() != "W20":
        continue
    cond = idc.GetDisasm(ea).split(",")[-1].strip().upper()
    src = 1 if cond == "LT" else 2          # LT(TST形态)取Wn,NE(AND形态)取Wm
    rm = int(idc.print_operand(ea, src)[1:])
    ida_bytes.patch_dword(ea, 0x2A0003E0 | (rm << 16) | 20)
    ida_auto.plan_and_wait(ea, ea + 4)
    print(f"{ea:#x} -> MOV W20, W{rm}")
```

![image](upload/attach/202609/951483_FE5RYZEWP2QBTPS.png)

去除后代码塌陷到300多行

## FLA去除

### 分析：

#### 分发器分析

随便挑选一个状态值的入口块做跟踪看看

![image](upload/attach/202609/951483_BTQ9TVFY2482CRG.png)

拿这部分来看 骨干处代码是给w8赋值 然后将	w20-w8 如果结果相等就跳转到loc_6D08 结果不等就跳转到0x5CA8

```c
MOV             W8, #0x59E17876
CMP             W20, W8
B.EQ            loc_6D08
```

先看loc_6D08 ，技巧就是只看头尾，尾巴处对w20进行赋值0x5E60B6BF，然后无条件返回主分发器。这里对w20的值进行了修改，后面肯定有一个块的值是刚好等于这个值的0x5E60B6BF 而且一定也是多后继的

```c
loc_6D08
SUB             X8, SP, #0x100
MOV             SP, X8
STR             X8, [X19,#0x18]
SUB             X8, SP, #0x100
MOV             SP, X8
STR             X8, [X19,#0x20]
SUB             X8, SP, #0x10
MOV             SP, X8
STR             X8, [X19,#0x28]
SUB             X8, SP, #0x10
MOV             SP, X8
MOV             W0, #1  ; nmemb
MOV             W1, #0x688 ; size
STR             X8, [X19,#0x30]
BL              .calloc
ADRP            X8, #off_61F48@PAGE
LDR             X8, [X8,#off_61F48@PAGEOFF] ; qword_677C0
MOV             W20, #0x5E60B6BF
STR             X0, [X8]
B               loc_53EC
```

直接搜索文本值，这里有两个结果0x6334就是拿着前面0x64D4C赋的值去做比较的

![image](upload/attach/202609/951483_QKUR4V8DWDG265X.png)

![image](upload/attach/202609/951483_DE9SZ6VNJ4MY57W.png)

把这一截的汇编抠出来看看 简单说就是在前面给0x5E60B6BF赋值的部分他的后继就是0x6334，因为这里的判断是B,NE 不等于 但是这里一定是值等于的 等于才会进入下面的0x6344

```c
.text:0000000000006324 loc_6324                                ; CODE XREF: JNI_OnLoad+924↑j
.text:0000000000006324                 MOV             W8, #0x5BA7A93E
.text:000000000000632C                 CMP             W20, W8
.text:0000000000006330                 B.EQ            loc_6D80

.text:0000000000006334                 MOV             W8, #0x5E60B6BF
.text:000000000000633C                 CMP             W20, W8
.text:0000000000006340                 B.NE            loc_53EC

.text:0000000000006344                 ADD             X8, X19, #0x198
.text:0000000000006348                 STR             X8, [X19,#0x38]
.text:000000000000634C                 LDR             X8, [X19,#0x38]
.text:0000000000006350                 STR             XZR, [X19,#0x198]
.text:0000000000006354                 LDR             X8, [X24]
.text:0000000000006358                 MOV             W2, #4
.text:000000000000635C                 ADD             X1, X19, #0x198
.text:0000000000006360                 MOVK            W2, #1,LSL#16
.text:0000000000006364                 LDR             X8, [X8,#0x30]
.text:0000000000006368                 MOV             X0, X24
.text:000000000000636C                 BLR             X8
.text:0000000000006370                 MOV             W8, #0xC612
.text:0000000000006374                 MOV             W9, #0xD2CB
.text:0000000000006378                 CMP             W0, #0
.text:000000000000637C                 MOVK            W8, #0x85FA,LSL#16
.text:0000000000006380                 MOVK            W9, #0xEDB8,LSL#16
.text:0000000000006384                 CSEL            W20, W9, W8, EQ
.text:0000000000006388                 B               loc_53EC
```

如果值不一样 分发器永远不知道前者的后继是谁，无法跳转，逻辑崩盘。所以这里0x64D4C的后继就是0x6334。只不过经过了分发器的手而已，中转了一下梳理一下就是这样的。那么只需要将这个中转器去掉就解决了FLA。也就是让loc_6D08直接跳转到0x6344不经过主分发器，这样patch后主分发器的入度会少1

![image](upload/attach/202609/951483_328KGR4BSMXSQ2R.png)

再回过头去看前面的左边那部分 也就是条件不等于的时候

在这里其实挺眼熟的这玩意不跟0x6334一模一样的吗？按照前面的理论 这个0x5A67B105的值一定是能够搜到的，然后下面也会有业务逻辑，业务逻辑执行完毕后一定会给w20赋值，接着又跳回主分发器。

![image](upload/attach/202609/951483_A3TCQKA942WBQGW.png)

看一下汇编 跟前面的0x6334无太大的区别（这里其实很长一坨的是不透明谓词表达式 BCF在汇编上的残留）

而且这里对W20的赋值也是通过MOV+MOVK的方式来进行赋值的。

```c
.text:0000000000005CA8                 MOV             W8, #0x5A67B105
.text:0000000000005CB0                 CMP             W20, W8
.text:0000000000005CB4                 B.NE            loc_53EC
.text:0000000000005CB8                 ADRP            X8, #off_61D30@PAGE
.text:0000000000005CBC                 LDR             X8, [X8,#off_61D30@PAGEOFF] ; dword_68068
.text:0000000000005CC0                 ADRP            X9, #off_61F18@PAGE
.text:0000000000005CC4                 LDR             W8, [X8]
.text:0000000000005CC8                 LDR             X9, [X9,#off_61F18@PAGEOFF] ; dword_6807C
.text:0000000000005CCC                 SUB             W10, W8, #1
.text:0000000000005CD0                 LDR             W9, [X9]
.text:0000000000005CD4                 MUL             W8, W10, W8
.text:0000000000005CD8                 TST             W8, #1
.text:0000000000005CDC                 MOV             W8, #0xBC3C
.text:0000000000005CE0                 CCMP            W9, #0xA, #8, NE
.text:0000000000005CE4                 MOV             W9, #0xD743
.text:0000000000005CE8                 MOVK            W8, #0x1E52,LSL#16
.text:0000000000005CEC                 MOVK            W9, #0x69FB,LSL#16
.text:0000000000005CF0                 MOV             W20, W9
.text:0000000000005CF4                 B               loc_53EC
```

有几个注意点 首先就是对W20的赋值方式有MOV、MOV+MOVK、CSEL

获取真实块的思路就是获取主分发器的所有前驱筛选前面提到的w20赋值方式，如果符合条件就是真实块，不符合条件就分发器的二分查找树的内部节点。

内部节点也分两个情况，一个是以B.EQ、B.NE的，在这里的被比较值w8就是其后继真实块的入口状态值

简单观察了一下当前样本的情况和上述描述都是符合的

#### 特殊情况

但是这里看到两个块

![image](upload/attach/202609/951483_WKZT4DZSYEGSANZ.png)

![image](upload/attach/202609/951483_E4JXBW2GERD3CHP.png)

先从左边的来看吧

loc_53E0后面就是主分发器 说明loc_53E0是fallthrough 再去看看谁用到了loc_53E0

```java
.text:00000000000053E0 loc_53E0                                ; CODE XREF: JNI_OnLoad+F7C↓j
.text:00000000000053E0                                         ; JNI_OnLoad+12D4↓j
.text:00000000000053E0                 MOV             W9, #0x35043DCC
.text:00000000000053E8                 CSEL            W20, W8, W9, LT
.text:00000000000053EC
.text:00000000000053EC loc_53EC  
```

![image](upload/attach/202609/951483_2VRYPKP8M7FV3H9.png)

一共两个，先看第一个

```java
.text:000000000000629C loc_629C                                ; CODE XREF: JNI_OnLoad+700↑j
.text:000000000000629C                 MOV             W8, #0x4CC9900D
.text:00000000000062A4                 CMP             W20, W8
.text:00000000000062A8                 B.EQ            loc_6CC4
.text:00000000000062AC                 MOV             W8, #0x4F54103D
.text:00000000000062B4                 CMP             W20, W8
.text:00000000000062B8                 B.NE            loc_53EC
.text:00000000000062BC                 ADRP            X8, #off_61D30@PAGE
.text:00000000000062C0                 LDR             X8, [X8,#off_61D30@PAGEOFF] ; dword_68068
.text:00000000000062C4                 ADRP            X9, #off_61F18@PAGE
.text:00000000000062C8                 LDR             W8, [X8]
.text:00000000000062CC                 LDR             X9, [X9,#off_61F18@PAGEOFF] ; dword_6807C
.text:00000000000062D0                 SUB             W10, W8, #1
.text:00000000000062D4                 LDR             W9, [X9]
.text:00000000000062D8                 MUL             W8, W10, W8
.text:00000000000062DC                 TST             W8, #1
.text:00000000000062E0                 MOV             W8, #0xAE38
.text:00000000000062E4                 CCMP            W9, #0xA, #8, NE
.text:00000000000062E8                 MOVK            W8, #0x2C32,LSL#16
.text:00000000000062EC                 B               loc_53E0
```

这里w8的值来自前边

![image](upload/attach/202609/951483_VV9CDZD5S9NVZ3J.png)

另外一个块也是一样的w8的值来自前边。对于这种形式有专门的名称：Tail merging 是编译器后端的一个体积优化：如果两个或更多基本块的**指令后缀完全相同**、并且**跳向同一个后继**，那把这段公共后缀提取成一个独立块，让原来那几个块各自跳过去，就能省下重复的字节

再来看另外一个

```java
loc_6F94
MOV             W20, #0xC790
STR             W8, [X19,#0x10]
MOVK            W20, #0xD54D,LSL#16
B               loc_53EC
```

CFG图中loc_6F94是有两个指向他的 但是交叉引用却只找到一个

![image](upload/attach/202609/951483_WEZZ6VH9DXXRDWN.png)

那就先看找到的这个

在这里loc_6F94是当w20等于0xF9164846的时候才会执行loc_6F94，按照之前说的那个讨论，真实块的前驱存在与w20比较的值就是当前块的入口状态值，但是当前情况真实块的前驱并没有比较，而是前驱的前驱，这里有两个方案，第一个就是如果当前样本还存在其他这种情况，就在获取真实块前驱的部分加上一个判断如果当前前驱块没有CMP w20那么就获取其前驱的前驱，这样就可以包含这种情况，第二个方案更加省事的就是直接把这种真实块前驱找不到状态值的块打印出来地址 ，人工去找然后手动加入到列表中。

```java
text:0000000000006C28 loc_6C28                                ; CODE XREF: JNI_OnLoad+D54↑j
.text:0000000000006C28                 MOV             W8, #0xF87E2327
.text:0000000000006C30                 CMP             W20, W8
.text:0000000000006C34                 B.EQ            loc_76E8
.text:0000000000006C38                 MOV             W8, #0xF9164846
.text:0000000000006C40                 CMP             W20, W8
.text:0000000000006C44                 B.NE            loc_53EC
.text:0000000000006C48                 LDR             W8, [X19,#0x134]
.text:0000000000006C4C                 B               loc_6F94
```

![image](upload/attach/202609/951483_AJCSD6E6MQHS9A2.png)

```java
import idautils, idc, ida_funcs, ida_gdl

f = ida_funcs.get_func(0x5370)
fc = ida_gdl.FlowChart(f, flags=ida_gdl.FC_PREDS)

for bb in fc:
    if bb.start_ea == 0x6F94:
        for p in bb.preds():
            print(hex(p.start_ea), hex(p.end_ea))
```

输出

```java
0x6c48 0x6c50
0x6f90 0x6f94
```

看第二个地址 相差四个字节 说明0x6f90这玩意也是fallthrough

```java
.text:0000000000006F90 loc_6F90                                ; CODE XREF: JNI_OnLoad+1054↑j
.text:0000000000006F90                 LDR             W8, [X19,#0x144]
```

那就交叉引用再往上找，这里的0x746ECE9A就是状态值入口，按照我们前面说的方案

在获取真实块前驱的部分加上一个判断如果当前前驱块没有CMP w20那么就获取其前驱的前驱

```java
.text:00000000000063B8 loc_63B8                                ; CODE XREF: JNI_OnLoad+564↑j
.text:00000000000063B8                 MOV             W8, #0x746ECE9A
.text:00000000000063C0                 CMP             W20, W8
.text:00000000000063C4                 B.EQ            loc_6F90
.text:00000000000063C8                 MOV             W8, #0x7952DAAA
.text:00000000000063D0                 CMP             W20, W8
.text:00000000000063D4                 B.NE            loc_53EC
.text:00000000000063D8                 ADRP            X8, #off_61D30@PAGE
.text:00000000000063DC                 LDR             X8, [X8,#off_61D30@PAGEOFF] ; dword_68068
.text:00000000000063E0                 ADRP            X9, #off_61F18@PAGE
.text:00000000000063E4                 LDR             W8, [X8]
.text:00000000000063E8                 LDR             X9, [X9,#off_61F18@PAGEOFF] ; dword_6807C
.text:00000000000063EC                 SUB             W10, W8, #1
.text:00000000000063F0                 LDR             W9, [X9]
.text:00000000000063F4                 MUL             W8, W10, W8
.text:00000000000063F8                 TST             W8, #1
.text:00000000000063FC                 MOV             W8, #0xC8AB
.text:0000000000006400                 CCMP            W9, #0xA, #8, NE
.text:0000000000006404                 MOV             W9, #0xD685
.text:0000000000006408                 MOVK            W8, #0x82C0,LSL#16
.text:000000000000640C                 MOVK            W9, #0xD9FC,LSL#16
.text:0000000000006410                 MOV             W20, W9
.text:0000000000006414                 B               loc_53EC
```

### 收集状态值 -> 真实块入口脚本

```java
import idc
import idautils
import ida_funcs

STATE_REG = "W20"
FUNC_ADDR = 0x5370      # JNI_OnLoad

def get_imm(ea, n):
    """取第 n 个操作数的立即数, 不是立即数返回 None"""
    if idc.get_operand_type(ea, n) == idc.o_imm:
        return idc.get_operand_value(ea, n) & 0xFFFFFFFF
    return None

def track(regs, ea):
    """维护 寄存器 -> 常量, 处理 MOV/MOVK 两种赋值形态"""
    mnem = idc.print_insn_mnem(ea)
    dst = idc.print_operand(ea, 0)

if mnem == "MOV":
        imm = get_imm(ea, 1)
        if imm is not None:
            regs[dst] = imm                        # MOV Wd, #imm (含折叠的 MOVK)
        else:
            regs[dst] = regs.get(idc.print_operand(ea, 1))   # MOV Wd, Wm
    elif mnem == "MOVK":
        # 与 MOV 被业务指令隔开的情况, 例如 loc_6F94
        imm = get_imm(ea, 1)
        shift = 16 if "16" in idc.print_operand(ea, 1) else 0
        old = regs.get(dst)
        if old is not None and imm is not None:
            regs[dst] = old | (imm << shift)
    elif mnem in ("CMP", "CMN", "TST", "CCMP", "STR", "STUR", "STP", "B", "B.EQ", "B.NE"):
        pass                                        # 不改通用寄存器
    else:
        regs[dst] = None                            # 其他指令保守置未知

def collect():
    func = ida_funcs.get_func(FUNC_ADDR)
    state_map = {}
    regs = {}

for ea in idautils.Heads(func.start_ea, func.end_ea):
        mnem = idc.print_insn_mnem(ea)

# 找 CMP W20, Wm
        if mnem == "CMP" and idc.print_operand(ea, 0) == STATE_REG:
            src = idc.print_operand(ea, 1)
            state = regs.get(src)
            nxt = idc.next_head(ea, func.end_ea)
            cond = idc.print_insn_mnem(nxt)

if state is None:
                print("[skip] 0x%X: %s 常量未知" % (ea, src))
            elif cond == "B.EQ":
                # 命中就跳走, 目标即真实块入口
                state_map[state] = idc.get_operand_value(nxt, 0)
            elif cond == "B.NE":
                # 不等回分发器, fall-through 才是命中
                state_map[state] = idc.next_head(nxt, func.end_ea)
            else:
                # GT/LE/LT/GE 是二分查找枢轴, 常量不是状态值
                print("[pivot] 0x%X: %s 0x%08X" % (ea, cond, state))

track(regs, ea)

return state_map

state_map = collect()

print("")
print("共 %d 个真实块" % len(set(state_map.values())))
for state in sorted(state_map):
    print("  0x%08X  ->  0x%X" % (state, state_map[state]))

```

总共122个真实块

![image](upload/attach/202609/951483_HA2XJS4WP29E2JB.png)

### 真实块 -> 后继

```java

DISPATCHER = 0x53EC
TAIL_BLOCK = 0x53E0     # 尾块, CSEL W20,W8,W9,LT 的 LT 恒真
#最大步长
MAX_STEP   = 800

def solve_exit(entry, func_end):
    """
    从真实块入口顺序走到终结指令, 求出口状态值.
    返回 (类型, 数据, 终结地址)
      "one"     单后继, 数据 = 出口状态值
      "two"     双后继, 数据 = (条件, 值1, 值2, CSEL地址)
      "direct"  原生直连, 数据 = 目标地址
      "ret"     函数出口块
      "none"    算不出来, 交人工
    """
    regs = {}
    csel = None          # 真双后继时暂存
    term = None          # 终结地址, 以后打补丁用
    in_tail = False
    ea = entry

for _ in range(MAX_STEP):
        #当前地址是主分发器就跳过
        if ea == DISPATCHER:            # 尾块 fallthrough 进分发器
            break

mnem = idc.print_insn_mnem(ea)

if mnem == "RET":
            return ("ret", None, ea)

if mnem == "B":
            target = idc.get_operand_value(ea, 0)
            if target == TAIL_BLOCK:
                term = ea               # 补丁要打回源块这条 B
                in_tail = True
                ea = target
                continue
            if target == DISPATCHER:
                if term is None:
                    term = ea
                break
            return ("direct", target, ea)       # 真实块之间原生边

# 栈保护检查: CMP X8, X9 + B.NE, 失败分支进 __stack_chk_fail, 直接跳过
        if mnem == "B.NE" and idc.print_insn_mnem(idc.prev_head(ea, entry)) == "CMP" \
                and idc.print_operand(ea - 4, 0).startswith("X"):
            ea = idc.next_head(ea, func_end)
            continue

if mnem.startswith("B."):
            return ("none", None, None)

if mnem == "CSEL" and idc.print_operand(ea, 0) == STATE_REG:
            src1 = idc.print_operand(ea, 1)
            src2 = idc.print_operand(ea, 2)
            if in_tail:
                regs[STATE_REG] = regs.get(src1)    # LT 恒真, 取第一个
            else:
                csel = (idc.print_operand(ea, 3), src1, src2, ea)
        else:
            track(regs, ea)

ea = idc.next_head(ea, func_end)

if csel is not None:
        cond, src1, src2, csel_ea = csel
        v1 = regs.get(src1)
        v2 = regs.get(src2)
        if v1 is None or v2 is None:
            return ("none", None, term)
        return ("two", (cond, v1, v2, csel_ea), term)

value = regs.get(STATE_REG)
    if value is None or term is None:
        return ("none", None, term)
    return ("one", value, term)

#状态值->真实块地址
def build_succ(state_map):
    func = ida_funcs.get_func(FUNC_ADDR)

succ = {}        # 真实块入口 -> (类型, 数据, 终结地址)
    manual = []

for state in sorted(state_map):
        # 真实块入口地址
        entry = state_map[state]

if entry in succ:
            continue                 # tail merging, 多个状态值共用一个块

kind, data, term = solve_exit(entry, func.end_ea)

if kind == "one":
            if data in state_map:
                succ[entry] = ("one", state_map[data], term)
            else:
                print("[人工] 0x%X 出口状态 0x%08X 查不到入口" % (entry, data))
                manual.append(entry)

elif kind == "two":
            cond, v1, v2, csel_ea = data
            if v1 in state_map and v2 in state_map:
                succ[entry] = ("two", (cond, state_map[v1], state_map[v2], csel_ea), term)
            else:
                print("[人工] 0x%X 双后继状态查不到入口" % entry)
                manual.append(entry)

elif kind == "direct":
            succ[entry] = ("direct", data, term)

elif kind == "ret":
            succ[entry] = ("ret", None, term)

else:
            print("[人工] 0x%X 出口状态算不出来" % entry)
            manual.append(entry)

print("")
    print("真实块 %d 个, 解出 %d 个, 人工 %d 个"
          % (len(set(state_map.values())), len(succ), len(manual)))
    print("")
    for entry in sorted(succ):
        kind, data, term = succ[entry]
        if kind == "one":
            print("  0x%-6X -> 0x%-6X       (term 0x%X)" % (entry, data, term))
        elif kind == "two":
            cond, t1, t2, csel_ea = data
            print("  0x%-6X -> 0x%X / 0x%X  (%s, csel 0x%X)"
                  % (entry, t1, t2, cond, csel_ea))
        elif kind == "direct":
            print("  0x%-6X -> 0x%-6X       (原生直连)" % (entry, data))
        else:
            print("  0x%-6X -> RET" % entry)

return succ

succ = build_succ(state_map)

```

输出：

![image](upload/attach/202609/951483_K6KGS6KFEMJT4EQ.png)

### patch

```java

COND_CODE = {"EQ": 0x0, "NE": 0x1, "GE": 0xA, "LT": 0xB, "GT": 0xC, "LE": 0xD}

def enc_b(src, dst):
    offset = (dst - src) >> 2
    assert -(1 << 25) <= offset < (1 << 25)
    return 0x14000000 | (offset & 0x3FFFFFF)

def enc_bcond(src, dst, cond):
    offset = (dst - src) >> 2
    assert -(1 << 18) <= offset < (1 << 18)
    return 0x54000000 | ((offset & 0x7FFFF) << 5) | COND_CODE[cond]

def do_patch():
    count = 0
    for entry in sorted(succ):
        kind, data, term = succ[entry]

if kind == "one":
            ida_bytes.patch_dword(term, enc_b(term, data))
            count += 1

elif kind == "two":
            # CSEL Wd, Wn, Wm, cond -> 条件成立取 Wn, 即 t1
            cond, t1, t2, csel_ea = data
            ida_bytes.patch_dword(csel_ea, enc_bcond(csel_ea, t1, cond))
            ida_bytes.patch_dword(term, enc_b(term, t2))
            count += 2

# direct / ret 不用动

print("已 patch %d 处" % count)

do_patch()
```

得劲。

![image](upload/attach/202609/951483_GRSB8AWPBVT47AA.png)

## 开挂

不是主播，人工分析怎么那么累那么麻烦，有没有轮椅打法。有的有的 有的兄弟，伪代码丢给大模型直接就反混淆了还能提取逻辑

![image](upload/attach/202609/951483_4UYTGFJC36JNFTU.png)

‍

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

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

最新回复 (40) 1 2 ▶
北袅雪币： 2626 活跃值： (3156) 能力值： ( LV7，RANK：100 ) 在线值：发帖 5 回帖 46 粉丝 34 关注私信	北袅 2 2 楼 111 2026-9-7 18:14 0
啊你好哇123 雪币： 750 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 367 粉丝 0 关注私信	啊你好哇123 3 楼学习学习 2026-9-7 18:40 0
啊你好哇123 雪币： 750 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 367 粉丝 0 关注私信	啊你好哇123 4 楼话说有些时候生成的伪代码是错误的，和汇编指令的对不上，这种情况要咋办? 2026-9-7 18:42 0
xianhuimin 雪币： 9304 活跃值： (6173) 能力值： ( LV2，RANK：10 ) 在线值：发帖 5 回帖 226 粉丝 2 关注私信	xianhuimin 5 楼看看 2026-9-7 18:58 0
Aar0n 雪币： 4239 活跃值： (4150) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 39 粉丝 57 关注私信	Aar0n 2 6 楼 look 2026-9-7 19:11 0
Sigil 雪币： 216 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 56 粉丝 0 关注私信	Sigil 7 楼 1 2026-9-7 21:25 0
tonykros 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 99 粉丝 0 关注私信	tonykros 8 楼 111 2026-9-7 21:42 0
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 695 粉丝 7 关注私信	mb_ldbucrik 9 楼厉害了 2026-9-7 22:10 0
dpzx 雪币： 9 活跃值： (483) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 48 粉丝 0 关注私信	dpzx 10 楼 666 2026-9-8 01:23 0
北袅雪币： 2626 活跃值： (3156) 能力值： ( LV7，RANK：100 ) 在线值：发帖 5 回帖 46 粉丝 34 关注私信	北袅 2 11 楼啊你好哇123 话说有些时候生成的伪代码是错误的，和汇编指令的对不上，这种情况要咋办? 那就以汇编为准去分析费点事 2026-9-8 08:02 0
mb_xjdhrmck 雪币： 276 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 146 粉丝 0 关注私信	mb_xjdhrmck 12 楼 1231231 2026-9-8 10:05 0
wx_IT_717 雪币： 3019 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 105 粉丝 0 关注私信	wx_IT_717 13 楼厉害厉害 2026-9-8 10:48 0
B.M.K 雪币： 234 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 98 粉丝 0 关注私信	B.M.K 14 楼 123 2026-9-8 11:18 0
Dem0li 雪币： 225 活跃值： (1561) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 50 粉丝 57 关注私信	Dem0li 15 楼 1 2026-9-8 11:21 0
MaYil 雪币： 9421 活跃值： (8002) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 480 粉丝 2 关注私信	MaYil 16 楼感谢分享 2026-9-8 11:32 0
xingbing 雪币： 158 活跃值： (5711) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 1381 粉丝 2 关注私信	xingbing 17 楼感谢分享 2026-9-8 13:24 0
iBa0 雪币： 1560 活跃值： (5858) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 483 粉丝 37 关注私信	iBa0 18 楼 6666 2026-9-8 14:07 0
mb_jnmxfjku 雪币： 109 活跃值： (775) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 145 粉丝 0 关注私信	mb_jnmxfjku 19 楼 666 2026-9-8 15:06 0
k4y0z 雪币： 313 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 143 粉丝 1 关注私信	k4y0z 20 楼 666 2026-9-8 15:21 0
Imxz 雪币： 112 活跃值： (9435) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 754 粉丝 9 关注私信	Imxz 21 楼 666 2026-9-8 16:21 0
LQ6H 雪币： 530 活跃值： (2627) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 80 粉丝 1 关注私信	LQ6H 22 楼 666 2026-9-8 18:38 0
matshao 雪币： 0 活跃值： (25) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	matshao 23 楼 666 2026-9-8 18:50 0
mb_kmdbozar 雪币： 14 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 4 粉丝 0 关注私信	mb_kmdbozar 24 楼 66666 2026-9-8 19:30 0
wx_插曲雪币： 411 活跃值： (936) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 323 粉丝 24 关注私信	wx_插曲 25 楼 666 2026-9-9 12:15 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复