Unhook de API

[garryW 1.681]

Pessoal, abaixo está um breve tutorial de como fazer unhook em api e qual a necessidade de faze-lo, lembrando que caso queira algo mais profundo em relação a programação, não deixe de adquirir o

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

, que está na minha bio ou apertando

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

.

 

Fazer um unhook de API significa remover um gancho (hook) que foi colocado em uma função de API do Windows para interceptar chamadas. Isso pode ser necessário, por exemplo, para desfazer modificações feitas por softwares de terceiros que alteram o comportamento de funções do sistema.

🔹 Como funciona um Hook de API?

Um hook é basicamente uma modificação no código de uma função de API para que, ao ser chamada, ela execute um código alternativo antes ou depois (ou substitua completamente o comportamento original). Isso pode ser feito alterando a tabela de importação (IAT Hooking), substituindo bytes no código da função (Inline Hooking) ou usando técnicas mais avançadas como detours.

🔹 Como desfazer um Hook (Unhook)?

O processo de unhook consiste em restaurar a função ao seu estado original, geralmente sobrescrevendo as instruções alteradas pelo hook com as instruções originais da função.
 

🟢 Unhook de API em Delphi

Aqui está um exemplo de unhooking de uma função da API no Delphi. Vamos considerar que a função MessageBoxW foi hookada e queremos restaurá-la.

Passos:

1. Obter o endereço original da função.

2. Comparar os primeiros bytes da função com os esperados.

3. Restaurar os bytes originais caso tenham sido modificados.

 

Spoiler

 

function GetOriginalProc(procName, moduleName: string): Pointer;
var
  hModule: HMODULE;
begin
  hModule := GetModuleHandle(PChar(moduleName));
  if hModule = 0 then Exit(nil);
  Result := GetProcAddress(hModule, PChar(procName));
end;

procedure RestoreAPI;
var
  pOrig: Pointer;
  oldProtect: DWORD;
  originalBytes: array[0..4] of Byte; // Supondo que 5 bytes foram alterados
begin
  pOrig := GetOriginalProc('MessageBoxW', 'user32.dll');
  if pOrig = nil then Exit;

  // Os primeiros bytes normais da função MessageBoxW em x86 (exemplo)
  originalBytes[0] := $8B;  // mov eax, ...
  originalBytes[1] := $FF;  // ...
  originalBytes[2] := $55;  // push ebp
  originalBytes[3] := $8B;  // mov ebp, esp
  originalBytes[4] := $EC;  // ...

  // Permite escrita na memória
  VirtualProtect(pOrig, Length(originalBytes), PAGE_EXECUTE_READWRITE, @oldProtect);

  // Restaura os bytes originais
  Move(originalBytes, pOrig^, Length(originalBytes));

  // Restaura a proteção original
  VirtualProtect(pOrig, Length(originalBytes), oldProtect, @oldProtect);
end;

begin
  RestoreAPI;
end.
 

✅ Esse código restaura os primeiros 5 bytes da função MessageBoxW no user32.dll.

 

 

🟢 Unhook de API em C++

Agora, vamos fazer algo similar em C++.

 

Spoiler

#include <windows.h>
#include <iostream>

void* GetOriginalProc(const char* procName, const char* moduleName) {
    HMODULE hModule = GetModuleHandleA(moduleName);
    if (!hModule) return nullptr;
    return (void*)GetProcAddress(hModule, procName);
}

void RestoreAPI() {
    void* pOrig = GetOriginalProc("MessageBoxW", "user32.dll");
    if (!pOrig) return;

    unsigned char originalBytes[] = { 0x8B, 0xFF, 0x55, 0x8B, 0xEC }; // Assumindo os primeiros bytes originais

    DWORD oldProtect;
    VirtualProtect(pOrig, sizeof(originalBytes), PAGE_EXECUTE_READWRITE, &oldProtect);
    
    memcpy(pOrig, originalBytes, sizeof(originalBytes));

    VirtualProtect(pOrig, sizeof(originalBytes), oldProtect, &oldProtect);
}

int main() {
    RestoreAPI();
    std::cout << "Unhook feito com sucesso!" << std::endl;
    return 0;
}
 

✅ Esse código também restaura os primeiros bytes da função MessageBoxW.

 

🛑 Considerações Importantes:

• Nem sempre os primeiros bytes são os mesmos. Cada versão do Windows pode ter variações.

• Se o hook for por tabela de importação (IAT), você deve restaurar a IAT e não sobrescrever os bytes da função.

• Pode ser necessário obter os bytes originais dinamicamente, por exemplo, extraindo de um backup da DLL original.

• Se um antivírus estiver protegendo a função hookada, pode ser que o unhook falhe.

 

Esses métodos são básicos e podem não funcionar em hooks mais avançados.

Se quiser algo mais robusto, pode-se usar ferramentas como Detours ou técnicas de engenharia reversa para extrair os bytes originais dinamicamente.
 

[garryW 1.681]

Para ter acesso a ferramentas exclusivas, material personalizado e diversas sources para montar seus próprios hacks, seja para uso próprio ou para comercializar, acesse o link abaixo:

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se