安全矩阵

 找回密码
 立即注册
搜索
查看: 244|回复: 0

第三部分:我如何找到你的标识 – Brute Rate

[复制链接]

5

主题

5

帖子

37

积分

新手上路

Rank: 1

积分
37
发表于 2022-8-12 13:51:25 | 显示全部楼层 |阅读模式
本帖最后由 lostidle 于 2022-8-12 13:55 编辑

文章地址:https://sec-in.com/article/1884

翻译:梦幻的彼岸
简介
第一部分中,我们介绍了对C2框架进行威胁猎取的通用方法,然后在第二部分中用实际例子对Cobalt Strike进行了跟进。
在本系列的第三部分,我们将分析Brute Ratel,一个由Dark Vortex. 开发的指挥和控制框架。由于C2的知名度较低,我们可以看到它对自己的描述如下:
在过去的几个月里,该框架受到密切关注,据称最近被APT29 和勒索软件集团BlackCat所滥用。因此,了解我们如何在我们的基础设施中通用地检测这种新兴的C2,对防御者来说是有用的情报。
最初,所有的分析都是在Brute Ratel v1.0.7版本上进行的;在最初审查时是最新的。然而,我们进行了一次粗略的更新(包含在本文末尾),讨论了与v1.1版本有关的发现,该版本在我们最初的x33fcon演讲后不久发布。对于Brute Ratel应该注意的一点是,badger只有有限的可塑性,而且主要是从c2通道的角度来看;但v1.1版除外,它为睡眠混淆技术增加了可塑性。因此,它使得为该工具创建非常具体的检测成为可能。
Brute Ratel的加载器
Brute Ratel的坏器有多种形式,包括exe、DLL和shellcode。当badger被注入时,其反射性装载器将立即加载badger所需的所有依赖。由于badger捆绑了大量的post-exploitation功能,这导致了大量的DLLs在初始化时被加:
正如我们所看到的,突出显示的 DLLs 是所有在注入badger时被加载的 DLLs。这个列表包括加载 winhttp.dll 和 wininet.dll。. 然而,还有一些不太常见的DLL被加载,如dbghelp.dll、credui.dll samcli.dll和logoncli.dll等。
这种行为使我们能够为图像负载创建一个签名,并导致一个高信号指标,可以通过图像负载遥测来猎取。
例如,使用Elastic查询语言,我们可以搜索一个进程中在60秒内发生的credui.dll、dbghelp.dll和winhttp.dll加载事件的序列。
sequence by Image with maxspan=1m    [any where ImageLoaded == 'C:\\Windows\\System32\\credui.dll']    [any where ImageLoaded == 'C:\\Windows\\System32\\dbghelp.dll']    [any where ImageLoaded == 'C:\\Windows\\System32\\winhttp.dll']
使用EQL工具,或者Elastic云,我们可以搜索我们的事件数据,比如下面这个是从sysmon日志中提取的。注意,我们明确排除了badger可执行文件本身,所以我们只能识别注入的badger:
eql query -f sysmon-data.json "sequence by Image with maxspan=2m [any where ImageLoaded == 'C:\\Windows\\System32\\credui.dll' and Image != 'C:\\Users\\bob\\Desktop\\badger_x64_aws.exe'] [any where ImageLoaded == 'C:\\Windows\\System32\\dbghelp.dll' and Image != 'C:\\Users\\bob\\Desktop\\badger_x64_aws.exe'] [any where ImageLoaded == 'C:\\Windows\\System32\\winhttp.dll' and Image != 'C:\\Users\\bob\\Desktop\\badger_x64_aws.exe']"
这个查询特别强大,因为它允许我们在网络中追溯寻找 Brute Ratel badgers 的指标,而无需直接在终端上运行代码。
内存中Brute Ratel
由于大多数信标保持内存驻留,因此了解留下的足迹以猎取它们是很重要的。回顾Brute Ratel 1.0版本的文档,它详细说明了自己对混淆和睡眠的实现:
根据发布的帖子,BRc4使用了 "异步程序调用、Windows事件创建、等待对象和计时器 "的混合物。然而,对badger的分析只能找到基于APC的执行的证据;后面会有更多的内容。
为了分析内存中的badger,我们首先使用pcinject命令将其注入一个进程,然后使用sleep命令让badger进入睡眠状态:
一旦badger处于睡眠状态,我们就可以用Process Hacker恢复进程中的字符串。有趣的是,当badger处于睡眠状态时,我们可以看到诸如以下的字符串:
最初,考虑到前面提到的Brute Ratel博客上描述的所谓睡眠和混淆策略,这是很令人惊讶的。
深入研究,我们可以发现一些有趣的设计决定,其中许多显示在操作员用户界面的字符串是由badger本身填充的。例如,当badger在睡眠时,我们可以在它的内存中看到以下内容:
然后这些字符串被返回到用户界面,我们可以看到下面的内容:
深入挖掘badger,很快就发现只有.text部分在睡眠时被混淆了,使badger容易受到针对字符串和数据的各种签名的影响。
为了说明这一点,逆向badger,我们可以看到加载器的入口点是 "bruteloader"。
当badger在睡眠时,在内存中搜索这个字符串,我们可以在我们的记事本进程中快速找到它。
这些字符串提供了一个很好的点,可以作为内存扫描的Yara规则的基础。例如,下面的规则将在一个进程的内存中搜索bruteloader或bhttp_x64.dll字符串
rulebrc4_badger_strings{meta:    author = "@domchell"    description = "Identifies strings used in Badger v1.0.x rDLL, even while sleeping"strings:    $a = "bruteloader"    $b = "bhttp_x64.dll"condition:    1 of them}
我们可以在badger睡眠的时候用我们的记事本程序测试这些东西,以证明其有效性:
这些字符串不太可能存在于其他进程中,使用一个简单的单行本,我们可以快速找到我们测试系统中所有被注入的badger:
将这条Yara规则添加到Virus Total中,我们可以快速找到其他样本,例如:
页面权限
对Brute Ratel混淆和睡眠策略的分析观察到,badger在睡眠期间对badger的页面权限进行了打乱,试图在badger睡眠时逃避延长可执行的权限。
下面,我们可以看到badger在睡眠0时的操作,badger的页面权限是PAGE_EXECUTE_READ,在一个未映射的页面上;为了执行任务,这是必要的:
将badger置于睡眠状态,我们可以看到混淆和睡眠策略混淆了.text部分,并将badger的页面权限重置为page_READWRITE:
然而,有趣的是,我们注意到,当SMB pivot正在执行时,即当两个badgers链接时,这种行为不会重复。在这里,我们可以看到我们的两个badger联系在一起,并且都处于60秒的睡眠状态:
对两个badger链接时的页面权限的分析显示,无论睡眠时间如何,两者都保持PAGE_EXECUTE_READ
结论是,混淆和睡眠策略只适用于.text部分,而且是在没有对等支点的情况下。
由于好奇混淆和睡眠功能是如何工作的,我们开始对其进行反向工程。通过windbg中的睡眠程序,我们可以初步了解正在发生的事情;badger正在使用WaitForSingleObjectEx来延迟一系列异步过程调用(APC)的执行,并利用一个间接的系统调用来执行NtTestAlert并强迫线程发出警报:
IDA深入分析,我们可以更好地感受到正在发生的事情。首先,它创建了一个新的线程,其起始地址被欺骗为TpReleaseCleanupGroupMembers+550的一个固定位置:
然后为一些函数调用创建了一系列上下文结构,包括NtWaitForSingleObject, NtProtectVirtualMemory, , SystemFunction032, NtGetContextThread和SetThreadContext:
接下来,一些APC被排在NtContinue的后面,目的是利用它来代理对上述上下文结构的调用;这种技术是ROP的一种基本形式:
在对睡眠技术进行逆向工程后,我们很快意识到,它与@ilove2pwnFoliage项目非常相似,除了硬编码的线程启动地址。
尽管对该badger进行了大量的调试和逆向工程,但我们无法发现v1.0博文中提到的 "Windows事件创建、等待对象和计时器 "技术的任何证据;事实上,这些技术所需的API似乎并没有通过该badger的散列导入导入。
Brute Ratels 线程
为了分析Brute Ratel线程在内存中的情况,我们将badger注入到一个新的记事本副本中。随即,我们可以看到睡眠的badger所使用的线程中存在一些可疑的迹象。
首先,我们注意到有一个看起来很可疑的线程,它的起始地址是0x0,并且在调用栈中有一个调用WaitForSingleObjectEx的单帧:
根据对线程调用堆栈的分析,我们可以推测这个线程是用于HTTP通信的,而此时badger正在睡眠:
根据我们从混淆和睡眠策略的逆向工程中获得的信息,我们注意到,新的线程是以硬编码的欺骗性起始地址ntdll!TpReleaseCleanupGroupMembers+0x550创建的:
我们无法找到任何作为起始地址自然发生的实例,因此导致了猎取Brute Ratel线程的一个琐碎的指标。在实践中,这在我们注入的记事本进程中看起来如下:
该线程的调用堆栈也略显不正常,因为它不仅包含延迟执行的调用,而且第一帧指向ntdll.dll!NtTerminateJobObject+0x1f。深入研究一下为什么使用NtNerminateJobObject就会发现,这只是NtTestAlert的一个ROP小工具,用来执行线程上的待定APC。
内存钩子
在本系列的第一篇文章中,我们详细介绍了检测基于内存钩子的内存标识的两种潜在方法;通过寻找已知补丁的签名(例如ret to ntdll.dll!EtwEventWrite)和检测写入操作的拷贝。
将这些概念应用于Brute Ratel,我们注意到,在操作者使用其开发后功能之前,badger不会应用任何内存钩。这方面的一个例子是sharpinline命令,它在当前进程中运行一个.NET组件。
一旦汇编完成,信标恢复睡眠,我们可以通过附加调试器和分解ntdll的值来更好地了解发生了什么。dll!ETWAventWrite和amsi.dll!AmsiScanBuffer:
如上所示,这些是禁用.NET ETW数据和禁止AMSI的简单持久补丁。由于补丁是持久性的,我们可以通过上述任何一种技术来检测它们,因为我们不仅会因为ETWAventWrite的第一条指令是ret而接收到高信号检测,而且还会因为清除共享位而指示ETWAvent Write所在的页面已被修改。
使用BeaconHunter,我们可以在解析修改页面上的导出的基础上快速检测这些钩子,从而提供恶意篡改发生的有力指示:
Brute Ratel C2 服务器
从终端离开,作为猎人,我们也有兴趣检测指挥和控制基础设施,因为这可能有助于为我们提供足够的情报来检测基于网络遥测的信标。
Brute Ratel的C2服务器是用golang开发的,默认情况下只允许操作员修改C2的默认登陆页面。为了对C2服务器进行指纹识别,我们发现在向任何URI发送包含base64的POST请求时,有可能产生一个未处理的异常。例如,考虑以下base64 POST数据与明文的比较:
这很可能发生,因为base64解码的POST数据的预期输入应该符合C2流量格式。一个简单的Nuclei规则可能有助于我们扫描这类基础设施:
id: brc4-tsinfo:  name: Brute Ratel C2 Server Fingerprint  author: Dominic Chell  severity: info  description: description  reference:    - https://  tags: tagsrequests:  - raw:      - |-        POST / HTTP/1.1        Host: {{Hostname}}        Content-Length: 8        Zm9vYmFy
在与C2的直接互动之外,还可以检测C2基础设施,其中运营商没有根据HTML的哈希值(http.html_hash=-1957161625).手动重新定义默认登陆页。
使用一个简单的Shodan查询,我们可以快速找到暴露在互联网上的实时基础设施。
虽然只确定了大约40个团队服务器,但根据地理分布,我们可以更好地了解这些服务器的位置:
这些技术中很可能有一些已经为人所知,因为根据对我们的测试基础设施的报告,防御者正在积极猎取这些C2服务器:
Brute Ratel 配置
对Badger的分析表明,Brute Ratel在内存中保持着一个加密的配置结构,其中包括C2端点的细节。能够从人工制品或运行中的进程中提取这些信息,可以证明对防御者有帮助。我们的分析显示,这个配置被保存在一个base64和RC4加密的blob中,使用一个固定的密钥 "bYXJm/3#M?:XyMBF",用于badger的构件。而配置则是明文存储在内存中,用于睡眠中的badger。
我们开发了以下的配置提取器,可以用来对付BRC4 v1.0.x的磁盘构件或用Brute Ratel 1.0.x和1.1.x注入的睡眠badger:
  1. #define _CRT_SECURE_NO_WARNINGS

  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <Windows.h>
  5. #include <string>
  6. #include <vector>

  7. #pragma comment(lib, "Crypt32.lib")

  8. std::string HexDump(void* pBuffer, DWORD cbBuffer)
  9. {
  10. PBYTE pbBuffer = (PBYTE)pBuffer;
  11. std::string strHex;

  12. #define FORMAT_APPEND_1(a){ char szTmp[256]; sprintf(szTmp, a); strHex += szTmp; }
  13. #define FORMAT_APPEND_2(a,b){ char szTmp[256]; sprintf(szTmp, a, b); strHex += szTmp; }

  14. for (DWORD i = 0; i < cbBuffer;)
  15. {
  16. FORMAT_APPEND_2("0x8x  ", i);

  17. DWORD n = ((cbBuffer - i) < 16) ? (cbBuffer - i) : 16;

  18. for (DWORD j = 0; j < n; j++)
  19. {
  20. FORMAT_APPEND_2("%02X ", pbBuffer[i + j]);
  21. }

  22. for (DWORD j = 0; j < (16 - n); j++)
  23. {
  24. FORMAT_APPEND_1("   ");
  25. }

  26. FORMAT_APPEND_1(" ");

  27. for (DWORD j = 0; j < n; j++)
  28. {
  29. FORMAT_APPEND_2("%c", (pbBuffer[i + j] < 0x20 || pbBuffer[i + j] > 0x7f) ? '.' : pbBuffer[i + j]);
  30. }

  31. FORMAT_APPEND_1("\n");

  32. i += n;
  33. }

  34. return strHex;
  35. }

  36. BOOL ReadAllBytes(std::string strFile, PBYTE* ppbBuffer, UINT* puiBufferLength)
  37. {
  38. BOOL bSuccess = FALSE;
  39. PBYTE pbBuffer = NULL;

  40. *ppbBuffer = NULL;
  41. *puiBufferLength = 0;

  42. FILE* fp = fopen(strFile.c_str(), "rb");
  43. if (fp)
  44. {
  45. fseek(fp, 0, SEEK_END);
  46. long lFile = ftell(fp);
  47. fseek(fp, 0, SEEK_SET);

  48. if (!(pbBuffer = (PBYTE)malloc(lFile)))
  49. goto Cleanup;

  50. if (fread(pbBuffer, 1, lFile, fp) != lFile)
  51. goto Cleanup;

  52. *ppbBuffer = pbBuffer;
  53. *puiBufferLength = (UINT)lFile;

  54. pbBuffer = NULL;
  55. bSuccess = TRUE;
  56. }

  57. Cleanup:
  58. if (fp) fclose(fp);
  59. if (pbBuffer) free(pbBuffer);
  60. return bSuccess;
  61. }

  62. void Brc4DecodeString(BYTE* pszKey, BYTE* pszInput, BYTE* pszOutput, int cchInput)
  63. {
  64. BYTE szCharmap[0x100];

  65. for (UINT i = 0; i < sizeof(szCharmap); i++)
  66. {
  67. szCharmap[i] = (char)i;
  68. }

  69. UINT cchKey = strlen((char*)pszKey);

  70. BYTE l = 0;

  71. for (UINT i = 0; i < sizeof(szCharmap); i++)
  72. {
  73. BYTE x = szCharmap[i];
  74. BYTE k = pszKey[i % cchKey];
  75. BYTE y = x + k + l;
  76. l = y;
  77. szCharmap[i] = szCharmap[y];
  78. szCharmap[y] = x;
  79. }

  80. l = 0;

  81. for (UINT i = 0; i < cchInput; i++)
  82. {
  83. BYTE x = szCharmap[i + 1];
  84. BYTE y = x + l;
  85. l = y;
  86. BYTE z = szCharmap[y];
  87. szCharmap[i + 1] = z;
  88. szCharmap[y] = x;
  89. x = x + szCharmap[i + 1];
  90. x = szCharmap[x];
  91. x = x ^ pszInput[i];
  92. pszOutput[i] = x;
  93. }
  94. }

  95. BOOL MatchPattern(PBYTE pbInput, PBYTE pbSearch, DWORD cbSearch, BYTE byteMask)
  96. {
  97. BOOL bMatch = TRUE;

  98. for (DWORD j = 0; j < cbSearch; j++)
  99. {
  100. if (pbSearch[j] != byteMask && pbInput[j] != pbSearch[j])
  101. {
  102. bMatch = FALSE;
  103. break;
  104. }
  105. }

  106. return bMatch;
  107. }

  108. PBYTE FindPattern(PBYTE pbInput, UINT cbInput, PBYTE pbSearch, DWORD cbSearch, BYTE byteMask, UINT* pcSkipMatches)
  109. {
  110. if (cbInput > cbSearch)
  111. {
  112. for (UINT i = 0; i < cbInput - cbSearch; i++)
  113. {
  114. BOOL bMatch = MatchPattern(pbInput + i, pbSearch, cbSearch, byteMask);

  115. if (bMatch)
  116. {
  117. if (!*pcSkipMatches)
  118. {
  119. return &pbInput[i];
  120. }

  121. (*pcSkipMatches)--;
  122. }
  123. }
  124. }

  125. return NULL;
  126. }

  127. BOOL LocateBrc4Config(PBYTE pbInput, UINT cbInput, PBYTE* ppbConfig)
  128. {
  129. #define XOR_RAX_RAX0x48, 0x31, 0xC0,
  130. #define PUSH_RAX0x50,
  131. #define MOV_EAX_IMM320xB8, 0xab, 0xab, 0xab, 0xab,
  132. #define MOV_RAX_IMM640x48, 0xB8, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
  133. #define PUSH_IMM320x68, 0xab, 0xab, 0xab, 0xab,
  134. #define MOV_EAX_00xB8, 0x00, 0x00, 0x00, 0x00,

  135. BYTE Pattern1[] =
  136. {
  137. XOR_RAX_RAX
  138. PUSH_RAX
  139. MOV_EAX_IMM32
  140. PUSH_RAX
  141. MOV_RAX_IMM64
  142. PUSH_RAX
  143. MOV_RAX_IMM64
  144. PUSH_RAX
  145. MOV_RAX_IMM64
  146. PUSH_RAX
  147. MOV_RAX_IMM64
  148. PUSH_RAX
  149. MOV_RAX_IMM64
  150. PUSH_RAX
  151. MOV_RAX_IMM64
  152. },
  153. Pattern2[] =
  154. {
  155. XOR_RAX_RAX
  156. PUSH_RAX
  157. MOV_RAX_IMM64
  158. PUSH_RAX
  159. MOV_RAX_IMM64
  160. PUSH_RAX
  161. MOV_RAX_IMM64
  162. PUSH_RAX
  163. MOV_RAX_IMM64
  164. PUSH_RAX
  165. MOV_RAX_IMM64
  166. PUSH_RAX
  167. MOV_RAX_IMM64
  168. PUSH_RAX
  169. MOV_RAX_IMM64
  170. };

  171. UINT cSkipMatches = 0;

  172. if (cbInput < 100)
  173. {
  174. return FALSE;
  175. }

  176. PBYTE pbConfigStart = FindPattern(pbInput, cbInput, Pattern1, sizeof(Pattern1), 0xab, &cSkipMatches);

  177. if (!pbConfigStart)
  178. {
  179. cSkipMatches = 0;

  180. pbConfigStart = FindPattern(pbInput, cbInput, Pattern2, sizeof(Pattern2), 0xab, &cSkipMatches);

  181. if (!pbConfigStart)
  182. {
  183. return FALSE;
  184. }
  185. }

  186. BYTE Pattern3[] = {
  187. PUSH_IMM32
  188. MOV_EAX_0
  189. PUSH_RAX
  190. MOV_EAX_0
  191. PUSH_RAX
  192. MOV_EAX_0
  193. PUSH_RAX
  194. };

  195. cSkipMatches = 0;

  196. PBYTE pbConfigEnd = FindPattern(pbConfigStart, cbInput - (pbConfigStart - pbInput), Pattern3, sizeof(Pattern3), 0xab, &cSkipMatches);

  197. if (!pbConfigEnd)
  198. {
  199. return FALSE;
  200. }

  201. *ppbConfig = (PBYTE)malloc(pbConfigEnd - pbConfigStart);

  202. if (!*ppbConfig)
  203. {
  204. return FALSE;
  205. }

  206. memset(*ppbConfig, 0, pbConfigEnd - pbConfigStart);

  207. pbConfigStart += 4; // skip: XOR_RAX_RAX / PUSH_RAX

  208. BYTE Pattern4[] = {
  209. MOV_EAX_IMM32
  210. PUSH_RAX
  211. },
  212. Pattern5[] = {
  213. MOV_RAX_IMM64
  214. PUSH_RAX
  215. };

  216. for (UINT uiIndex = 0, i = 0; i < pbConfigEnd - pbConfigStart;)
  217. {
  218. if (MatchPattern(pbConfigStart + i, Pattern4, sizeof(Pattern4), 0xab))
  219. {
  220. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 4];
  221. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 3];
  222. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 2];
  223. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 1];

  224. i += sizeof(Pattern4);
  225. }
  226. else if (MatchPattern(pbConfigStart + i, Pattern5, sizeof(Pattern5), 0xab))
  227. {
  228. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 9];
  229. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 8];
  230. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 7];
  231. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 6];
  232. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 5];
  233. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 4];
  234. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 3];
  235. (*ppbConfig)[uiIndex++] = pbConfigStart[i + 2];

  236. i += sizeof(Pattern5);
  237. }
  238. else if (MatchPattern(pbConfigStart + i, Pattern3, sizeof(Pattern3), 0xab))
  239. {
  240. break;
  241. }
  242. else
  243. {
  244. return FALSE;
  245. }
  246. }

  247. std::string config = (char*)*ppbConfig;
  248. std::reverse(config.begin(), config.end());

  249. strcpy((char*)*ppbConfig, config.c_str());

  250. return TRUE;
  251. }

  252. BOOL FromBase64(char* pszString, PBYTE* ppbBinary, UINT* pcbBinary)
  253. {
  254. DWORD cbBinary = 0;

  255. if (FAILED(CryptStringToBinaryA(pszString, 0, CRYPT_STRING_BASE64, NULL, &cbBinary, NULL, NULL)))
  256. {
  257. return FALSE;
  258. }

  259. *ppbBinary = (PBYTE)malloc(cbBinary + 1);

  260. if (!*ppbBinary)
  261. {
  262. return FALSE;
  263. }

  264. if (FAILED(CryptStringToBinaryA(pszString, 0, CRYPT_STRING_BASE64, *ppbBinary, &cbBinary, NULL, NULL)))
  265. {
  266. return FALSE;
  267. }

  268. *pcbBinary = cbBinary;

  269. return TRUE;
  270. }

  271. BOOL ScanProcessForBadgerConfig(HANDLE hProcess, std::string& badgerId, std::vector<std::wstring>& configStrings)
  272. {
  273. SIZE_T nBytesRead;
  274. PBYTE lpMemoryRegion = NULL, pbBadgerStateStruct = NULL;

  275. printf("[+] Searching process memory for badger state ...\n");

  276. while (1)
  277. {
  278. MEMORY_BASIC_INFORMATION mbi = { 0 };

  279. if (!VirtualQueryEx(hProcess, lpMemoryRegion, &mbi, sizeof(mbi)))
  280. {
  281. break;
  282. }

  283. if ((mbi.State & MEM_COMMIT) && !(mbi.Protect & PAGE_GUARD) &&
  284. ((mbi.Protect & PAGE_READONLY) || (mbi.Protect & PAGE_READWRITE) || (mbi.Protect & PAGE_EXECUTE_READWRITE)))
  285. {
  286. //printf("[+] Searching process memory at 0x%p (size 0x%x)\n", lpMemoryRegion, mbi.RegionSize);

  287. PBYTE pbLocalMemoryCopy = (PBYTE)malloc(mbi.RegionSize);

  288. if (!ReadProcessMemory(hProcess, lpMemoryRegion, pbLocalMemoryCopy, mbi.RegionSize, &nBytesRead))
  289. {
  290. //printf("[!] Unable to read memory at 0x%p\n", lpMemoryRegion);
  291. }
  292. else
  293. {
  294. for (UINT i = 0; i < mbi.RegionSize - 128 && !pbBadgerStateStruct; i++)
  295. {
  296. if (memcmp(pbLocalMemoryCopy + i, "b-", 2) == 0)
  297. {
  298. char* pszEndPtr = NULL;
  299. int badgerId = strtoul((char*)pbLocalMemoryCopy + i + 2, &pszEndPtr, 10);

  300. if (pszEndPtr != (char*)pbLocalMemoryCopy + i + 2 && pszEndPtr && *pszEndPtr == '\\' && strnlen(pszEndPtr, 100) > 16)
  301. {
  302. pbBadgerStateStruct = lpMemoryRegion + i;
  303. break;
  304. }
  305. }
  306. }
  307. }

  308. free(pbLocalMemoryCopy);
  309. pbLocalMemoryCopy = NULL;
  310. }

  311. lpMemoryRegion += mbi.RegionSize;
  312. }

  313. if (!pbBadgerStateStruct)
  314. {
  315. printf("[!] Failed to find badger state\n");
  316. return FALSE;
  317. }

  318. printf("[+] Found badger state at 0x%p\n", pbBadgerStateStruct);

  319. BYTE BadgerState[0x1000];

  320. memset(BadgerState, 0, sizeof(BadgerState));

  321. if (!ReadProcessMemory(hProcess, pbBadgerStateStruct, BadgerState, 0x1000, &nBytesRead))
  322. {
  323. if (GetLastError() != ERROR_PARTIAL_COPY)
  324. {
  325. printf("[!] Unable to read badger state at 0x%p\n", pbBadgerStateStruct);
  326. return FALSE;
  327. }
  328. }

  329. badgerId = (char*)BadgerState;

  330. BYTE ConfigString[1024];

  331. memset(ConfigString, 0, sizeof(ConfigString));

  332. for (UINT i = 0x100 + (0x10 - ((DWORD64)pbBadgerStateStruct & 0xf)); i < sizeof(BadgerState); i += sizeof(DWORD64))
  333. {
  334. DWORD64 pMem = *(DWORD64*)(BadgerState + i);

  335. if (pMem)
  336. {
  337. ConfigString[0] = 0;

  338. if (!ReadProcessMemory(hProcess, (LPVOID)pMem, ConfigString, 1024, &nBytesRead) || nBytesRead != 1024)
  339. {
  340. continue;
  341. }

  342. BOOL bIsValid = ConfigString[0] != 0;
  343. std::wstring badgerString;

  344. #define MIN_STRING_LENGTH5

  345. if (bIsValid)
  346. {
  347. char* pszConfigString = (char*)ConfigString;

  348. for (UINT j = 0; j < nBytesRead && pszConfigString[j] != 0; j++)
  349. {
  350. if (!isprint(pszConfigString[j]) && !(pszConfigString[j] == '\t' || pszConfigString[j] == '\r' || pszConfigString[j] == '\n'))
  351. {
  352. break;
  353. }

  354. badgerString.push_back(pszConfigString[j]);
  355. }

  356. bIsValid = badgerString.size() >= MIN_STRING_LENGTH;
  357. }

  358. if (!bIsValid)
  359. {
  360. badgerString.clear();
  361. bIsValid = TRUE;

  362. WCHAR* pwszConfigString = (WCHAR*)ConfigString;

  363. for (UINT j = 0; j < nBytesRead / sizeof(WCHAR) && pwszConfigString[j] != 0; j++)
  364. {
  365. if (!iswprint(pwszConfigString[j]) && !(pwszConfigString[j] == '\t' || pwszConfigString[j] == '\r' || pwszConfigString[j] == '\n'))
  366. {
  367. break;
  368. }

  369. badgerString.push_back(pwszConfigString[j]);
  370. }

  371. bIsValid = badgerString.size() >= MIN_STRING_LENGTH;
  372. }

  373. if (bIsValid)
  374. {
  375. configStrings.push_back(badgerString);
  376. }
  377. }
  378. }

  379. return TRUE;
  380. }

  381. int main(int argc, char *argv[])
  382. {
  383. PBYTE key = (PBYTE)"bYXJm/3#M?:XyMBF";

  384. printf("BruteRatel v1.x Config Extractor\n");

  385. if (argc < 2)
  386. {
  387. printf(
  388. "Usage: Brc4ConfigExtractor.exe <file> [key]\n"
  389. "    <file|pid> - file to scan for config, or running process ID\n"
  390. "    [key]  - key if not default\n"
  391. );

  392. return 1;
  393. }

  394. if (argc > 2)
  395. {
  396. key = (PBYTE)argv[2];
  397. }

  398. if (atoi(argv[1]) == 0)
  399. {
  400. PBYTE pbBadger = NULL;
  401. UINT cbBadger = 0;

  402. if (!ReadAllBytes(argv[1], &pbBadger, &cbBadger))
  403. {
  404. printf("[!] Input file '%s' not found\n", argv[1]);
  405. return 1;
  406. }

  407. printf("[+] Analysing file '%s' (%u bytes)\n", argv[1], cbBadger);

  408. PBYTE pbConfigText = NULL;

  409. if (!LocateBrc4Config(pbBadger, cbBadger, &pbConfigText))
  410. {
  411. printf("[!] Failed to locate BRC4 config\n");
  412. return 1;
  413. }

  414. printf("[+] Located BRC4 config: %s\n", pbConfigText);

  415. PBYTE pbBinaryConfig = NULL;
  416. UINT cbBinaryConfig = 0;

  417. if (!FromBase64((char*)pbConfigText, &pbBinaryConfig, &cbBinaryConfig))
  418. {
  419. printf("[!] Failed to decode BRC4 config from base64\n");
  420. return 1;
  421. }

  422. Brc4DecodeString(key, pbBinaryConfig, pbBinaryConfig, cbBinaryConfig);

  423. printf("[+] Decoded config: %.*s\n", cbBinaryConfig, pbBinaryConfig);
  424. }
  425. else
  426. {
  427. DWORD dwPid = atoi(argv[1]);

  428. printf("[+] Analysing process with ID %u\n", dwPid);

  429. HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPid);

  430. if (!hProcess)
  431. {
  432. printf("[!] Failed to open process\n");
  433. return 1;
  434. }

  435. std::string badgerId;
  436. std::vector<std::wstring> configStrings;

  437. if (!ScanProcessForBadgerConfig(hProcess, badgerId, configStrings))
  438. {
  439. printf("[!] Failed to locate badger configuration in memory\n");
  440. return 1;
  441. }

  442. printf("[+] Badger '%s' found...\n", badgerId.c_str());

  443. for (auto configString : configStrings)
  444. {
  445. printf("    : %S\n", configString.c_str());
  446. }

  447. CloseHandle(hProcess);
  448. }

  449. return 0;
  450. }
复制代码

在构件或运行中的进程上运行提取器工具(甚至在睡眠状态下),将提取进程或构件的Brute Ratel配置状态。
更新后的V1.1版分析
在我们在x33fcon会议上关于这个问题的演讲后不久,Brute Ratel宣布了该软件的新版本。因此,鉴于威胁者最近对Brute Ratel的了解,似乎应该对此进行分析,以确保防御者获得准确的建议。
混淆和睡眠技术的分析
在v1.1版本中,让我们印象深刻的一件事是,作者宣称发现了新的睡眠和混淆技术。正如这个"Brute Ratel C4 v/s Nighthawk and Open Source Sleep Obfuscation Techniques"中所说,作者说:"在Austin发布这个博文之前,我甚至不知道(SIC)这个技术。然而,Brute Ratel并没有使用我们在这里看到的这两种技术中的任何一种。"在提到Foliage 中使用的APC技术和MDSec的Nighthawk中使用的基于定时器的技术,以及这里的反向工程和这里发布的概念验证。注意到这个视频是在Ekko发布后不久出现的。
在Brute Ratel v1.1中使用的睡眠混淆技术的逆向工程显示,现在有三种睡眠策略可用。第一个,正如我们之前所记录的,是一个与 @ilove2pwn_的Foliage极其相似的实现,甚至是一个完全的拷贝。
第二种实现,逆向工程显示是@c5pider’的Ekko代码(最初由Peter Winter-Smith发现并在MDSec的Nighthaw中使用)的几乎相同的实现。例如,考虑以下取自Ekko的内容:
将其与Brute Ratel内部应用的技术进行比较:
正如你所看到的,代码几乎是相同的;事实上,为数不多的变化包括用Rtl包装器RtlCreateTimer替换了CreateTimerQueenTimer的WinApi调用,注意到在上述视频演示中避免了Rtl包装器的断点(可能是故意的)。
这给我们带来了Brute Ratel使用的第三种技术,它是定时器的一种变体,没有公开记录。我们在这里可以看到,这个技术使用了定时器的一个微妙变化,而是通过RtlRegisterWait代理了定时器:
虽然这种技术没有公开记录,但它已经在 Nighthawk 中使用了一段时间,巧合的是,许多常量使用了相同的值。 **Brute Ratel v1.1 版本中出现的其他未记录/未发布的功能也出现了更多巧合。**到目前为止,我们只讨论了 Brute Ratel 的 x64 应用中可用的休眠技术。 对 x86 应用的分析表明,混淆和睡眠策略被固定到上述基于 APC Foliage 的应用(注意断点从未命中):
到目前为止,还没有公开或开源的使用定时器的混淆和睡眠策略的x86应用,限制了无需定制开发即可轻松集成此类代码的可用机会。
内存中的检测
v1.1版本中的一个更新意味着.rdata部分现在也被混淆了,以隐藏诸如"[+]AMSI Patched "这样的字符串,这些字符串在badger睡眠的内存中是暴露的。然而,即使是粗略的内存分析也表明,在badger睡眠的内存中仍有许多暴露的字符串。因此,这意味着有很多机会可以在终端上拔出Brute Ratel进程,即使是在badger睡眠的时候。例如,考虑到Brute Ratel C2数据是以JSON格式存储的,只要在内存中搜索它的一个独特的参数,如 "chkin",我们就能发现badger:
或者简单地搜索badger标识符(例如b-)会发现它们分散在堆和栈中。另外,这可以作为一种简单的机制来发现Brute Ratel运行的线程,例如:
在这里,我们可以看到线程4344堆栈上存在“b-4\”。我们可以从UI中确认这确实是Brute Ratel的线程:
考虑到这一点,我们能够构建一个简单但有效的Yara规则,从内存中提取休眠的Brute Ratel进程:
rulebrc4_badger_strings{meta:    author = "@domchell"    description = "Identifies strings from Brute Ratel v1.1"strings:    $a = "\"chkin\":"condition:    $a}
执行Yara规则,我们可以发现睡眠状态的badger:
在V1.0版本中记录的对后剥削行为的检测,如写操作中的可疑拷贝,仍然是相关的,并且仍然为BRC4后剥削行为提供有效的检测手段。
线程栈欺骗
在Brute Ratel的V1.0版本中,正如我们注意到的,线程的起始地址被硬编码为ntdll!TpReleaseCleanupGroupMembers+0x550。1.1版本宣称提供 "全线程栈伪装"。对Brute Ratel的堆栈欺骗的分析显示了重写线程调用栈的简单应用。这个过程发生在badger进入睡眠之前,使用上述的定时器技术。为了使线程看起来更合法,一个新的线程栈被创建,前两帧的地址被硬编码。硬编码的地址分别在RtlUserThreadStart和BaseThreadInitThunk的偏移量0xa和0x12处:
我们能够使用这些硬编码的起始地址来识别任何其他线程,因此,识别系统上的任何Brute Ratel线程变得非常简单。为了检测这些线程,我们相应地更新了BeaconHunter,以识别RtlUserThreadStart+0xa和BaseThreadInitThunk+0x12处前两帧的线程:
更新rDLL提取功能
在我们在x33fcon进行分析后不久,Brute Ratel宣布了一个方法更新,在该方法中,构建隐藏了反射DLL。对这些伪影的分析表明,这是通过使用RC4用随机密钥加密反射DLL应用的;然后踩踏PE头。将8字节的RC4密钥附加到加密的反射DLL,然后是400字节的base64配置文件。
我们开发了以下针对Brute Ratel v1.1的工具,以从DLL和EXE构件中提取反射DLL:
  1. //
  2. // only works with BRC4 1.1 binaries.
  3. //
  4. #include <algorithm
  5. #include <windows.h>
  6. #include <cstdio>
  7. #include <string>
  8. #include <iostream>
  9. #include <fstream>
  10. #include <sstream>
  11. #include <vector>
  12. #include <iomanip>

  13. typedef struct _RC4_CTX {
  14.     BYTE       x, y;
  15.     BYTE       s[256];
  16. } RC4_CTX, *PRC4_CTX;

  17. std::vector<BYTE>
  18. ReadData(std::string path) {
  19.     std::ifstream instream(path, std::ios::in | std::ios::binary);
  20.     std::vector<BYTE> input((std::istreambuf_iterator<char>(instream)), std::istreambuf_iterator<char>());
  21.     return input;
  22. }

  23. bool
  24. WriteData(std::string path, std::vector<BYTE> data) {
  25.     std::ofstream outstream(path, std::ios::out | std::ios::binary);
  26.     std::copy(data.begin(), data.end(), std::ostreambuf_iterator<char>(outstream));
  27.     return outstream.good();
  28. }

  29. BYTE
  30. start_sig[]={
  31. #if defined(_WIN64)
  32.     0x55, 0x50, 0x53, 0x51, 0x52, 0x56, 0x57, 0x41, 0x50, 0x41, 0x51, 0x41, 0x52, 0x41, 0x53, 0x41,
  33.     0x54, 0x41, 0x55, 0x41, 0x56, 0x41, 0x57, 0x48, 0x89, 0xE5, 0x48, 0x83, 0xE4, 0xF0, 0x48, 0x31,
  34.     0xC0, 0x50
  35. #else
  36.     0x60, 0x89, 0xE5, 0x83, 0xE4, 0xF8, 0x31, 0xC0, 0x50
  37. #endif
  38. };

  39. BYTE
  40. end_sig[]={
  41. #if defined(_WIN64)
  42.     0x41, 0x5F, 0x41, 0x5E, 0x41, 0x5D, 0x41, 0x5C, 0x41, 0x5B, 0x41, 0x5A, 0x41, 0x59, 0x41, 0x58,
  43.     0x5F, 0x5E, 0x5A, 0x59, 0x5B, 0x58, 0x5D, 0xC3
  44. #else
  45.     0x83, 0xC4, 0x10, 0x61, 0xC3
  46. #endif
  47. };

  48. void
  49. RC4_set_key(
  50.     PRC4_CTX c,
  51.     PVOID    key,
  52.     UINT     keylen)
  53. {
  54.     UINT i;
  55.     UCHAR j;
  56.     PUCHAR k=(PUCHAR)key;

  57.     for (i=0; i<256; i++) {
  58.         c->s[i] = (UCHAR)i;
  59.     }
  60.   
  61.     c->x = 0; c->y = 0;
  62.   
  63.     for (i=0, j=0; i<256; i++) {
  64.         j = (j + (c->s[i] + k[i % keylen]));
  65.         UCHAR t = c->s[i];
  66.         c->s[i] = c->s[j];
  67.         c->s[j] = t;
  68.     }
  69. }

  70. void
  71. RC4_crypt(
  72.     PRC4_CTX c,
  73.     PUCHAR   buf,
  74.     UINT     len)
  75. {
  76.     UCHAR x = c->x, y = c->y, j=0, t;

  77.     for (UINT i=0; i<len; i++) {
  78.         x = (x + 1);
  79.         y = (y + c->s[x]);
  80.         t = c->s[x];
  81.         c->s[x] = c->s[y];
  82.         c->s[y] = t;
  83.         j = (c->s[x] + c->s[y]);
  84.         buf[i] ^= c->s[j];
  85.     }
  86.     c->x = x;
  87.     c->y = y;
  88. }

  89. std::vector<BYTE>
  90. extract_encrypted_rdll(PBYTE ptr, DWORD maxlen) {
  91.     std::vector<BYTE> outbuf;
  92.     printf("Searching %ld bytes.\n", maxlen);
  93.   
  94.     for (DWORD i=0; i<maxlen;) {
  95.         if (!memcmp(&ptr[i], end_sig, sizeof(end_sig))) {
  96.             printf("Reached end of signature...\n");
  97.             break;
  98.         }
  99.     #if defined(_WIN64)
  100.         if ((ptr[i] & 0x40) == 0x40 && (ptr[i+1] & 0xB0) == 0xB0)
  101.         {
  102.             BYTE buf[8];
  103.    
  104.             buf[0] = ptr[i + 9];
  105.             buf[1] = ptr[i + 8];
  106.             buf[2] = ptr[i + 7];
  107.             buf[3] = ptr[i + 6];
  108.             buf[4] = ptr[i + 5];
  109.             buf[5] = ptr[i + 4];
  110.             buf[6] = ptr[i + 3];
  111.             buf[7] = ptr[i + 2];
  112.    
  113.             outbuf.insert(outbuf.end(), buf, buf + sizeof(buf));
  114.             i += (ptr[i + 10] == 0x41) ? 12 : 11;
  115.         } else i++;
  116.     #else
  117.         if ((ptr[i] & 0xB0) == 0xB0 && (ptr[i+5] & 0x50) == 0x50) {
  118.             BYTE buf[4];
  119.    
  120.             buf[0] = ptr[i + 4];
  121.             buf[1] = ptr[i + 3];
  122.             buf[2] = ptr[i + 2];
  123.             buf[3] = ptr[i + 1];
  124.    
  125.             outbuf.insert(outbuf.end(), buf, buf + sizeof(buf));
  126.             i += 6;
  127.         } else i++;
  128.     #endif
  129.     }
  130. std::reverse(outbuf.begin(), outbuf.end());
  131.     return outbuf;
  132. }

  133. int
  134. main(int argc, char *argv[]) {
  135.     if (argc != 2) {
  136.         printf("usage: decrypt_brc4 <DLL|EXE>\n");
  137.         return 0;
  138.     }
  139.   
  140.     std::vector<BYTE> inbuf, infile = ReadData(argv[1]);
  141.     DWORD len=0, ptr=0;
  142.   
  143.     if (infile.empty()) {
  144.         printf("Nothing to read.\n");
  145.         return 0;
  146.     }
  147.   
  148.     do {
  149.         auto dos = (PIMAGE_DOS_HEADER)infile.data();
  150.         auto nt = (PIMAGE_NT_HEADERS)(infile.data() + dos->e_lfanew);
  151.         auto s = IMAGE_FIRST_SECTION(nt);
  152.   
  153.         for (DWORD i=0; i<nt->FileHeader.NumberOfSections; i++) {
  154.             char Name[IMAGE_SIZEOF_SHORT_NAME + 1] = {0};
  155.             memcpy(Name, s[i].Name, IMAGE_SIZEOF_SHORT_NAME);
  156.    
  157.             if (std::string(Name) == ".data") {
  158.                 len = s[i].SizeOfRawData;
  159.                 ptr = s[i].PointerToRawData;
  160.                 break;
  161.             }
  162.         }
  163.   
  164.         if (!len) {
  165.             printf("Unable to locate .data section.\n");
  166.             break;
  167.         }
  168.   
  169.         printf("Searching %ld bytes for loader...\n", len);
  170.   
  171.         for (DWORD idx=0; idx<len - sizeof(start_sig); idx++) {
  172.             if(!memcmp(infile.data() + ptr + idx, start_sig, sizeof(start_sig))) {
  173.                 printf("Found signature : %08lX\n", ptr + idx);
  174.                 inbuf = extract_encrypted_rdll(infile.data() + ptr + idx, len - idx);
  175.                 break;
  176.             }
  177.         }
  178.   
  179.         if (inbuf.size()) {
  180.             printf("size : %zd\n", inbuf.size());
  181.             RC4_CTX c;
  182.             BYTE key[8+1] = {0};
  183.             memcpy((char*)key, inbuf.data() + inbuf.size() - 400 - 8, 8);
  184.    
  185.             //
  186.             // Decrypt RDLL. The additional 400 bytes are base64 configuration.
  187.             //
  188.             RC4_set_key(&c, key, 8);
  189.             RC4_crypt(&c, inbuf.data(), inbuf.size() - 400);
  190.    
  191.             //
  192.             // Fix DOS header.
  193.             //
  194.             inbuf[0] = 'M';
  195.             inbuf[1] = 'Z';
  196.             WriteData(std::string(argv[1]) + ".dll", inbuf);
  197.         }
  198.     } while (FALSE);
  199.   
  200.     return 0;
  201. }
复制代码

总结
综上所述,我们重点介绍了在构件中、内存中、通过威胁搜索和网络中检测Brute Ratel的技术。随着这个框架在威胁者中的普及,了解它的多种检测方式是很重要的。作为附带说明,我们还说明了该框架是如何从许多可用的开源社区工具中获得灵感的;对这些工具的了解可以帮助对该框架进行逆向工程,并更好地了解其能力。

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|安全矩阵

GMT+8, 2022-10-6 00:31 , Processed in 0.017495 second(s), 18 queries .

Powered by Discuz! X4.0

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表