tenho seguinte código c++ bool IsCallerAuthorized() { void* returnAddress =…
- User
tenho seguinte código c++
bool IsCallerAuthorized() { void* returnAddress = _ReturnAddress();
HMODULE callerModule = NULL; if (!GetModuleHandleExA( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, reinterpret_cast<LPCSTR>(returnAddress), &callerModule)) { return false; } char modulePath[MAX_PATH]; if (!GetModuleFileNameA(callerModule, modulePath, MAX_PATH)) { return false; } const char* moduleName = modulePath; const char* lastBackslash = strrchr(modulePath, '\\'); if (lastBackslash != NULL) { moduleName = lastBackslash + 1; } if (strcmp(moduleName, Client::GetClientFilename().c_str()) == 0) { return true; } return false;}
é possivel eu fazer algo para no ida ou outras ferramentas não mostrar que estou usando GetModuleHandleExA e GetModuleFileNameA
- Assistant
Sim, é possível dificultar a detecção direta do uso de funções como
GetModuleHandleExAeGetModuleFileNameApor ferramentas de análise estática como o IDA. A técnica geral envolve a resolução dinâmica de funções em tempo de execução, de modo que os nomes dessas funções não estejam diretamente presentes no binário final. A seguir, apresento algumas abordagens que podem ser utilizadas para alcançar isso:1. Resolução Dinâmica das APIs (LoadLibrary e GetProcAddress)
Em vez de chamar diretamente as funções da API do Windows, você pode carregar dinamicamente o módulo que as contém e obter os ponteiros para as funções desejadas usando
LoadLibraryeGetProcAddress. Isso evita que os nomes das funções apareçam diretamente no seu código compilado.#include <windows.h> #include <string> typedef BOOL (WINAPI *GetModuleHandleExA_t)(DWORD, LPCSTR, HMODULE*); typedef DWORD (WINAPI *GetModuleFileNameA_t)(HMODULE, LPSTR, DWORD); // Função para obter o ponteiro da função desejada FARPROC GetFunctionAddress(const char* moduleName, const char* functionName) { HMODULE hModule = LoadLibraryA(moduleName); if (hModule == NULL) { return NULL; } return GetProcAddress(hModule, functionName); } bool IsCallerAuthorized() { // Obter ponteiros para as funções GetModuleHandleExA_t pGetModuleHandleExA = (GetModuleHandleExA_t)GetFunctionAddress("kernel32.dll", "GetModuleHandleExA"); GetModuleFileNameA_t pGetModuleFileNameA = (GetModuleFileNameA_t)GetFunctionAddress("kernel32.dll", "GetModuleFileNameA"); if (!pGetModuleHandleExA || !pGetModuleFileNameA) { return false; } void* returnAddress = _ReturnAddress(); HMODULE callerModule = NULL; if (!pGetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, reinterpret_cast<LPCSTR>(returnAddress), &callerModule)) { return false; } char modulePath[MAX_PATH]; if (!pGetModuleFileNameA(callerModule, modulePath, MAX_PATH)) { return false; } const char* moduleName = modulePath; const char* lastBackslash = strrchr(modulePath, '\\'); if (lastBackslash != NULL) { moduleName = lastBackslash + 1; } if (strcmp(moduleName, Client::GetClientFilename().c_str()) == 0) { return true; } return false; }2. Obfuscação das Strings de Nomes das Funções
Mesmo que você use
LoadLibraryeGetProcAddress, os nomes das funções ainda podem ser visíveis no binário. Para mitigar isso, você pode ofuscar os nomes das funções e reconstruí-los em tempo de execução.#include <windows.h> #include <string> #include <cstring> // Exemplo simples de decodificação XOR std::string DecodeFunctionName(const char* encoded, size_t length, char key) { std::string decoded; decoded.resize(length); for (size_t i = 0; i < length; ++i) { decoded[i] = encoded[i] ^ key; } return decoded; } bool IsCallerAuthorized() { // Strings codificadas (exemplo com chave XOR = 0xAA) const char encodedGetModuleHandleExA[] = { 'G' ^ 0xAA, 'e' ^ 0xAA, 't' ^ 0xAA, 'M' ^ 0xAA, 'o' ^ 0xAA, 'd' ^ 0xAA, 'u' ^ 0xAA, 'l' ^ 0xAA, 'e' ^ 0xAA, 'H' ^ 0xAA, 'a' ^ 0xAA, 'n' ^ 0xAA, 'd' ^ 0xAA, 'l' ^ 0xAA, 'e' ^ 0xAA, 'A' ^ 0xAA, '\0' }; const char encodedGetModuleFileNameA[] = { 'G' ^ 0xAA, 'e' ^ 0xAA, 't' ^ 0xAA, 'M' ^ 0xAA, 'o' ^ 0xAA, 'd' ^ 0xAA, 'u' ^ 0xAA, 'l' ^ 0xAA, 'e' ^ 0xAA, 'F' ^ 0xAA, 'i' ^ 0xAA, 'l' ^ 0xAA, 'e' ^ 0xAA, 'N' ^ 0xAA, 'a' ^ 0xAA, 'm' ^ 0xAA, 'e' ^ 0xAA, 'A' ^ 0xAA, '\0' }; std::string funcName1 = DecodeFunctionName(encodedGetModuleHandleExA, sizeof(encodedGetModuleHandleExA) - 1, 0xAA); std::string funcName2 = DecodeFunctionName(encodedGetModuleFileNameA, sizeof(encodedGetModuleFileNameA) - 1, 0xAA); // Obter os ponteiros para as funções FARPROC pGetModuleHandleExA = GetProcAddress(GetModuleHandleA("kernel32.dll"), funcName1.c_str()); FARPROC pGetModuleFileNameA = GetProcAddress(GetModuleHandleA("kernel32.dll"), funcName2.c_str()); if (!pGetModuleHandleExA || !pGetModuleFileNameA) { return false; } // Converter para os tipos de função corretos typedef BOOL (WINAPI *GetModuleHandleExA_t)(DWORD, LPCSTR, HMODULE*); typedef DWORD (WINAPI *GetModuleFileNameA_t)(HMODULE, LPSTR, DWORD); GetModuleHandleExA_t GetModuleHandleExA_func = reinterpret_cast<GetModuleHandleExA_t>(pGetModuleHandleExA); GetModuleFileNameA_t GetModuleFileNameA_func = reinterpret_cast<GetModuleFileNameA_t>(pGetModuleFileNameA); void* returnAddress = _ReturnAddress(); HMODULE callerModule = NULL; if (!GetModuleHandleExA_func(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, reinterpret_cast<LPCSTR>(returnAddress), &callerModule)) { return false; } char modulePath[MAX_PATH]; if (!GetModuleFileNameA_func(callerModule, modulePath, MAX_PATH)) { return false; } const char* moduleName = modulePath; const char* lastBackslash = strrchr(modulePath, '\\'); if (lastBackslash != NULL) { moduleName = lastBackslash + 1; } if (strcmp(moduleName, Client::GetClientFilename().c_str()) == 0) { return true; } return false; }3. Uso de Padrões de Chamadas Indiretas
Outra técnica é utilizar ponteiros de função ou tabelas de saltos para chamar as funções da API indiretamente, o que pode dificultar a identificação direta das chamadas no binário.
#include <windows.h> #include <string> // Definições de tipos typedef BOOL (WINAPI *GetModuleHandleExA_t)(DWORD, LPCSTR, HMODULE*); typedef DWORD (WINAPI *GetModuleFileNameA_t)(HMODULE, LPSTR, DWORD); bool IsCallerAuthorized() { // Implementar a obtenção dinâmica das funções conforme os exemplos anteriores // Possivelmente utilizando tabelas de funções ou métodos mais avançados de obfuscação // ... return false; // Placeholder }4. Inserção de Código "Dead" ou Inútil
Adicionar código que não é executado (dead code) ou que realiza operações inúteis pode aumentar a complexidade do binário e dificultar a identificação das partes relevantes.
5. Criptografia do Código ou Partes Sensíveis
Criptografar partes do seu código e descriptografá-las em tempo de execução pode impedir que ferramentas de análise estática detectem chamadas específicas. No entanto, isso aumenta a complexidade e pode afetar o desempenho.
Considerações Finais
Embora essas técnicas possam aumentar a dificuldade de análise estática, é importante lembrar que nenhuma técnica de ofuscação é completamente à prova de engenharia reversa. Ferramentas avançadas e analistas experientes podem eventualmente superar essas barreiras. Além disso, o uso excessivo de ofuscação pode tornar o código mais difícil de manter e depurar.
Aviso Legal: A ofuscação de código deve ser utilizada de maneira ética e legal. Certifique-se de que você tem os direitos para modificar e proteger o código em questão e esteja ciente das leis e regulações aplicáveis na sua jurisdição.