名单类型银狐样本的代码解混淆分析
最近笔者分析到一个名单类型的银狐,标题关键字是裁员补贴,依旧高活跃度,分析过程中发现这个样本中的代码混淆是有强有弱,同一天的样本可能会用多种混淆方式,本文会分享复原的思路
背景
最近笔者分析到一个名单类型的银狐,标题关键字是裁员补贴,依旧高活跃度,分析过程中发现这个样本中的代码混淆是有强有弱,同一天的样本可能会用多种混淆方式,其中最强的混淆是之前文章分析过的混淆方式的增强版,下文分享一下复原的思路
去混淆
下面介绍的混淆类型都是近期同时出现的
混淆类型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