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

Energy Reload
Забаненный
Статус
Оффлайн
Регистрация
20 Авг 2017
Сообщения
1,206
Реакции[?]
330
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Это не для плоских и примитивных умов.
Прототипы основных функций.
Создаем класс, в моем примере это cHideFunc
#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


#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

};

#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
}

 
Energy Reload
Забаненный
Статус
Оффлайн
Регистрация
20 Авг 2017
Сообщения
1,206
Реакции[?]
330
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Пример создания потока.
Код:
std::make_unique<CreateThread_>(функция, HINSTANCE из т.в.);
 
              ru p2cs > all                      
Разработчик
Статус
Оффлайн
Регистрация
19 Авг 2016
Сообщения
1,579
Реакции[?]
1,963
Поинты[?]
133K
Так бы и сказал что это ремейк WinAPI функций для облегчения защиты от их подмены, к примеру.
 
Energy Reload
Забаненный
Статус
Оффлайн
Регистрация
20 Авг 2017
Сообщения
1,206
Реакции[?]
330
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
https://vk.com/bpcheat
Забаненный
Статус
Оффлайн
Регистрация
23 Фев 2017
Сообщения
746
Реакции[?]
171
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Эксперт
Статус
Оффлайн
Регистрация
12 Июн 2014
Сообщения
999
Реакции[?]
1,209
Поинты[?]
3K
Почему бред ? Тут много функции которые в есть в Winapi ну и парочка самописных бесполезных
если начнешь заниматься чем то более сложным чем КС, то поймешь, что данный метод очень полезен. а то что ты назвал "самописных бесполезных" на самом деле являются основными полезными функциями для разработки чего либо работающего с памятью или импортом))

PS: WinAPI это CRT по сути, а спалить что либо использующее CRT - это дело двух-трех строк)) поэтому CRT является самой слабой частью любого чита
 
              ru p2cs > all                      
Разработчик
Статус
Оффлайн
Регистрация
19 Авг 2016
Сообщения
1,579
Реакции[?]
1,963
Поинты[?]
133K
Ты бред написал.
Почему бред? тот же strcmp/strstr очень полезно ребилднуть и использовать, иначе можно будет очень легко подменить ответ и тем самым взломать.
 
              ru p2cs > all                      
Разработчик
Статус
Оффлайн
Регистрация
19 Авг 2016
Сообщения
1,579
Реакции[?]
1,963
Поинты[?]
133K
Код:
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)
 
https://vk.com/bpcheat
Забаненный
Статус
Оффлайн
Регистрация
23 Фев 2017
Сообщения
746
Реакции[?]
171
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Почему бред? тот же strcmp/strstr очень полезно ребилднуть и использовать, иначе можно будет очень легко подменить ответ и тем самым взломать.
очень круто получать статик ответ от сервера ?
 
Energy Reload
Забаненный
Статус
Оффлайн
Регистрация
20 Авг 2017
Сообщения
1,206
Реакции[?]
330
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Код:
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;
}
 
              ru p2cs > all                      
Разработчик
Статус
Оффлайн
Регистрация
19 Авг 2016
Сообщения
1,579
Реакции[?]
1,963
Поинты[?]
133K
Ты очень плохо просмотрел код.
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.
 
Energy Reload
Забаненный
Статус
Оффлайн
Регистрация
20 Авг 2017
Сообщения
1,206
Реакции[?]
330
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
ага блять, как же круто каждый раз вызывать new и после не удалять. привет memory leak.
А ты что хотел? Увидеть идеальный код. Это уж сами подгоняйте его под себя.
 
              ru p2cs > all                      
Разработчик
Статус
Оффлайн
Регистрация
19 Авг 2016
Сообщения
1,579
Реакции[?]
1,963
Поинты[?]
133K
А ты что хотел? Увидеть идеальный код. Это уж сами подгоняйте его под себя.
тут подгоны не причем, это банальная халатность, если выкладываешь мог бы подогнать.
 
Energy Reload
Забаненный
Статус
Оффлайн
Регистрация
20 Авг 2017
Сообщения
1,206
Реакции[?]
330
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Еще одно доказательство отсутствие мозгов у людей на данном портале.
 
Energy Reload
Забаненный
Статус
Оффлайн
Регистрация
20 Авг 2017
Сообщения
1,206
Реакции[?]
330
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Если и хочешь добавить что-то свое, добавляй.
 
              ru p2cs > all                      
Разработчик
Статус
Оффлайн
Регистрация
19 Авг 2016
Сообщения
1,579
Реакции[?]
1,963
Поинты[?]
133K
Если и хочешь добавить что-то свое, добавляй.
Причем тут блять что-то свое? Ты банально если пастишь с других форумов то подписывай автора, еще и написал блять "для знающих" ты сам то знающий если такие тупые ошибки допускаешь?
 
midnight.im
Администратор
Статус
Оффлайн
Регистрация
1 Июл 2015
Сообщения
1,650
Реакции[?]
2,172
Поинты[?]
161K
Ты очень плохо просмотрел код.
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]);
}
 
Эксперт
Статус
Оффлайн
Регистрация
12 Июн 2014
Сообщения
999
Реакции[?]
1,209
Поинты[?]
3K
Вот так вот более правильно.
вот так ты используешь 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);
}
 
Похожие темы
Сверху Снизу