619 lines
15 KiB
C++
619 lines
15 KiB
C++
#include "utils.h"
|
|
|
|
namespace utils
|
|
{
|
|
// 读取二进制文件到内存
|
|
BYTE* ReadBinaryFile(const char* filePath, DWORD* outSize) {
|
|
HANDLE hFile = CreateFileA(
|
|
filePath,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE) {
|
|
printf("打开文件失败: %s\n", filePath);
|
|
return NULL;
|
|
}
|
|
|
|
DWORD fileSize = GetFileSize(hFile, NULL);
|
|
if (fileSize == INVALID_FILE_SIZE) {
|
|
printf("获取文件大小失败\n");
|
|
CloseHandle(hFile);
|
|
return NULL;
|
|
}
|
|
|
|
BYTE* buffer = (BYTE*)malloc(fileSize);
|
|
if (!buffer) {
|
|
printf("内存分配失败\n");
|
|
CloseHandle(hFile);
|
|
return NULL;
|
|
}
|
|
|
|
DWORD bytesRead = 0;
|
|
BOOL result = ReadFile(hFile, buffer, fileSize, &bytesRead, NULL);
|
|
CloseHandle(hFile);
|
|
|
|
if (!result || bytesRead != fileSize) {
|
|
printf("读取文件失败\n");
|
|
free(buffer);
|
|
return NULL;
|
|
}
|
|
|
|
*outSize = bytesRead;
|
|
return buffer;
|
|
}
|
|
BOOL WriteShellcodeToFile(const char* filePath, const BYTE* shellcode, SIZE_T shellcodeSize) {
|
|
// 1. 创建文件
|
|
HANDLE hFile = CreateFileA(
|
|
filePath,
|
|
GENERIC_WRITE,
|
|
0, // 独占访问
|
|
NULL,
|
|
CREATE_ALWAYS, // 总是创建新文件
|
|
FILE_ATTRIBUTE_NORMAL, // 普通文件
|
|
NULL
|
|
);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE) {
|
|
//printf("CreateFile 失败: %d\n", GetLastError());
|
|
return FALSE;
|
|
}
|
|
|
|
// 2. 写入 shellcode
|
|
DWORD bytesWritten = 0;
|
|
BOOL result = WriteFile(hFile, shellcode, (DWORD)shellcodeSize, &bytesWritten, NULL);
|
|
|
|
if (!result || bytesWritten != shellcodeSize) {
|
|
//printf("WriteFile 失败: %d\n", GetLastError());
|
|
CloseHandle(hFile);
|
|
return FALSE;
|
|
}
|
|
|
|
// 3. 刷新缓冲区并关闭
|
|
FlushFileBuffers(hFile);
|
|
CloseHandle(hFile);
|
|
|
|
//printf("Shellcode 写入成功: %s (大小: %d 字节)\n", filePath, bytesWritten);
|
|
return TRUE;
|
|
}
|
|
// 创建多级目录(递归创建)
|
|
BOOL CreateDirectoryRecursive(const char* path) {
|
|
char tempPath[MAX_PATH];
|
|
strcpy_s(tempPath, path);
|
|
|
|
// 去掉末尾的反斜杠
|
|
size_t len = strlen(tempPath);
|
|
if (len > 0 && tempPath[len - 1] == '\\') {
|
|
tempPath[len - 1] = '\0';
|
|
}
|
|
|
|
// 检查目录是否已存在
|
|
DWORD attrs = GetFileAttributesA(tempPath);
|
|
if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
|
|
return TRUE; // 目录已存在
|
|
}
|
|
|
|
// 递归创建父目录
|
|
char* lastSlash = strrchr(tempPath, '\\');
|
|
if (lastSlash) {
|
|
*lastSlash = '\0';
|
|
if (!CreateDirectoryRecursive(tempPath)) {
|
|
return FALSE;
|
|
}
|
|
*lastSlash = '\\';
|
|
}
|
|
|
|
// 创建当前目录
|
|
if (!CreateDirectoryA(tempPath, NULL)) {
|
|
if (GetLastError() == ERROR_ALREADY_EXISTS) {
|
|
return TRUE;
|
|
}
|
|
//printf("创建目录失败: %s (错误: %d)\n", tempPath, GetLastError());
|
|
return FALSE;
|
|
}
|
|
|
|
//printf("创建目录成功: %s\n", tempPath);
|
|
return TRUE;
|
|
}
|
|
auto GetProcessByName(CONST wchar_t* Name) -> DWORD
|
|
{
|
|
DWORD Pid = 0;
|
|
|
|
auto SnapshotHandle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
|
if (SnapshotHandle == INVALID_HANDLE_VALUE)
|
|
return Pid;
|
|
|
|
PROCESSENTRY32 pe32{ 0 };
|
|
pe32.dwSize = sizeof(pe32);
|
|
|
|
if (Process32First(SnapshotHandle, &pe32))
|
|
{
|
|
do
|
|
{
|
|
if (!wcscmp(pe32.szExeFile, Name))
|
|
{
|
|
Pid = pe32.th32ProcessID;
|
|
break;
|
|
}
|
|
|
|
} while (Process32Next(SnapshotHandle, &pe32));
|
|
}
|
|
|
|
CloseHandle(SnapshotHandle);
|
|
|
|
return Pid;
|
|
|
|
}
|
|
|
|
// 不区分大小写查找子串
|
|
bool StrContainsI(const char* src, const char* sub)
|
|
{
|
|
char* p = strstr(_strlwr((char*)src), _strlwr((char*)sub));
|
|
return p != nullptr;
|
|
}
|
|
|
|
// 不区分大小写宽字符串查找
|
|
bool StrContainsI(LPCWSTR Source, LPCWSTR Sub)
|
|
{
|
|
if (!Source || !Sub)
|
|
return FALSE;
|
|
WCHAR srcBuf[1024] = { 0 };
|
|
WCHAR subBuf[1024] = { 0 };
|
|
lstrcpyW(srcBuf, Source);
|
|
lstrcpyW(subBuf, Sub);
|
|
_wcslwr(srcBuf);
|
|
_wcslwr(subBuf);
|
|
return wcsstr(srcBuf, subBuf) != nullptr;
|
|
}
|
|
|
|
|
|
// 读取注册表字符串值
|
|
BOOL RegReadString(HKEY hRoot, LPCSTR szSubKey, LPCSTR szValueName, char* outBuf, DWORD bufSize)
|
|
{
|
|
HKEY hKey;
|
|
LONG ret = RegOpenKeyExA(hRoot, szSubKey, 0, KEY_READ, &hKey);
|
|
if (ret != ERROR_SUCCESS)
|
|
return FALSE;
|
|
|
|
DWORD dataType = REG_SZ;
|
|
DWORD dataLen = bufSize;
|
|
ret = RegQueryValueExA(hKey, szValueName, nullptr, &dataType, (LPBYTE)outBuf, &dataLen);
|
|
RegCloseKey(hKey);
|
|
|
|
if (ret != ERROR_SUCCESS)
|
|
return FALSE;
|
|
outBuf[dataLen] = '\0';
|
|
return TRUE;
|
|
}
|
|
|
|
void GetProcessName(
|
|
DWORD ProcessId,
|
|
char* ProcessName,
|
|
DWORD ProcessNameSize
|
|
)
|
|
{
|
|
ProcessName[0] = '\0';
|
|
|
|
HANDLE ProcessHandle =
|
|
OpenProcess(
|
|
PROCESS_QUERY_LIMITED_INFORMATION,
|
|
FALSE,
|
|
ProcessId
|
|
);
|
|
|
|
if (!ProcessHandle)
|
|
{
|
|
strcpy_s(
|
|
ProcessName,
|
|
ProcessNameSize,
|
|
"Unknown"
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
DWORD Size = ProcessNameSize;
|
|
|
|
if (!QueryFullProcessImageNameA(
|
|
ProcessHandle,
|
|
0,
|
|
ProcessName,
|
|
&Size))
|
|
{
|
|
strcpy_s(
|
|
ProcessName,
|
|
ProcessNameSize,
|
|
"Unknown"
|
|
);
|
|
}
|
|
else
|
|
{
|
|
char* FileName =
|
|
strrchr(ProcessName, '\\');
|
|
|
|
if (FileName)
|
|
{
|
|
memmove(
|
|
ProcessName,
|
|
FileName + 1,
|
|
strlen(FileName)
|
|
);
|
|
}
|
|
}
|
|
|
|
CloseHandle(ProcessHandle);
|
|
}
|
|
|
|
bool Is32BitOperatingSystem()
|
|
{
|
|
SYSTEM_INFO si{};
|
|
GetNativeSystemInfo(&si);
|
|
|
|
return si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL;
|
|
}
|
|
|
|
|
|
BOOL CheckVBS(BOOL* vbsRunning, BOOL* hvciRunning)
|
|
{
|
|
if (!vbsRunning || !hvciRunning)
|
|
return FALSE;
|
|
|
|
*vbsRunning = FALSE;
|
|
*hvciRunning = FALSE;
|
|
|
|
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
|
|
BOOL needUninitialize = SUCCEEDED(hr);
|
|
|
|
if (FAILED(hr) && hr != RPC_E_CHANGED_MODE)
|
|
return FALSE;
|
|
|
|
hr = CoInitializeSecurity(
|
|
NULL,
|
|
-1,
|
|
NULL,
|
|
NULL,
|
|
RPC_C_AUTHN_LEVEL_DEFAULT,
|
|
RPC_C_IMP_LEVEL_IMPERSONATE,
|
|
NULL,
|
|
EOAC_NONE,
|
|
NULL
|
|
);
|
|
|
|
if (FAILED(hr) && hr != RPC_E_TOO_LATE)
|
|
{
|
|
if (needUninitialize)
|
|
CoUninitialize();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
IWbemLocator* locator = NULL;
|
|
|
|
hr = CoCreateInstance(
|
|
CLSID_WbemLocator,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IWbemLocator,
|
|
(LPVOID*)&locator
|
|
);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
if (needUninitialize)
|
|
CoUninitialize();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
IWbemServices* services = NULL;
|
|
|
|
hr = locator->ConnectServer(
|
|
_bstr_t(L"ROOT\\Microsoft\\Windows\\DeviceGuard"),
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
&services
|
|
);
|
|
|
|
locator->Release();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
if (needUninitialize)
|
|
CoUninitialize();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
hr = CoSetProxyBlanket(
|
|
services,
|
|
RPC_C_AUTHN_WINNT,
|
|
RPC_C_AUTHZ_NONE,
|
|
NULL,
|
|
RPC_C_AUTHN_LEVEL_CALL,
|
|
RPC_C_IMP_LEVEL_IMPERSONATE,
|
|
NULL,
|
|
EOAC_NONE
|
|
);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
services->Release();
|
|
|
|
if (needUninitialize)
|
|
CoUninitialize();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
IEnumWbemClassObject* enumerator = NULL;
|
|
|
|
hr = services->ExecQuery(
|
|
_bstr_t(L"WQL"),
|
|
_bstr_t(
|
|
L"SELECT "
|
|
L"VirtualizationBasedSecurityStatus, "
|
|
L"SecurityServicesRunning "
|
|
L"FROM Win32_DeviceGuard"
|
|
),
|
|
WBEM_FLAG_FORWARD_ONLY |
|
|
WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
NULL,
|
|
&enumerator
|
|
);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
services->Release();
|
|
|
|
if (needUninitialize)
|
|
CoUninitialize();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
IWbemClassObject* object = NULL;
|
|
ULONG returned = 0;
|
|
|
|
hr = enumerator->Next(
|
|
WBEM_INFINITE,
|
|
1,
|
|
&object,
|
|
&returned
|
|
);
|
|
|
|
if (SUCCEEDED(hr) && returned == 1)
|
|
{
|
|
// =========================
|
|
// VBS
|
|
// =========================
|
|
|
|
VARIANT vbs;
|
|
VariantInit(&vbs);
|
|
|
|
if (SUCCEEDED(object->Get(
|
|
L"VirtualizationBasedSecurityStatus",
|
|
0,
|
|
&vbs,
|
|
NULL,
|
|
NULL)))
|
|
{
|
|
DWORD value = 0;
|
|
|
|
if (vbs.vt == VT_UI4)
|
|
value = vbs.ulVal;
|
|
else if (vbs.vt == VT_I4)
|
|
value = (DWORD)vbs.lVal;
|
|
|
|
// 2 = VBS 正在运行
|
|
if (value == 2)
|
|
*vbsRunning = TRUE;
|
|
}
|
|
|
|
VariantClear(&vbs);
|
|
|
|
// =========================
|
|
// HVCI
|
|
// =========================
|
|
|
|
VARIANT servicesRunning;
|
|
VariantInit(&servicesRunning);
|
|
|
|
if (SUCCEEDED(object->Get(
|
|
L"SecurityServicesRunning",
|
|
0,
|
|
&servicesRunning,
|
|
NULL,
|
|
NULL)))
|
|
{
|
|
if (servicesRunning.vt == (VT_ARRAY | VT_UI4))
|
|
{
|
|
SAFEARRAY* array = servicesRunning.parray;
|
|
|
|
LONG lower = 0;
|
|
LONG upper = -1;
|
|
|
|
SafeArrayGetLBound(
|
|
array,
|
|
1,
|
|
&lower
|
|
);
|
|
|
|
SafeArrayGetUBound(
|
|
array,
|
|
1,
|
|
&upper
|
|
);
|
|
|
|
for (LONG i = lower; i <= upper; ++i)
|
|
{
|
|
DWORD service = 0;
|
|
|
|
if (SUCCEEDED(
|
|
SafeArrayGetElement(
|
|
array,
|
|
&i,
|
|
&service
|
|
)))
|
|
{
|
|
// 2 = HVCI / Memory Integrity
|
|
if (service == 2)
|
|
{
|
|
*hvciRunning = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VariantClear(&servicesRunning);
|
|
object->Release();
|
|
}
|
|
|
|
enumerator->Release();
|
|
services->Release();
|
|
|
|
if (needUninitialize)
|
|
CoUninitialize();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool GetWindowsVersion(WINDOWS_VERSION* Version)
|
|
{
|
|
if (!Version)
|
|
return false;
|
|
|
|
ZeroMemory(Version, sizeof(WINDOWS_VERSION));
|
|
|
|
RTL_OSVERSIONINFOW VersionInfo = {};
|
|
VersionInfo.dwOSVersionInfoSize = sizeof(VersionInfo);
|
|
|
|
typedef LONG(WINAPI* RtlGetVersionPtr)(
|
|
PRTL_OSVERSIONINFOW
|
|
);
|
|
|
|
RtlGetVersionPtr RtlGetVersion =
|
|
(RtlGetVersionPtr)GetProcAddress(
|
|
GetModuleHandleW(L"ntdll.dll"),
|
|
"RtlGetVersion"
|
|
);
|
|
|
|
if (!RtlGetVersion)
|
|
return false;
|
|
|
|
if (RtlGetVersion(&VersionInfo) != 0)
|
|
return false;
|
|
|
|
Version->Major = VersionInfo.dwMajorVersion;
|
|
Version->Minor = VersionInfo.dwMinorVersion;
|
|
Version->Build = VersionInfo.dwBuildNumber;
|
|
Version->UBR = 0;
|
|
|
|
/*
|
|
获取 UBR,例如:
|
|
|
|
19045.6456
|
|
^^^^
|
|
UBR
|
|
*/
|
|
HKEY hKey = NULL;
|
|
|
|
if (RegOpenKeyExW(
|
|
HKEY_LOCAL_MACHINE,
|
|
L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
|
|
0,
|
|
KEY_READ,
|
|
&hKey) == ERROR_SUCCESS)
|
|
{
|
|
DWORD Type = 0;
|
|
DWORD Size = sizeof(DWORD);
|
|
|
|
RegQueryValueExW(
|
|
hKey,
|
|
L"UBR",
|
|
NULL,
|
|
&Type,
|
|
reinterpret_cast<LPBYTE>(&Version->UBR),
|
|
&Size
|
|
);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
/*
|
|
判断 Windows 版本
|
|
*/
|
|
|
|
if (Version->Major == 5)
|
|
{
|
|
if (Version->Minor == 1)
|
|
{
|
|
Version->Name = "Windows XP";
|
|
}
|
|
else if (Version->Minor == 2)
|
|
{
|
|
Version->Name = "Windows XP / Server 2003";
|
|
}
|
|
else
|
|
{
|
|
Version->Name = "Windows 2000";
|
|
}
|
|
}
|
|
else if (Version->Major == 6)
|
|
{
|
|
if (Version->Minor == 0)
|
|
{
|
|
Version->Name = "Windows Vista";
|
|
}
|
|
else if (Version->Minor == 1)
|
|
{
|
|
Version->Name = "Windows 7";
|
|
}
|
|
else if (Version->Minor == 2)
|
|
{
|
|
Version->Name = "Windows 8";
|
|
}
|
|
else if (Version->Minor == 3)
|
|
{
|
|
Version->Name = "Windows 8.1";
|
|
}
|
|
else
|
|
{
|
|
Version->Name = "Windows";
|
|
}
|
|
}
|
|
else if (Version->Major == 10)
|
|
{
|
|
/*
|
|
Win10 和 Win11 都是 10.0
|
|
*/
|
|
|
|
if (Version->Build >= 22000)
|
|
{
|
|
Version->Name = "Windows 11";
|
|
}
|
|
else
|
|
{
|
|
Version->Name = "Windows 10";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Version->Name = "Unknown Windows";
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
} |