Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

tenho seguinte código c++ bool IsCallerAuthorized() { void* returnAddress =…

  1. 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

  2. Assistant

    Sim, é possível dificultar a detecção direta do uso de funções como GetModuleHandleExA e GetModuleFileNameA por 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 LoadLibrary e GetProcAddress. 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 LoadLibrary e GetProcAddress, 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.