背景

最近笔者分析到一个名单类型的银狐,标题关键字是裁员补贴,依旧高活跃度,分析过程中发现这个样本中的代码混淆是有强有弱,同一天的样本可能会用多种混淆方式,其中最强的混淆是之前文章分析过的混淆方式的增强版,下文分享一下复原的思路

去混淆

下面介绍的混淆类型都是近期同时出现的

混淆类型1

只做简单的字符串混淆,在字符串中每隔一个字符插入'@',整体逻辑清晰明了

混淆类型2

字符串放在栈上不存储在全局

调用的api经过一层封装

call sub_10001F2F0
      ⬇
void __fastcall sub_10001F2F0(DWORD a1)
{
  Sleep(a1);
}
      ⬇
void __stdcall Sleep(DWORD dwMilliseconds)
{
  __imp_Sleep(dwMilliseconds);
}
混淆类型3

强混淆类型,具有多种对抗手法,程序外层是壳,段名为".fish"

脱壳后分析,一开始会对全局的字符串做单字节异或解密

功能函数以类方法进行调用,在虚函数表中可以找到所有功能函数

调用流程如下

下面进入本文正题,对第6个关键函数调用进行分析,进入后查看伪代码,不仅有大量不知名调用,还有针对IDA伪代码生成的混淆

先把这些干扰ida生成代码的部分,简单地undefine和make code

复原后如下

观察代码,其中有大量sub_7FF70F8C4DA0的调用,查看功能是做hash运算后比较结果,针对的是对软件断点的对抗,直接patch掉不影响代码的分析,patch后效果如下,仍然不具备可读性

代码中还有大量的无参数off_xxxx的调用,查看代码,发现是常量函数,如下所示

__int64 sub_7FF70F87EFE9()
{
  return 7LL;
}

用AI编写idapython脚本进行patch,把调用处的call,替换成mov eax,[函数返回的常量值],结果如下图

但是现在的代码还是很嘈杂,代码中混入了VM函数的调用,这些VM函数如off_7FF70F8E8808((int)&dword_7FF70F9285D0, 7, -97, 9, 7LL);通过传入的参数进行不同的计算,各个算式间相互嵌套

要去除这些VM函数,需要先识别这些函数的调用点,调用处的汇编为(已经进行上诉2次patch后的汇编),都是先lea rcx,mov r11,随后call r11,ida反编译后dword_7FF70F9285D0可能为qowrd、byte、word、dword,我们直接暴力全部重新定义为dword方便匹配

.dosx:00007FF70F8599D7                 lea     rcx, dword_7FF70F9285D0
.dosx:00007FF70F8599DE
.dosx:00007FF70F8599DE loc_7FF70F8599DE:                       ; DATA XREF: .dosx:off_7FF70F8E8800↓o
.dosx:00007FF70F8599DE                 mov     r11, cs:off_7FF70F8E8808
.dosx:00007FF70F8599E5                 push    rax
.dosx:00007FF70F8599E6                 push    rcx
.dosx:00007FF70F8599E7                 push    rdx
.dosx:00007FF70F8599E8                 push    r8
.dosx:00007FF70F8599EA                 push    r9
.dosx:00007FF70F8599EC                 push    r11
.dosx:00007FF70F8599EE                 lea     rcx, off_7FF70F8E8800
.dosx:00007FF70F8599F5                 sub     rsp, 20h
.dosx:00007FF70F8599F9                 nop
.dosx:00007FF70F8599FA                 nop
.dosx:00007FF70F8599FB                 nop
.dosx:00007FF70F8599FC                 nop
.dosx:00007FF70F8599FD                 nop
.dosx:00007FF70F8599FE                 add     rsp, 20h
.dosx:00007FF70F859A02                 pop     r11
.dosx:00007FF70F859A04                 pop     r9
.dosx:00007FF70F859A06                 pop     r8
.dosx:00007FF70F859A08                 pop     rdx
.dosx:00007FF70F859A09                 pop     rcx
.dosx:00007FF70F859A0A                 pop     rax
.dosx:00007FF70F859A0B                 call    r11 ;最后需要patch掉这个call

像这样找到dword_的值、VM函数的地址、patch的地址

def scan_asm_for_vm_patterns(func_ea):
    """
    扫描函数汇编,找到所有:
        lea  rcx, qword_XXXX
        ...
        mov  r11, cs:off_XXXX
        ...
        call r11
    模式,返回列表 [{qword_name, lea_ea, mov_r11_ea, call_ea, ...}]
    """
    func = ida_funcs.get_func(func_ea)
    if not func:
        print("[!] 无法获取函数 0x%x" % func_ea)
        return []

    patterns = []
    ea = func.start_ea

    while ea < func.end_ea:
        mnem = idc.print_insn_mnem(ea)
        op0 = idc.print_operand(ea, 0)
        op1 = idc.print_operand(ea, 1)

        # Step 1: 定位 lea rcx, qword_XXX
        if mnem != 'lea' or 'rcx' not in op0 or 'dword_' not in op1:
            ea += idc.get_item_size(ea)
            continue

        qword_name = extract_label(op1)
        qword_addr = idc.get_operand_value(ea, 1)
        lea_ea = ea

        # Step 2: 向前扫描找 mov r11, cs:off_XXX
        mov_r11_ea = None
        off_name = None
        scan = lea_ea + idc.get_item_size(lea_ea)

        while scan < func.end_ea:
            sm = idc.print_insn_mnem(scan)
            so0 = idc.print_operand(scan, 0)
            so1 = idc.print_operand(scan, 1)

            # 遇到新的 lea rcx 则终止
            if sm == 'lea' and 'rcx' in so0:
                break
            # 遇到直接 call r11(无 mov r11 的情况)终止
            if sm == 'call' and 'r11' in so0:
                break

            if sm == 'mov' and 'r11' in so0 and 'cs:off_' in so1.lower():
                mov_r11_ea = scan
                off_name = extract_label(so1)
                break

            scan += idc.get_item_size(scan)

        if mov_r11_ea is None:
            ea += idc.get_item_size(ea)
            continue

        # Step 3: 从 mov r11 继续向前找 call r11
        call_ea = None
        scan = mov_r11_ea + idc.get_item_size(mov_r11_ea)

        while scan < func.end_ea:
            sm = idc.print_insn_mnem(scan)
            so0 = idc.print_operand(scan, 0)

            # 遇到新的 mov r11 或 lea rcx 则终止
            if (sm == 'mov' and 'r11' in so0):
                break
            if (sm == 'lea' and 'rcx' in so0):
                if 'dword_' in idc.print_operand(scan, 1):
                    break

            if sm == 'call' and 'r11' in so0:
                call_ea = scan
                break

            scan += idc.get_item_size(scan)

        if call_ea is None:
            ea += idc.get_item_size(ea)
            continue

        patterns.append({
            'qword_name': qword_name,
            'qword_addr': qword_addr,
            'lea_ea': lea_ea,
            'mov_r11_ea': mov_r11_ea,
            'off_name': off_name,
            'call_ea': call_ea,
        })
        print("  [ASM] %s @ lea=0x%x mov_r11=0x%x call=0x%x" % (
            qword_name, lea_ea, mov_r11_ea, call_ea))

        ea += idc.get_item_size(ea)

    return patterns

随后,我们利用ida生成的伪代码,去伪代码中找有确定参数调用的VM函数调用,运行一次就会使得下一层嵌套的VM函数拿到确定的参数,以此多次调用来去除混淆

def parse_vm_calls_from_pseudocode(joined_lines):
    """从伪代码行列表中解析所有 VM 调用,返回 [{qword_name, length, key, a4_str, a5_str, ...}]"""
    vm_calls = []
    for line_no, line in enumerate(joined_lines, 1):
        for m in re.finditer(r'off_7FF70F[0-9A-Fa-f]+\([^;]+\)', line):
            call_str = m.group()

            # 找匹配的右括号
            paren_start = call_str.find('(')
            depth = 0
            paren_end = -1
            for j, ch in enumerate(call_str[paren_start:], paren_start):
                if ch == '(':
                    depth += 1
                elif ch == ')':
                    depth -= 1
                    if depth == 0:
                        paren_end = j
                        break

            if paren_end < 0:
                continue

            params_str = call_str[paren_start+1:paren_end]
            parts = [p.strip() for p in params_str.split(',')]
            if len(parts) < 5:
                continue

            data_ref = clean_data_ref(parts[0])
            len_str  = clean_value_str(parts[1])
            key_str  = clean_value_str(parts[2])
            a4_str   = clean_value_str(parts[3])
            a5_str   = clean_value_str(parts[4])

            # 提取 qword 名称
            qword_name = extract_label(data_ref)

            vm_calls.append({
                'line': line_no,
                'data_ref': data_ref,
                'qword_name': qword_name,
                'len_str': len_str,
                'key_str': key_str,
                'a4_str': a4_str,
                'a5_str': a5_str,
                'orig': call_str,
            })

    return vm_calls

执行脚本去除混淆

 Auto Patch VM Calls
 Target: sub_7FF70F855A3C (0x7ff70f855a3c)
=================================================================

[Phase 1] 扫描汇编代码中的 VM 调用模式...
  [ASM] dword_7FF70F928C10 @ lea=0x7ff70f855ae7 mov_r11=0x7ff70f855aee call=0x7ff70f855b1b
  [ASM] dword_7FF70F928C08 @ lea=0x7ff70f855b9c mov_r11=0x7ff70f855ba3 call=0x7ff70f855bd0
  [ASM] dword_7FF70F928C00 @ lea=0x7ff70f855bec mov_r11=0x7ff70f855bf3 call=0x7ff70f855c20
  [ASM] dword_7FF70F928BF0 @ lea=0x7ff70f855c3b mov_r11=0x7ff70f855c42 call=0x7ff70f855c6f
  [ASM] dword_7FF70F928BE0 @ lea=0x7ff70f855c91 mov_r11=0x7ff70f855c98 call=0x7ff70f855cc5
  [ASM] dword_7FF70F928BD8 @ lea=0x7ff70f855d45 mov_r11=0x7ff70f855d4c call=0x7ff70f855d79
  [ASM] dword_7FF70F928BC8 @ lea=0x7ff70f855d96 mov_r11=0x7ff70f855d9d call=0x7ff70f855dca
  [ASM] dword_7FF70F928BC0 @ lea=0x7ff70f855de5 mov_r11=0x7ff70f855dec call=0x7ff70f855e19
......
  找到 158 个 VM 调用模式

[Phase 2] 反编译并解析伪代码...
  常量赋值: 1 个 (单次赋值的变量)
    v150 = 0 (0x0)
  找到 145 个 VM 调用

[Phase 3] 匹配合并解析参数,计算并 Patch...
  [PATCH] 0x7ff70f859a0b: call r11 → mov eax, 16  (off_7FF70F8E8808((int)&dword_7FF70F9285D0, 7, -97, 9, 7LL))  [qword=dword_7FF70F9285D0]
  [PATCH] 0x7ff70f859ac0: call r11 → mov eax, 0  (off_7FF70F8E88B0((int)&dword_7FF70F9285C9, 7, -107, 2, 0LL))  [qword=dword_7FF70F9285C9]
  [SKIP] dword_7FF70F9285C2 — 参数非确定值 (a4=v5)
  [SKIP] dword_7FF70F9285B8 — 参数非确定值 (a4=v82, a5=v6)
  [SKIP] dword_7FF70F9285A8 — 参数非确定值 (a4=v115)
  [PATCH] 0x7ff70f856c26: call r11 → mov eax, 0  (off_7FF70F8E6B60((int)&dword_7FF70F928A6E, 7, 116, v150, 2LL)  [qword=dword_7FF70F928A6E]
  [PATCH] 0x7ff70f856d55: call r11 → mov eax, 16  (off_7FF70F8E6C40((int)&dword_7FF70F928A69, 5, 72, 9, 7LL))  [qword=dword_7FF70F928A69]
  [SKIP] dword_7FF70F928A60 — 参数非确定值 (a4=v5)
  [SKIP] dword_7FF70F928A50 — 参数非确定值 (a4=v32, a5=v36)
  [SKIP] dword_7FF70F928A44 — 参数非确定值 (a4=v92)
  [PATCH] 0x7ff70f856f09: call r11 → mov eax, 16  (off_7FF70F8E6D20((int)&dword_7FF70F928A3E, 6, 24, 9, 7LL))  [qword=dword_7FF70F928A3E]
......

=================================================================
 总计 Patch: 45 个 call r11
 跳过 (参数非确定值): 99
 跳过 (无法解析地址): 0
 跳过 (汇编未匹配):   1
 跳过 (result>255):   0
=================================================================

多次运行脚本去除混淆,可以得到下图的效果,虽然没有去除干净,但已经具有可读性,函数中继续对虚表中的函数进行调用,这个时候不管是交给AI分析还是手动分析,代码的可读性都是非常高的

通过这种方式消除大部分的混淆,以进程注入的方法为示例,先是获取SeDebug权限,查询目标进程内存空间写入shellcode和跳板shellcode,如果写入失败则选用传统的NtAllocate_Write进行注入

如果写入成功则使用线程池(PoolParty)的方式启动shellcode

后续的流程与各个安全厂商分析的流程一致,在被注入进程中发起网络通信,下载后续载荷,在目录C:\Program Files (x86)\Internet Explorer释放白加黑驻留文件

IOCs

9f3c5cbdcce59a14297c31eec5e346c78cd422443b753c7d82f3b75c9fbf20b3
e9764a9fe0ed1b364e9e51f7c44ed94b735de70edee80e552a8c29a6492da669
130c7869b687f8a480400550dc7de11fa8cc2bbb8623c67769699634d87440a7