C++ Прототипы функций

[Dimedrol]

Это не для плоских и примитивных умов.
Прототипы основных функций.
Создаем класс, в моем примере это cHideFunc

Спойлер: cHideFunc.cpp

#define _CRT_SECURE_NO_WARNINGS

#include "cHideFunc.h"
cHideFunc pHideFunc;

#pragma region Без модуля
const wchar_t * cHideFunc::GetWideChar(const char *c)
{
const size_t cSize = strlen(c) + 1;
wchar_t* wc = new wchar_t[cSize];
mbstowcs(wc, c, cSize);

return wc;
}

int cHideFunc::_atoi(const char *s)
{
int z = 0, n = 0;
while (isspace(*s)) s++;
if (*s == '-') { z = 1; s++; }
else if (*s == '+') s++;
while (isdigit(*s)) n = 10 * n + *s++ - '0';

return (z ? -n : n);
}

int cHideFunc::str_len(const char *str)
{
int n = 0;
while (*str++)
n++; // считаем символы без конечного нуля
return n;
}

int cHideFunc::str_cmp(const char * str1, const char * str2)
{
int result = 0;
int str1_len = str_len(str1);
int str2_len = str_len(str2);
while (*str1 || *str2)
{
if (*str1 > *str2)
{
result = 1;
break;
}
else if (*str1 < *str2)
{
result = -1;
break;
}
*str1++;
*str2++;
}
if (!result && (str1_len < str2_len))
result = 1;
else if (!result && (str1_len > str2_len))
result = -1;
return result;
}

void cHideFunc::_strcat(char *str1, const char *str2)
{
char *p;
for (p = str1; *p; p++);
while (*str2) {
*(p++) = *(str2++);
}
*p = 0;
}

char* cHideFunc::_strcpy(char* c_str1, char* c_str2)
{
while (*c_str1++ = *c_str2++);

return c_str1;
}

char * cHideFunc::_strstr(const char *source, const char *word)
{
const char *bp = word;
const char *back_pos;
while (*source != 0 && source != 0 && word != 0)
{
back_pos = source;
while (toupper(*back_pos++) == toupper(*word++))
{
if (*word == 0)
{
return (char*)(back_pos - strlen(bp));
}
}
++source;
word = bp;
}

return 0;
}

char * cHideFunc::_Itoa(int nDigit, char *strDigit)
{
int nSizeDigit = 0;
if (nDigit < 0)
{
*strDigit = '-';
nDigit = -nDigit;
nSizeDigit++;
}
int nHelpDig = nDigit;
while (nHelpDig != 0)
{
nHelpDig /= 10;
nSizeDigit++;
}
*(strDigit + nSizeDigit) = '\0';
nSizeDigit--;
while (nDigit != 0)
{
*(strDigit + nSizeDigit) = nDigit % 10 + '0';
nDigit /= 10;
nSizeDigit--;
}

return strDigit;
}

wchar_t* cHideFunc::ctow(const char* c, size_t max)
{
wchar_t* w = new wchar_t[max];
mbstowcs(w, c, max);

return w;
}

std::wstring cHideFunc::AnsiToWstring(const std::string& str)
{
return AnsiToWstring(str, CP_UTF8);
}

std::string cHideFunc::WstringToAnsi(const std::wstring& str)
{
return WstringToAnsi(str, 1251);
}

std::wstring cHideFunc::AnsiToWstring(const std::string& input, DWORD locale /*= CP_ACP*/)
{
wchar_t buf[8192] = { 0 };
_MultiByteToWideChar(locale, 0, input.c_str(), (int)input.length(), buf, ARRAYSIZE(buf));

return buf;
}

std::string cHideFunc::WstringToAnsi(const std::wstring& input, DWORD locale /*= CP_ACP*/)
{
char buf[8192] = { 0 };
_WideCharToMultiByte(locale, 0, input.c_str(), (int)input.length(), buf, ARRAYSIZE(buf), nullptr, nullptr);

return buf;
}
#pragma endregion

#pragma region Модульные
HMODULE __stdcall cHideFunc::_GetLoadLibrary(char * LibFileName)
{
ULONG retadr = 0;
DWORD rb;
HANDLE hFile;
IMAGE_DOS_HEADER DosHeader;
IMAGE_NT_HEADERS PeHeader;
IMAGE_SECTION_HEADER Section[MAX_SECTIONS];
char tmp[1024];

typedef DWORD(WINAPI* nSetFilePointer)(HANDLE, LONG, PLONG, DWORD dwMoveMethod);
typedef BOOL(WINAPI* nCloseHandle)(HANDLE);

nSetFilePointer oSetFilePointer= (nSetFilePointer)_GetLibraryProcAddress(XorStr("Kernel32.dll"), XorStr("SetFilePointer"));
nCloseHandle oCloseHandle=(nCloseHandle)_GetLibraryProcAddress(XorStr("Kernel32.dll"), XorStr("CloseHandle"));


// если dll ранее была загружена
retadr = (ULONG)_GetModuleHandle(AnsiToWstring(LibFileName).c_str());
if (retadr) return (HMODULE)retadr; // то вернем её адрес и не будем мучатся
// откроем файл на чтение
hFile = _CreateFile(LibFileName, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile != INVALID_HANDLE_VALUE)
{
// считаем DOS заголовок
_ReadFile(hFile, &DosHeader, sizeof(IMAGE_DOS_HEADER), &rb, 0);
if (DosHeader.e_magic == IMAGE_DOS_SIGNATURE) // проверим сигнатуру
{
// если есть какимето данные между DOS заголовком и PE
// то считаем их. В MS компиляторах это часто Rich данные
if (sizeof(IMAGE_DOS_HEADER) < DosHeader.e_lfanew)
{
_ReadFile(hFile, &tmp[0], DosHeader.e_lfanew - sizeof(IMAGE_DOS_HEADER), &rb, 0);
}
// установим указатель в файле на PE заголовок
oSetFilePointer(hFile, DosHeader.e_lfanew, 0, FILE_BEGIN);
// считаем заголовок
_ReadFile(hFile, &PeHeader, sizeof(IMAGE_NT_HEADERS), &rb, 0);
if (PeHeader.Signature == IMAGE_NT_SIGNATURE) // проверим сигнатуру
{
// считаем 10 секций
_ReadFile(hFile, &Section[0], sizeof(IMAGE_SECTION_HEADER)*PeHeader.FileHeader.NumberOfSections, &rb, 0);
// выделим память столько, сколько указано в SIZE OF BASE
retadr = (ULONG)_VirtualAlloc(0, PeHeader.OptionalHeader.SizeOfImage, MEM_COMMIT | MEM_RESERVE | MEM_TOP_DOWN, PAGE_EXECUTE_READWRITE);

if (retadr) // если память выделилась
{
// скопируем туда DOS заголовок
memcpy((void*)retadr, &DosHeader, sizeof(IMAGE_DOS_HEADER));
// скопируем туда PE заголовок
memcpy((void*)(retadr + DosHeader.e_lfanew), &PeHeader, sizeof(IMAGE_NT_HEADERS));
// скопируем туда таблицу секций
memcpy((void*)(retadr + DosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS)), &Section[0], sizeof(IMAGE_SECTION_HEADER)* PeHeader.FileHeader.NumberOfSections);
// если есть Rich данные то и их тоже скопируем
if (sizeof(IMAGE_DOS_HEADER) < DosHeader.e_lfanew)
{
memcpy((void*)(retadr + sizeof(IMAGE_DOS_HEADER)), &tmp[0], DosHeader.e_lfanew - sizeof(IMAGE_DOS_HEADER));
}
// обработаем каждую секцию
for (int i = 0; i < PeHeader.FileHeader.NumberOfSections; i++)
{
// установим указатель в файле не начало секции в файле
oSetFilePointer(hFile, Section.PointerToRawData, 0, FILE_BEGIN);
// считаем всё секцию
_ReadFile(hFile, (void*)(retadr + Section.VirtualAddress), Section.SizeOfRawData, &rb, 0);
}
// Обработаем релоки
if (!ProgressReloc(retadr)) // если ошибка
{
_VirtualFree((PVOID*)retadr, 0, MEM_RELEASE); // освободим память
retadr = 0;
}
else if (!ProgressImport(retadr))// обработаем импорт
{
_VirtualFree((PVOID*)retadr, 0, MEM_RELEASE);// если ошибка освободим память
retadr = 0;
}
else
{
__asm
{
mov eax, PeHeader.OptionalHeader.AddressOfEntryPoint
add eax, retadr // EAX = ENTRY POINT
push 0
push DLL_PROCESS_ATTACH // ставим флаг что подгрузили DLL
push retadr
call eax // передадим управление на точку входа в DLL
}
}
}
}
}
oCloseHandle(hFile); // закрываем файл
}

return (HMODULE)retadr; // возвращаем адрес загруженного модуля в памяти
}

HMODULE cHideFunc::_GetModuleHandle(const wchar_t* szModule)//GetModuleHandle
{
LDR_MODULE* pModule = NULL;

_asm
{
MOV EAX, FS:[0x18]; // TEB (Thread Environment Block)
MOV EAX, [EAX + 0x30]; // PEB (Process Environment Block)
MOV EAX, [EAX + 0x0C]; // pModule
MOV EAX, [EAX + 0x0C]; // pModule->InLoadOrderModuleList.Flink
MOV pModule, EAX;
}

while (pModule->BaseAddress)
{
if (_wcsicmp(pModule->BaseDllName.Buffer, szModule) == 0)
{
return (HMODULE)pModule->BaseAddress;
}
pModule = (LDR_MODULE*)pModule->InLoadOrderModuleList.Flink; // grab the next module in the list
}


return NULL;
}

FARPROC cHideFunc::_GetProcAddress(HMODULE hModule, const char* lpProcName)
{
ULONG PE;
PIMAGE_EXPORT_DIRECTORY ED;
PULONG NamePointerRVA;
PUSHORT OrdinalTableRVA;
PULONG AddressTableRVA;

ULONG ret = 0;
USHORT hint = 0;
USHORT index;
char * name;
ULONG addr;
ULONG CNT_FUNC;

if ((ULONG)lpProcName <= 0xFFFF)// если импорт по ординалу
{
hint = (USHORT)lpProcName; // запишем наш ординал
}

if (hModule) // если указан модуль откуда грузить
{
PE = *(ULONG*)((ULONG)hModule + 0x3C) + (ULONG)hModule;// адрес PE заголовка
ED = (PIMAGE_EXPORT_DIRECTORY)(*(ULONG*)((ULONG)PE + 0x78) + (ULONG)hModule); // адрес таблицы экспорта

NamePointerRVA = (ULONG*)(ED->AddressOfNames + (ULONG)hModule); // адрес таблицы имен
OrdinalTableRVA = (USHORT*)(ED->AddressOfNameOrdinals + (ULONG)hModule); // адрес таблицы ординалов
AddressTableRVA = (ULONG*)(ED->AddressOfFunctions + (ULONG)hModule); // адрес таблицы адерсов

// вычесляем наибольшее значение - кол-во функций
if (ED->NumberOfNames > ED->NumberOfFunctions)
{
CNT_FUNC = ED->NumberOfNames;
}
else
{
CNT_FUNC = ED->NumberOfFunctions;
}

// пройдемся по всем функциям
for (USHORT x = 0; x < CNT_FUNC; x++)
{
if (x < ED->NumberOfFunctions) // если есть имя у функции
{
name = (char*)(NamePointerRVA[x] + (ULONG)hModule); // запомним имя
index = OrdinalTableRVA[x]; // запомним ординал
}
else // если имени нет
{
name = 0; // имени нет
index = x; // ординал = текущей позиции
}

// вычесляем адрес функции
addr = AddressTableRVA[index] + (ULONG)hModule;
if ((hint == index + ED->Base) || // если это наш ординал
(name && !str_cmp(name, lpProcName))) // если есть имя и оно наше
{
ret = addr; // нашли адрес
break; // прекратим обход экспорта
}
}
}


return (FARPROC)ret; // вернем адрес
}

PVOID cHideFunc::_GetLibraryProcAddress(const char* LibraryName, const char *ProcName)
{
return this->_GetProcAddress(this->_GetModuleHandle(GetWideChar(LibraryName)), ProcName);
}
#pragma endregion

#pragma region Другие модули
HRESULT cHideFunc::_D3DXCreateFont(LPDIRECT3DDEVICE9 pDevice, INT Height, UINT Width, UINT Weight, UINT MipLevels, BOOL Italic, DWORD CharSet, DWORD OutputPrecision, DWORD Quality, DWORD PitchAndFamily, LPCSTR pFaceName, LPD3DXFONT * ppFont)
{
LoadLibrary(XorStr("D3DX9_43.dll"));
nD3DXCreateFont oFunc = (nD3DXCreateFont)this->_GetLibraryProcAddress(ModName[ModName_text::D3DX9_43].c_str(),Funcname[0].c_str());//D3DXCreateFontA

return oFunc(pDevice, Height, Width, Weight, MipLevels, Italic, CharSet, OutputPrecision, Quality, PitchAndFamily, pFaceName, ppFont);
}

int cHideFunc::_SHGetFolderPathA(_Reserved_ HWND hwnd, _In_ int csidl, _In_opt_ HANDLE hToken, _In_ DWORD dwFlags, _Out_writes_(MAX_PATH) LPSTR pszPath)
{
nSHGetFolderPathA nFunc;
DWORD Address = (DWORD)this->_GetLibraryProcAddress(ModName[ModName_text::shell32].c_str(), Funcname[1].c_str());
nFunc = (nSHGetFolderPathA)(Address);
return nFunc(hwnd, csidl, hToken, dwFlags, pszPath);
}
#pragma endregion

#pragma region Kernel32
HANDLE cHideFunc::_CreateFile(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
nCreateFileA oFunc = (nCreateFileA)_GetLibraryProcAddress(XorStr("Kernel32.dll"), XorStr("CreateFileA"));
return oFunc(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
}

BOOL cHideFunc::_ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
{
nReadFile oFunc = (nReadFile)_GetLibraryProcAddress(XorStr("Kernel32.dll"), XorStr("ReadFile"));
return oFunc(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);
}

LPVOID cHideFunc::_VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect)
{
nVirtualAlloc oFunc = (nVirtualAlloc)_GetLibraryProcAddress(XorStr("Kernel32.dll"), XorStr("VirtualAlloc"));
return oFunc(lpAddress, dwSize, flAllocationType, flProtect);
}

BOOL cHideFunc::_DisableThreadLibraryCalls(HMODULE hLibModule)
{
nDisableThreadLibraryCalls nFunc;
DWORD Address = (DWORD)this->_GetLibraryProcAddress(ModName[ModName_text::Kernel32].c_str(), Funcname[2].c_str());
nFunc = (nDisableThreadLibraryCalls)(Address);

return nFunc(hLibModule);
}

UINT cHideFunc::_GetSystemDirectory(LPSTR lpBuffer, UINT uSize)
{
nGetSystemDirectoryA CurrentProcess = (nGetSystemDirectoryA)_GetLibraryProcAddress(ModName[ModName_text::Kernel32].c_str(), Funcname[3].c_str());

return CurrentProcess(lpBuffer, uSize);
}

int cHideFunc::_MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cchMultiByte, LPWSTR lpWideCharStr, int cchWideChar)
{
nMultiByteToWideChar nFunc;
DWORD Address = (DWORD)this->_GetLibraryProcAddress(ModName[ModName_text::Kernel32].c_str(), Funcname[4].c_str());
nFunc = (nMultiByteToWideChar)(Address);

return nFunc(CodePage, dwFlags, lpMultiByteStr, cchMultiByte, lpWideCharStr, cchWideChar);
}

int cHideFunc::_WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cchMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar)
{
nWideCharToMultiByte nFunc;
DWORD Address = (DWORD)this->_GetLibraryProcAddress(ModName[ModName_text::Kernel32].c_str(), Funcname[5].c_str());
nFunc = (nWideCharToMultiByte)(Address);

return nFunc(CodePage, dwFlags, lpWideCharStr, cchWideChar, lpMultiByteStr, cchMultiByte, lpDefaultChar, lpUsedDefaultChar);
}
#pragma endregion

#pragma region USER32
BOOL cHideFunc::_SetRect(_Out_ LPRECT lprc, _In_ int xLeft, _In_ int yTop, _In_ int xRight, _In_ int yBottom)
{
nSetRect nFunc;
DWORD Address = (DWORD)this->_GetLibraryProcAddress(ModName[ModName_text::USER32].c_str(), Funcname[6].c_str());
nFunc = (nSetRect)(Address);

return nFunc(lprc, xLeft, yTop, xRight, yBottom);
}

int cHideFunc::_MessageBox(HWND hWnd, LPCSTR MbString, LPCSTR lpCaption, UINT uType)
{
nMessageBoxTimeoutA pFunc = (nMessageBoxTimeoutA)_GetLibraryProcAddress(ModName[ModName_text::USER32].c_str(),
Funcname[7].c_str());
return pFunc(hWnd, MbString, lpCaption, uType, 0, -1);
}

BOOL cHideFunc::_GetCursorPos(LPPOINT lpPoint)
{

nGetCursorPos nGetCursorPosA;
DWORD Address = (DWORD)_GetLibraryProcAddress(ModName[ModName_text::USER32].c_str(), Funcname[8].c_str());
nGetCursorPosA = (nGetCursorPos)(Address);

return nGetCursorPosA(lpPoint);
}

BOOL cHideFunc::_ScreenToClient(HWND hWnd, LPPOINT lpPoint)
{

nScreenToClient nScreenToClientA;
DWORD Address = (DWORD)_GetLibraryProcAddress(ModName[ModName_text::USER32].c_str(), Funcname[9].c_str());
nScreenToClientA = (nScreenToClient)(Address);

return nScreenToClientA(hWnd, lpPoint);
}

HWND cHideFunc::_GetForegroundWindow()
{

nGetForegroundWindow nGetForegroundWindowA;
DWORD Address = (DWORD)_GetLibraryProcAddress(ModName[ModName_text::USER32].c_str(), Funcname[10].c_str());
nGetForegroundWindowA = (nGetForegroundWindow)(Address);

return nGetForegroundWindowA();
}

SHORT cHideFunc::_GetKeyState(int nVirtKey)
{

nGetKeyState nGetKeyStateA;
DWORD Address = (DWORD)_GetLibraryProcAddress(ModName[ModName_text::USER32].c_str(), Funcname[11].c_str());
nGetKeyStateA = (nGetKeyState)(Address);

return nGetKeyStateA(nVirtKey);
}

SHORT cHideFunc::_GetAsyncKeyState(int vKey)
{

nGetAsyncKeyState nGetAsyncKeyStateA;
DWORD Address = (DWORD)_GetLibraryProcAddress(ModName[ModName_text::USER32].c_str(), Funcname[12].c_str());
nGetAsyncKeyStateA = (nGetAsyncKeyState)(Address);

return nGetAsyncKeyStateA(vKey);
}

#pragma endregion

#pragma region ntdll
int cHideFunc::_NtCreateFile(PHANDLE FileHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PIO_STATUS_BLOCK IoStatusBlock, PLARGE_INTEGER AllocationSize, ULONG FileAttributes, ULONG ShareAccess, ULONG CreateDisposition, ULONG CreateOptions, PVOID EaBuffer, ULONG EaLength)
{
return 0;
}

BOOL cHideFunc::_VirtualFree(PVOID *BaseAddress, PSIZE_T RegionSize, ULONG FreeType)
{

typedef HANDLE(WINAPI* nGetCurrentProcess)();
nGetCurrentProcess oGetCurrentProcess = (nGetCurrentProcess)_GetLibraryProcAddress(XorStr("Kernel32.dll"), XorStr("GetCurrentProcess"));

NtFreeVirtualMemory* func = (NtFreeVirtualMemory*)_GetLibraryProcAddress(ModName[ModName_text::ntdll].c_str(),Funcname[13].c_str());
if (func == NULL)return NULL;
func(oGetCurrentProcess, BaseAddress, RegionSize, FreeType);

return TRUE;
}

BOOL cHideFunc::_NtProtectVirtualMemory(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect)
{

LPFN_NtProtectVirtualMemory * NtProtectVirtualMemory = (LPFN_NtProtectVirtualMemory*)_GetLibraryProcAddress(ModName[ModName_text::ntdll].c_str(),
Funcname[14].c_str());
if (NtProtectVirtualMemory == NULL)return NULL;
NtProtectVirtualMemory(GetCurrentProcess(), (PVOID*)&lpAddress, (PULONG)&dwSize, flNewProtect, lpflOldProtect);

return TRUE;
}

HANDLE cHideFunc::NtCreateThreadEx(void* InRemoteThreadStart, void* InRemoteCallback)
{
NtCreateThreadEx_PROC* VistaCreateThread = (NtCreateThreadEx_PROC*)_GetLibraryProcAddress(ModName[ModName_text::ntdll].c_str(),
Funcname[15].c_str());
if (VistaCreateThread == NULL)return NULL;

HANDLE hRemoteThread = NULL;
HRESULT hRes = 0;

if (!SUCCEEDED(hRes = VistaCreateThread(&hRemoteThread, 0x1FFFFF, 0, (HANDLE)-1, (LPTHREAD_START_ROUTINE)InRemoteThreadStart, InRemoteCallback, FALSE, 0, 0, 0, 0)))
return NULL;

return hRemoteThread;
}

void cHideFunc::_ExitProcess(UINT uExitCode)
{
nExitProcess nFunc;
DWORD Address = (DWORD)_GetLibraryProcAddress(ModName[ModName_text::ntdll].c_str(), Funcname[16].c_str());
nFunc = (nExitProcess)(Address);
return nFunc(uExitCode);
}
#pragma endregion

CreateThread_::CreateThread_(void*func, HINSTANCE hInst)
{
typedef BOOL(WINAPI* nCloseHandle)(HANDLE);
nCloseHandle oCloseHandle = (nCloseHandle)pHideFunc._GetLibraryProcAddress(XorStr("Kernel32.dll"), XorStr("CloseHandle"));
if ((CreateThread_::hHandle = pHideFunc.NtCreateThreadEx(func, hInst)))
{
if (!HideThread(hHandle))
{
TerminateThread(hHandle, 0);
return;
}
//oCloseHandle(CreateThread_::hHandle);
return;
}
}

bool CreateThread_::HideThread(HANDLE hThread)
{
typedef NTSTATUS(NTAPI *pNtSetInformationThread)
(HANDLE, UINT, PVOID, ULONG);
NTSTATUS Status;

pNtSetInformationThread NtSIT = (pNtSetInformationThread)pHideFunc._GetLibraryProcAddress(XorStr("ntdll.dll"),XorStr("NtSetInformationThread"));

if (NtSIT == NULL)
return false;

if (hThread == NULL)
Status = NtSIT(GetCurrentThread(),
0x11,
0, 0);
else
Status = NtSIT(hThread, 0x11, 0, 0);

if (Status != 0x00000000)
return false;
else
return true;
}

#pragma region 1
// обработка релоков
ULONG cHideFunc::ProgressReloc(ULONG filebase)
{
ULONG PE;
ULONG IB;
ULONG cnt;
ULONG x;
ULONG Delta;
PFIXREC fixrec;
USHORT fixtype;
USHORT fixoffset;

PE = *(ULONG*)(filebase + 0x3C) + filebase; // получаем адрес PE заголовка
IB = *(ULONG*)(PE + 0x34); // IMAGE BASE
if (filebase == IB) return 1; // Если совпадает с загруженным адресом, то фиксить не нужно ничего
Delta = filebase - IB; // выцесляем дельта смещение.

if (!*(ULONG*)(PE + 0xA0)) return 1; // если нет релоков то выходим
fixrec = (PFIXREC)(*(ULONG*)(PE + 0xA0) + filebase); // получаем адрес таблицы релоков
while (fixrec->BlockSize) // если таблица не пуста
{
cnt = (fixrec->BlockSize - 8) >> 1; // вычеслим кол-во элементов
for (x = 0; x < cnt; x++)
{
fixtype = (fixrec->TOR[x]) >> 12; // типа фиксации
fixoffset = (fixrec->TOR[x]) % 4096; // офсет внутри 4-х килобайтового блока
if (!fixtype) continue; // если 0, то фиксация не нужна
if (fixtype == 3) // если 3, то прибавить дельта смещение
{
*(ULONG*)(filebase + fixoffset + fixrec->PageRVA) = *(ULONG*)(filebase + fixoffset + fixrec->PageRVA) + Delta;
}
else return 0; // все остальные случае вызовут ошибку (хотя их и не будет теоретически)
}
fixrec = (PFIXREC)((ULONG)fixrec + fixrec->BlockSize); // следующая таблица реловок
}

return 1;
}

// Обработчик импорта
ULONG cHideFunc::ProgressImport(ULONG filebase)
{
ULONG PE;
HMODULE lib;
PIMPORT_TABLE ImportTable;
PADDRESS_TABLE AddressTable;
ULONG IAT_Index;
ULONG RVA;
ULONG addr;

PE = *(ULONG*)(filebase + 0x3C) + filebase; // адрес PE заголовка
if (!*(ULONG*)(PE + 0x80)) return 1; // если нет импорта то выходим
ImportTable = (PIMPORT_TABLE)(*(ULONG*)(PE + 0x80) + filebase); // адрес таблицыы импорта

while (ImportTable->NameRVA) // пока есть DLL откуда нужно импортировать функции
{
// проверим что DLL была ранее загружена
lib = _GetModuleHandle(AnsiToWstring((char*)(ImportTable->NameRVA + filebase)).c_str());
if (!lib) // если не загружена была, то загрузим её.
{
lib = _GetLoadLibrary((char*)(ImportTable->NameRVA + filebase));
}
if (!lib) return 0; // если не загрузилась, значит ошибка
if (ImportTable->LookUp) // Если импорт идет через LookUp
{
RVA = ImportTable->LookUp + filebase;
}
else // если через таблицу адресов импорта
{
RVA = ImportTable->AddresTableRVA + filebase;
}
IAT_Index = 0;
while (*(ULONG*)RVA) // если есть ссылка на таблицу имен
{
AddressTable = (PADDRESS_TABLE)(*(ULONG*)RVA + filebase); // получаем адрес структуры где хранится HINT NAME
if (AddressTable->Name[0]) // если импорт по имени
{
addr = (ULONG)_GetProcAddress(lib, AddressTable->Name); // найдем адрес
}
else // если импорт по ординалу
{
addr = (ULONG)_GetProcAddress(lib, (char*)AddressTable->Hint);
}
// если есть IAT то сохраним в неё найденный адрес
if (ImportTable->AddresTableRVA)
{
*(ULONG*)(ImportTable->AddresTableRVA + filebase + IAT_Index) = addr;
}
else // иначе сохраним туда откуда брали
{
*(ULONG*)RVA = addr;
}
RVA += 4; // сделающий элемент
IAT_Index += 4;
}
ImportTable = (PIMPORT_TABLE)((ULONG)ImportTable + sizeof(IMPORT_TABLE)); // следующая таблица
}

return 1;
}
#pragma endregion

Спойлер: cHideFunc.h

#define _CRT_SECURE_NO_WARNINGS

#include <windows.h>
//#include <winternl.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <vector>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#include "../XorCT.h"
#define MAX_SECTIONS 10 // максимальное кол-во секций в файле

#pragma region Structure
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;

typedef UNICODE_STRING *PUNICODE_STRING;

typedef struct _OBJECT_ATTRIBUTES {
ULONG Length;
HANDLE RootDirectory;
PUNICODE_STRING ObjectName;
ULONG Attributes;
PVOID SecurityDescriptor;
PVOID SecurityQualityOfService;
} OBJECT_ATTRIBUTES;
typedef OBJECT_ATTRIBUTES *POBJECT_ATTRIBUTES;

// структура для релоков
typedef struct _FIXREC
{
ULONG PageRVA;
ULONG BlockSize;
USHORT TOR[];
} TFIXREC, *PFIXREC;

// структура таблицы импорта
typedef struct _IMPORT_TABLE
{
ULONG LookUp;
ULONG TimeStamp;
ULONG ForwardChain;
ULONG NameRVA;
ULONG AddresTableRVA;
} IMPORT_TABLE, *PIMPORT_TABLE;

// структура таблица адресов
typedef struct _ADDRESS_TABLE
{
USHORT Hint;
char Name[];
} ADDRESS_TABLE, *PADDRESS_TABLE;

typedef struct _LDR_MODULE
{
LIST_ENTRY InLoadOrderModuleList;
LIST_ENTRY InMemoryOrderModuleList;
LIST_ENTRY InInitializationOrderModuleList;
PVOID BaseAddress;
PVOID EntryPoint;
ULONG SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
ULONG Flags;
SHORT LoadCount;
SHORT TlsIndex;
LIST_ENTRY HashTableEntry;
ULONG TimeDateStamp;
}LDR_MODULE, *PLDR_MODULE;

typedef struct _CLIENT_ID {
HANDLE UniqueProcess;
HANDLE UniqueThread;
} CLIENT_ID, *PCLIENT_ID;

typedef struct _INITIAL_TEB {
struct {
PVOID OldStackBase;
PVOID OldStackLimit;
} OldInitialTeb;
PVOID StackBase;
PVOID StackLimit;
PVOID StackAllocationBase;
} INITIAL_TEB, *PINITIAL_TEB;

typedef struct _IO_STATUS_BLOCK {
union {
NTSTATUS Status;
PVOID Pointer;
} DUMMYUNIONNAME;

ULONG_PTR Information;
} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;

typedef enum _FILE_INFORMATION_CLASS {
FileDirectoryInformation = 1
} FILE_INFORMATION_CLASS;

#pragma endregion

class CreateThread_
{
public:
CreateThread_(void* func, HINSTANCE hInst);
bool HideThread(HANDLE hThread);
private:
HANDLE hHandle;
};

class cHideFunc
{
public:
virtual int _NtCreateFile(
PHANDLE FileHandle,
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes,
PIO_STATUS_BLOCK IoStatusBlock,
PLARGE_INTEGER AllocationSize,
ULONG FileAttributes,
ULONG ShareAccess,
ULONG CreateDisposition,
ULONG CreateOptions,
PVOID EaBuffer,
ULONG EaLength
);
virtual BOOL _VirtualFree(PVOID *BaseAddress, PSIZE_T RegionSize, ULONG FreeType);
virtual BOOL _NtProtectVirtualMemory(LPVOID, SIZE_T, DWORD, PDWORD);
virtual HANDLE NtCreateThreadEx(void* ,void* );

virtual int _MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cchMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
virtual int _WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cchMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar);

virtual BOOL _SetRect(_Out_ LPRECT lprc, _In_ int xLeft, _In_ int yTop, _In_ int xRight, _In_ int yBottom);
virtual HRESULT _D3DXCreateFont(LPDIRECT3DDEVICE9 pDevice, INT Height, UINT Width, UINT Weight, UINT MipLevels, BOOL Italic, DWORD CharSet, DWORD OutputPrecision, DWORD Quality, DWORD PitchAndFamily, LPCSTR pFaceName, LPD3DXFONT * ppFont);

virtual const wchar_t * GetWideChar(const char *c);
virtual int str_len(const char *str);
virtual int str_cmp(const char * str1, const char * str2);
virtual int _atoi(const char *s);
virtual void _strcat(char *str1, const char *str2);
virtual char* _strcpy(char* c_str1, char* c_str2);
virtual char * _strstr(const char *source, const char *word);
virtual char * _Itoa(int nDigit, char *strDigit);
virtual wchar_t* ctow(const char* c, size_t max);

virtual int _SHGetFolderPathA(_Reserved_ HWND hwnd, _In_ int csidl, _In_opt_ HANDLE hToken, _In_ DWORD dwFlags, _Out_writes_(MAX_PATH) LPSTR pszPath);
virtual std::string WstringToAnsi(const std::wstring& str);
virtual std::wstring AnsiToWstring(const std::string& str);
virtual std::wstring AnsiToWstring(const std::string& input, DWORD locale /*= CP_ACP*/);
virtual std::string WstringToAnsi(const std::wstring& input, DWORD locale /*= CP_ACP*/);
virtual HMODULE __stdcall _GetLoadLibrary(char * LibFileName);
virtual HMODULE _GetModuleHandle(const wchar_t* szModule);
virtual FARPROC _GetProcAddress(HMODULE hModule, const char* lpProcName);
virtual PVOID _GetLibraryProcAddress(const char* LibraryName, const char *ProcName);
virtual ULONG ProgressReloc(ULONG filebase);
virtual ULONG ProgressImport(ULONG filebase);
virtual BOOL _DisableThreadLibraryCalls(HMODULE hLibModule);
virtual UINT _GetSystemDirectory(LPSTR lpBuffer, UINT uSize);
virtual int _MessageBox(HWND hWnd, LPCSTR MbString, LPCSTR lpCaption, UINT uType);
virtual void _ExitProcess(UINT uExitCode);
virtual BOOL _GetCursorPos(LPPOINT lpPoint);
virtual BOOL _ScreenToClient(HWND hWnd, LPPOINT lpPoint);
virtual HWND _GetForegroundWindow();
virtual SHORT _GetKeyState(int nVirtKey);
virtual SHORT _GetAsyncKeyState(int vKey);

virtual HANDLE _CreateFile(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
virtual BOOL _ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
virtual LPVOID _VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
};

extern cHideFunc pHideFunc;



#pragma region Prototype

typedef HANDLE(WINAPI* nCreateFileA)(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
typedef BOOL(WINAPI* nReadFile)(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
typedef LPVOID(WINAPI* nVirtualAlloc)(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
//typedef int WINAPI nNtCreateFile(
// PHANDLE FileHandle,
// ACCESS_MASK DesiredAccess,
// POBJECT_ATTRIBUTES ObjectAttributes,
// PIO_STATUS_BLOCK IoStatusBlock,
// PLARGE_INTEGER AllocationSize,
// ULONG FileAttributes,
// ULONG ShareAccess,
// ULONG CreateDisposition,
// ULONG CreateOptions,
// PVOID EaBuffer,
// ULONG EaLength
//);

typedef int WINAPI nRtlNtStatusToDosError (
IN NTSTATUS Status
);

typedef int WINAPI nRtlInitUnicodeString (
OUT PUNICODE_STRING DestinationString,
IN PCWSTR SourceString
);



typedef int WINAPI nNtQueryInformationFile(
IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass
);

typedef DWORD WINAPI NtFreeVirtualMemory(
HANDLE ProcessHandle,
PVOID *BaseAddress,
PSIZE_T RegionSize,
ULONG FreeType
);

typedef DWORD WINAPI NtCreateThreadEx_PROC(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
BOOL CreateSuspended,
DWORD dwStackSize,
LPVOID Unknown1,
LPVOID Unknown2,
LPVOID Unknown3
);
typedef LONG * NTAPI LPFN_NtProtectVirtualMemory(HANDLE, PVOID *, PULONG, ULONG, PULONG);


typedef HRESULT(WINAPI*nD3DXCreateFont)(
LPDIRECT3DDEVICE9 pDevice,
INT Height,
UINT Width,
UINT Weight,
UINT MipLevels,
BOOL Italic,
DWORD CharSet,
DWORD OutputPrecision,
DWORD Quality,
DWORD PitchAndFamily,
LPCSTR pFaceName,
LPD3DXFONT* ppFont);

typedef int (WINAPI* nMultiByteToWideChar)( UINT, DWORD, LPCCH, int, LPWSTR, int);
typedef int (WINAPI* nWideCharToMultiByte)(UINT, DWORD, LPCWSTR, int, LPSTR, int, LPCSTR, LPBOOL);
typedef BOOL(WINAPI*nSetRect)(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int);
//typedef BOOL(WINAPI*nVirtualFree)(LPVOID, DWORD, DWORD);
typedef BOOL(WINAPI *nVirtualProtect)(LPVOID, DWORD, DWORD, PDWORD);
typedef void(WINAPI*nExitProcess)(UINT);
typedef int(WINAPI*nMessageBoxTimeoutA)(HWND hWnd, LPCSTR MbString, LPCSTR lpCaption, UINT uType, int a5, int a6);
typedef BOOL(WINAPI* nDisableThreadLibraryCalls)(HMODULE hLibModule);
typedef UINT(WINAPI* nGetSystemDirectoryA)(LPSTR lpBuffer, UINT uSize);
typedef BOOL(WINAPI* nGetCursorPos)(__out LPPOINT lpPoint);
typedef BOOL(WINAPI* nScreenToClient)(HWND hWnd, LPPOINT lpPoint);
typedef HWND(WINAPI* nGetForegroundWindow)();
typedef SHORT(WINAPI* nGetKeyState)(int nVirtKey);
typedef SHORT(WINAPI* nGetAsyncKeyState)(int vKey);
typedef int (WINAPI* nSHGetFolderPathA)(_Reserved_ HWND, _In_ int , _In_opt_ HANDLE , _In_ DWORD, _Out_writes_(MAX_PATH) LPSTR);


#pragma endregion

static std::vector<std::string>ModName = { XorStr("D3DX9_43.dll"), XorStr("shell32.dll"), XorStr("Kernel32.dll"),XorStr("ntdll.dll"),XorStr("USER32.dll") };
enum ModName_text { D3DX9_43, shell32, Kernel32, ntdll, USER32};

static std::vector<std::string>Funcname = {
XorStr("D3DXCreateFontA"),//0
XorStr("SHGetFolderPathA"),
XorStr("DisableThreadLibraryCalls"),
XorStr("GetSystemDirectoryA"),
XorStr("MultiByteToWideChar"),
XorStr("WideCharToMultiByte"),//5
XorStr("SetRect"),
XorStr("MessageBoxTimeoutA"),
XorStr("GetCursorPos"),
XorStr("ScreenToClient"),
XorStr("GetForegroundWindow"),//10
XorStr("GetKeyState"),
XorStr("GetAsyncKeyState"),
XorStr("NtFreeVirtualMemory"),
XorStr("NtProtectVirtualMemory"),
XorStr("NtCreateThreadEx"),//15
XorStr("RtlExitUserProcess")//16

};

Спойлер: XorCT.h

#pragma once



#include <string>
#include <array>
#include <cstdarg>


namespace XorCompileTime
{
constexpr auto time = __TIME__;
constexpr auto seed = static_cast<int>(time[7]) + static_cast<int>(time[6]) * 10 + static_cast<int>(time[4]) * 60 + static_cast<int>(time[3]) * 600 + static_cast<int>(time[1]) * 3600 + static_cast<int>(time[0]) * 36000;

template < int iValue >
struct RandomGenerator
{
private:
static constexpr unsigned a = 16807;
static constexpr unsigned m = 2147483647;
static constexpr unsigned s = RandomGenerator<iValue - 1>::value;
static constexpr unsigned lo = a * (s & 0xFFFF);
static constexpr unsigned hi = a * (s >> 16);
static constexpr unsigned lo2 = lo + ((hi & 0x7FFF) << 16);
static constexpr unsigned hi2 = hi >> 15;
static constexpr unsigned lo3 = lo2 + hi;

public:
static constexpr unsigned max = m;
static constexpr unsigned value = lo3 > m ? lo3 - m : lo3;
};

template <>
struct RandomGenerator< 0 >
{
static constexpr unsigned value = seed;
};

template < int N, int M >
struct RandomInt
{
static constexpr auto value = RandomGenerator< N + 1 >::value % M;
};

template < int N >
struct RandomChar
{
static const char value = static_cast<char>(1 + RandomInt< N, 0x7F - 1 >::value);
};

template < size_t N, int K >
struct XorString
{
private:
const char _key;
std::array< char, N + 1 > _encrypted;

constexpr char enc(char c) const { return c ^ _key; }
char dec(char c) const { return c ^ _key; }
public:
template < size_t... Is >
constexpr __forceinline XorString(const char* str, std::index_sequence< Is... >) : _key(RandomChar< K >::value), _encrypted{ enc(str[Is])... } {}

__forceinline decltype(auto) decrypt(void)
{
for (size_t i = 0; i < N; ++i)
{
_encrypted = dec(_encrypted);
}
_encrypted[N] = '\0';
return _encrypted.data();
}
};



#ifdef NDEBUG
#define XorStr( s ) ( XorCompileTime::XorString< sizeof( s ) - 1, __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ).decrypt() )
#else
#define XorStr( s ) ( s )
#endif
}

 

[Dimedrol]

Пример создания потока.

std::make_unique<CreateThread_>(функция, HINSTANCE из т.в.);

 

[L3D451R7]

Так бы и сказал что это ремейк WinAPI функций для облегчения защиты от их подмены, к примеру.

 

[Dimedrol]

Так бы и сказал что это ремейк WinAPI функций для облегчения защиты от их подмены, к примеру.

Ты бред написал.

 

[Крайслер]

#define _CRT_SECURE_NO_WARNINGS

если использовать новые стандарты, то от этого лучше избавляться(для старых он и не требуется)

 

[gob]

Ты бред написал.

Почему бред ? Тут много функции которые в есть в Winapi ну и парочка самописных бесполезных

 

[Крайслер]

Почему бред ? Тут много функции которые в есть в Winapi ну и парочка самописных бесполезных

если начнешь заниматься чем то более сложным чем КС, то поймешь, что данный метод очень полезен. а то что ты назвал "самописных бесполезных" на самом деле являются основными полезными функциями для разработки чего либо работающего с памятью или импортом))

PS: WinAPI это CRT по сути, а спалить что либо использующее CRT - это дело двух-трех строк)) поэтому CRT является самой слабой частью любого чита

 

[L3D451R7]

Ты бред написал.

Почему бред? тот же strcmp/strstr очень полезно ребилднуть и использовать, иначе можно будет очень легко подменить ответ и тем самым взломать.

 

[L3D451R7]

std::wstring s2ws(const std::string& str)
{
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
    std::wstring wstrTo(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
    return wstrTo;
}

Если кому надо конвентер из char в wchar (для GetModuleHandle)

 

[gob]

Почему бред? тот же strcmp/strstr очень полезно ребилднуть и использовать, иначе можно будет очень легко подменить ответ и тем самым взломать.

очень круто получать статик ответ от сервера ?

 

[Dimedrol]

std::wstring s2ws(const std::string& str)
{
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
    std::wstring wstrTo(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
    return wstrTo;
}

Если кому надо конвентер из char в wchar (для GetModuleHandle)

Ты очень плохо просмотрел код.
const wchar_t * cHideFunc::GetWideChar(const char *c)
{
const size_t cSize = strlen(c) + 1;
wchar_t* wc = new wchar_t[cSize];
mbstowcs(wc, c, cSize);

return wc;
}

 

[L3D451R7]

Ты очень плохо просмотрел код.
const wchar_t * cHideFunc::GetWideChar(const char *c)
{
const size_t cSize = strlen(c) + 1;
wchar_t* wc = new wchar_t[cSize];
mbstowcs(wc, c, cSize);

return wc;
}

ага блять, как же круто каждый раз вызывать new и после не удалять. привет memory leak.

 

[Dimedrol]

ага блять, как же круто каждый раз вызывать new и после не удалять. привет memory leak.

А ты что хотел? Увидеть идеальный код. Это уж сами подгоняйте его под себя.

 

[L3D451R7]

А ты что хотел? Увидеть идеальный код. Это уж сами подгоняйте его под себя.

тут подгоны не причем, это банальная халатность, если выкладываешь мог бы подогнать.

 

[Dimedrol]

Еще одно доказательство отсутствие мозгов у людей на данном портале.

 

[Dimedrol]

Если и хочешь добавить что-то свое, добавляй.

 

[L3D451R7]

Если и хочешь добавить что-то свое, добавляй.

Причем тут блять что-то свое? Ты банально если пастишь с других форумов то подписывай автора, еще и написал блять "для знающих" ты сам то знающий если такие тупые ошибки допускаешь?

 

[Blick1337]

Ты очень плохо просмотрел код.
const wchar_t * cHideFunc::GetWideChar(const char *c)
{
const size_t cSize = strlen(c) + 1;
wchar_t* wc = new wchar_t[cSize];
mbstowcs(wc, c, cSize);

return wc;
}

Вот так вот более правильно.

std::string WideStringToAnsi(std::wstring const &Str, UINT CodePage = CP_ACP)
{
    DWORD const BuffSize = WideCharToMultiByte(CodePage, 0, Str.c_str(), -1, NULL, 0, NULL, NULL);
    if (!BuffSize) return NULL;
    std::vector<char> Buffer;
    Buffer.resize(BuffSize);
    if (!WideCharToMultiByte(CodePage, 0, Str.c_str(), -1, &Buffer[0], BuffSize, NULL, NULL)) return NULL;
    return (&Buffer[0]);
}

 

[Крайслер]

Вот так вот более правильно.

вот так ты используешь STL, что в корне ломает весь смысл))

но если на то пошло, то можно так сделать:

std::wstring cUtilit::to_wchar_t(std::string str){
        return std::wstring_convert< std::codecvt_utf8<wchar_t>, wchar_t >{}.from_bytes(str);
    }

    std::string cUtilit::to_utf8(std::wstring wstr){
        return std::wstring_convert< std::codecvt_utf8<wchar_t>, wchar_t >{}.to_bytes(wstr);
}