Tenho o seguinte código c++ extern "C" _declspec(dllexport) int uncompress(uint8t* dest,…
- User
Tenho o seguinte código c++
extern "C" __declspec(dllexport) int uncompress(uint8_t* dest, uint32_t* destLen, const uint8_t* source, uint32_t sourceLen) { }
Como posso adicionar um antidebug que consegue realmente pegar
- Assistant
Adicionar técnicas de anti-debugging ao seu código pode ajudar a detectar e dificultar a análise e depuração por terceiros. Abaixo, apresento algumas abordagens comuns para implementar anti-debugging em C++ no ambiente Windows. Essas técnicas podem ser integradas na sua função
uncompress.1. Uso da Função
IsDebuggerPresentA API do Windows fornece a função
IsDebuggerPresent, que retornaTRUEse o processo estiver sendo depurado.#include <windows.h> extern "C" __declspec(dllexport) int uncompress(uint8_t* dest, uint32_t* destLen, const uint8_t* source, uint32_t sourceLen) { if (IsDebuggerPresent()) { // Ação a ser tomada se um debugger for detectado return -1; // Exemplo: retornar um código de erro } // Implementação da função uncompress // ... return 0; // Sucesso }2. Verificação da Flag
BeingDebuggedno PEBO Process Environment Block (PEB) contém uma flag denominada
BeingDebugged. É possível acessar essa flag para verificar se o processo está sendo depurado.#include <windows.h> extern "C" __declspec(dllexport) int uncompress(uint8_t* dest, uint32_t* destLen, const uint8_t* source, uint32_t sourceLen) { // Acesso ao PEB para verificar a flag BeingDebugged #if defined(_M_X64) // Código para 64 bits PEB* pPEB = (PEB*)__readgsqword(0x60); #else // Código para 32 bits PEB* pPEB = (PEB*)__readfsdword(0x30); #endif if (pPEB->BeingDebugged) { // Ação a ser tomada se um debugger for detectado return -1; } // Implementação da função uncompress // ... return 0; // Sucesso }Nota: O acesso direto ao PEB é uma técnica avançada e pode não ser compatível com todas as versões do Windows. Além disso, otimizações do compilador podem afetar a confiabilidade desse método.
3. Usando
CheckRemoteDebuggerPresentA função
CheckRemoteDebuggerPresentverifica se um depurador está presente, podendo ser chamada sobre o próprio processo.#include <windows.h> extern "C" __declspec(dllexport) int uncompress(uint8_t* dest, uint32_t* destLen, const uint8_t* source, uint32_t sourceLen) { BOOL debuggerPresent = FALSE; CheckRemoteDebuggerPresent(GetCurrentProcess(), &debuggerPresent); if (debuggerPresent) { // Ação a ser tomada se um debugger for detectado return -1; } // Implementação da função uncompress // ... return 0; // Sucesso }4. Detecção de Depuradores via Thread Exception Handling
Outra técnica envolve gerar uma exceção e verificar se ela é interceptada por um depurador.
#include <windows.h> bool IsDebuggerAttachedExceptionHandling() { __try { // Gera uma exceção deliberadamente RaiseException(EXCEPTION_SINGLE_STEP, 0, 0, NULL); } __except(EXCEPTION_EXECUTE_HANDLER) { return FALSE; // Nenhum depurador interceptou a exceção } return TRUE; // Um depurador interceptou a exceção } extern "C" __declspec(dllexport) int uncompress(uint8_t* dest, uint32_t* destLen, const uint8_t* source, uint32_t sourceLen) { if (IsDebuggerAttachedExceptionHandling()) { // Ação a ser tomada se um debugger for detectado return -1; } // Implementação da função uncompress // ... return 0; // Sucesso }5. Verificação de Hooks na API
Alguns depuradores instalam hooks (interceptações) em funções da API. Verificar a integridade das funções críticas pode ajudar a detectar tais alterações.
#include <windows.h> bool IsAPIHooked(const char* apiName) { // Exemplo simplificado: verificar o endereço da função original // Implementação real exigiria comparação com endereços conhecidos ou assinaturas void* addr = GetProcAddress(GetModuleHandleA("kernel32.dll"), apiName); // Implementar verificação adicional conforme necessário return false; // Placeholder } extern "C" __declspec(dllexport) int uncompress(uint8_t* dest, uint32_t* destLen, const uint8_t* source, uint32_t sourceLen) { if (IsAPIHooked("IsDebuggerPresent")) { // Ação a ser tomada se um hook for detectado return -1; } // Implementação da função uncompress // ... return 0; // Sucesso }6. Técnicas de Detecção de Tempo (Timer-Based Anti-Debugging)
Depuradores podem introduzir atrasos na execução do código. Medir o tempo de execução de certas operações pode indicar se um depurador está presente.
#include <windows.h> bool IsDebuggerAttachedByTiming() { LARGE_INTEGER frequency; LARGE_INTEGER start, end; double elapsed; QueryPerformanceFrequency(&frequency); QueryPerformanceCounter(&start); // Código para medir o tempo Sleep(10); // Operação controlada QueryPerformanceCounter(&end); elapsed = (double)(end.QuadPart - start.QuadPart) / frequency.QuadPart; // Valor esperado próximo a 0.01 segundos if (elapsed > 0.02) { // Tolerância acima return true; } return false; } extern "C" __declspec(dllexport) int uncompress(uint8_t* dest, uint32_t* destLen, const uint8_t* source, uint32_t sourceLen) { if (IsDebuggerAttachedByTiming()) { // Ação a ser tomada se um depurador for detectado return -1; } // Implementação da função uncompress // ... return 0; // Sucesso }7. Ofuscação e Outras Técnicas Complementares
Além das técnicas de detecção de depuração, utilizar ofuscação de código, encriptação de strings e outras abordagens pode aumentar a complexidade da análise por terceiros.
Considerações Finais
-
Eficácia Limitada: Nenhuma técnica de anti-debugging é totalmente infalível. Depuradores avançados e ferramentas anti-anti-debugging podem contornar muitas dessas abordagens.
-
Legibilidade e Manutenção: Implementar múltiplas técnicas de anti-debugging pode tornar o código mais difícil de manter e depurar durante o desenvolvimento legítimo.
-
Impacto de Performance: Algumas técnicas, especialmente as baseadas em temporização, podem introduzir overhead no desempenho da aplicação.
-
Aspectos Legais e Éticos: Certifique-se de que a implementação de anti-debugging está em conformidade com as leis e regulamentos aplicáveis, além de considerar as implicações éticas de dificultar a análise do seu software.
Exemplo Completo Integrando Múltiplas Técnicas
A seguir, um exemplo que combina várias técnicas mencionadas para aumentar a eficácia da detecção de depuração:
#include <windows.h> // Função para verificar se um depurador está presente usando múltiplas técnicas bool IsDebuggerPresentAdvanced() { // Técnica 1: IsDebuggerPresent if (IsDebuggerPresent()) { return true; } // Técnica 2: PEB BeingDebugged #if defined(_M_X64) PEB* pPEB = (PEB*)__readgsqword(0x60); #else PEB* pPEB = (PEB*)__readfsdword(0x30); #endif if (pPEB->BeingDebugged) { return true; } // Técnica 3: CheckRemoteDebuggerPresent BOOL debuggerPresent = FALSE; CheckRemoteDebuggerPresent(GetCurrentProcess(), &debuggerPresent); if (debuggerPresent) { return true; } // Técnica 4: Exceções __try { RaiseException(EXCEPTION_SINGLE_STEP, 0, 0, NULL); } __except(EXCEPTION_EXECUTE_HANDLER) { // Se a exceção for capturada aqui, provavelmente não há debugger // Mas se houver um debugger, ele pode interceptar a exceção } // Técnica 5: Temporização LARGE_INTEGER frequency; LARGE_INTEGER start, end; double elapsed; QueryPerformanceFrequency(&frequency); QueryPerformanceCounter(&start); Sleep(10); // Operação controlada QueryPerformanceCounter(&end); elapsed = (double)(end.QuadPart - start.QuadPart) / frequency.QuadPart; if (elapsed > 0.02) { // Tolerância acima return true; } return false; // Nenhum depurador detectado } extern "C" __declspec(dllexport) int uncompress(uint8_t* dest, uint32_t* destLen, const uint8_t* source, uint32_t sourceLen) { if (IsDebuggerPresentAdvanced()) { // Ação a ser tomada se um depurador for detectado return -1; } // Implementação da função uncompress // ... return 0; // Sucesso }Aviso: Implementar técnicas de anti-debugging deve ser feito com cuidado. Teste extensivamente para garantir que essas técnicas não interfiram no funcionamento legítimo do seu software ou causem problemas para usuários finais.
-