28 replies to this topic

[escafandra]

Como en algún sitio comenté, si me animo publico un tutorial sobre este tema...

Una advertencia antes de comenzar. El código de este tutorial es funcional y está diseñado para ser compilado y trabajar en un entorno de 32 bits.


EL HOOK A LA API EN DELPHI

Existen dos formas básicas de realizar un Hook a la API y múltiples variantes. Ninguna técnica es perfecta, todas tienen sus ventajas y sus inconvenientes. Todas requieren inyectar código en el proceso anfitrión.


- EL Hook en la IAT:

Quizás la forma mas sencilla sea el Hook en la IAT. La IAT es una Tabla en la cabecera PE de todo ejecutable y DLL que contiene las direcciones de las API y funciones que importa de forma estática (en tiempo de compilación). Cambiando el valor de esas direcciones a una función Gancho tenemos realizado el Hook. Es un método muy estable pero requiere cambiar el valor de la dirección en todos los módulos del proceso que importen dicha API. No funciona para API importada de forma dinámica, es decir con GetProcAddress.


- El Hook Trampolín:

Con esta técnica modificamos instrucciones asm de la API para provocar un salto a nuestro código. Nuestro código debe ser capaz de llamar, después a la API original sin provocar errores. Esta técnica es algo mas compleja que la anterior, funciona para APIs importadas tanto de forma estática como dinámica pero se pueden cometer errores al medir mal el número de bytes sobrescritos, partiendo una instrucción asm y alterando, con ello, el sentido del código.


Hace un tiempo, seoane publicó en su web un código para realizar un Hook a la IAT escrito en delphi. Yo me voy a centrar en la técnica del trampolín.


La filosofía de un Hook de tipo trampolín:

Como expliqué antes tenemos que buscar una fracción de código de la API original que podamos sobrescribir con cierta tranquilidad. Lo ideal es encontrar una zona de longitud 5 bytes, en una o varias instrucciones completas asm. Si nos fijamos como comienza el código asm de una API, casi siempre se repite la misma secuencia:
 

delphi

8BFF    mov edi, edi
55      push ebp
8BEC    mov ebp, esp

Lo ideal sería que esto fuera una constante, pero me he encontrado APIs con codificación distinta en distintos PCs, posiblemente debido a las distintas actualizaciones del S.O.

Otro buen punto, puede ser buscar una instrucción de salto (jmp) o llamada a subrutina (call) pero lógicamente no la encontraremos en sitios fijos, entorpeciendo un sistema automático de Hook. Esto nos obliga, en cierta forma, a proceder a un desensamblado de parte del código, bien manual para cada API, bien automático. Nosotros vamos a usar un desensamblador de longitud que nos informa de la longitud de las instrucciones asm. Esta herramienta es justo lo que nos hace falta para controlar que no partimos instrucciones al realizar la preparación del hook.

El código que muestro en este tutorial se centra en los 5 primeros bytes de la API. La filosofía será establecer un puntero especial, del mismo tipo que la API que vamos a enganchar. En el código para automatizar Hooks llamaré a este puntero, ToAPI. Vamos a reservar memoria para él de al menos mas de 10 bytes(los 5 o mas copiados desde la API original, más otros 5 para un salto). También escribiremos la función HOOK o suplantadora, que será declarada exactamente como la API original, yo la suelo denominar como la API víctima con el prefijo New. Los primeros 5 o mas Bytes de la API original serán copiados al Buffer apuntado por ToAPI, de forma que se copien instrucciones completas y si hubiese algún salto habría que recalcularlo. Detrás de los 5 o mas bytes copiados, escribiremos una instrucción de salto ($E9) que apunta al resto de código no copiado de la API original. Esto es para poder devolver el flujo del programa al punto donde lo interrumpiremos. En la API original rescribiremos los 5 bytes con otro salto ($E9) que apunta a nuestra función Hook (NewAPI). Cuando nuestro Hook necesite llamar a la API original, usaremos el puntero ToAPI como si fuese una función, que de hecho lo es.

El código de este tutorial es operativo y permite automatizar un Hook a cualquier API a nivel usuario de forma automatizada.

Un ejemplo vale mas que mil palabras, vamos a realizar un Hook a la API MessageBox en nuestro propio proceso. Comenzamos por un esquema de cómo queda el código asm que vamos a alterar:

Attached Files

•  3967_e9ae93e897c19afc9a868accc0c3ca7834bc5b4a.png   85KB   24 downloads
•  3965_570dbd335dc6849ba45e973feffa48e4e751a749.png   128.7KB   23 downloads

[escafandra]

Para nuestro propósito vamos a necesitar usar determinadas APIs de Windows:

LoadLibrary: Carga una dll, si ya está cargada aumenta el contador en uno.
FreeLibrary: Decrementa el contador de carga de dll y a cero la descarga.
GetModuleHandle: Encuentra el HMODULE de una dll si está cargada.
GetProcAddress: Encuentra el puntero a una función exportada por una dll.
VirtualAlloc: Localiza memoria.
VirtualFree: Libera memoria
VirtualProtectEx: Cambia los permisos de escritura de un bloque de memoria.
FlushInstructionCache: Actualiza el caché de instrucciones del microprocesador.
CopyMemory: Copia un bloque de memoria en otro.


El código de alto nivel:

Comenzamos con los preparativos antes de entrar en la parte automática de bajo nivel:

delphi

// Definición de tipo puntero a la API MessageBox
type PMESSAGEBOX = function(hWnd: THandle; lpText, lpCaption: PCHAR; uType: integer): Integer; stdcall;
 
 
var
  // Puntero a un buffer que representa la API original
  // Al hacer el Hook reservamos memoria y copiamos los 5 bytes
  // y un salto a la API original
  OMessageBox: PMESSAGEBOX = nil;                                   
 
 
 
implementation
 
// La API hookeada
function NewMessageBox(hWnd: THandle; lpText, lpCaption: PCHAR; uType: integer): Integer; stdcall;
begin
  // OMessageBox representa la API original.
  // Cambiamos parámetros para delatar el Hook...
  Result:= OMessageBox(hWnd, 'MessageBox HOOKED    ', lpCaption, uType or MB_ICONEXCLAMATION);
end;

El código de bajo nivel:

Bueno, el resto del trabajo es el duro, bajo nivel y punteros.
El código, que he escrito y os presento, automatiza este trabajo. Creo que si le prestáis atención se puede entender bien.

delphi

// Calcula la dirección de la API original para llamar a la siguiente función
procedure InstallHook(HookAPI: Pointer; var ToAPI: Pointer; dllName, ApiName: PCHAR; Resume: BOOL);
var
  hLib: HMODULE;
  API: PBYTE;
begin
  hLib:= GetModuleHandle(dllName);
  if hLib = 0 then hLib:= LoadLibrary(dllName);
  if hLib <> 0 then
  begin
    API:= GetProcAddress(hLib, ApiName);
    InstallHookFromAddr(HookAPI, ToAPI, API, Resume);
  end;
end;
// Realiza el Hook a la API. Devuelve un puntero a la función puente ToAPI
// Si Resume = true, el hook está operativo.
procedure InstallHookFromAddr(HookAPI: Pointer; var ToAPI: Pointer; API: Pointer; Resume: BOOL);
var
  NBytes: DWORD;
  OldProtect: DWORD;
begin
  // Bytes a sobreescribir de la API
  NBytes  := GetOverloadBytes(API);
  // reservar memoria para ToAPI, el camino de vuelta...
  ToAPI  := VirtualAlloc(nil, NBytes+5, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 
  // Preparar la función ToAPI
  // Autorizo escribir en ToAPI, es un puntero a una función...
  VirtualProtectEx(THandle(-1), ToAPI, NBytes+5, PAGE_EXECUTE_READWRITE, OldProtect);
  // Copio los primeros bytes de la api original
  ASMmemcpy(ToAPI, API, NBytes);
  // Escribo un salto relativo a la API original
  PBYTE(DWORD(ToAPI) + NBytes)^:= $E9 ; //jmp
  PDWORD(DWORD(ToAPI) + NBytes+1)^:= DWORD(API) - DWORD(ToAPI) - 5;
  VirtualProtectEx(THandle(-1), ToAPI, NBytes+5, OldProtect, PDWORD(nil)^);
 
  // Preparar la API a Hookear
  if Resume then ResumeHookFromAddr(HookAPI, API);
 
  // Obliga al procesaror a alcualizar el cache de instruciones
  // pues las hemos modificado...
  FlushInstructionCache(GetCurrentProcess, nil, 0);
end;
 
// Esta función escribe el salto en la API original
// Deja el Hook totalmente operativo
procedure ResumeHookFromAddr(HookFunc, API: Pointer);
var
  OldProtect: DWORD;
begin
  if (HookFunc = nil) or (API = nil) then exit;
 
  // Autorizo escribir en la API a Hookear
  VirtualProtectEx(THandle(-1), API, 5, PAGE_EXECUTE_READWRITE, OldProtect);
  // escribimos el salto: jmp
  PBYTE(API)^:= $E9;
  // escribimos la dirección relativa del salto
  PDWORD(DWORD(API)+1)^:= DWORD(HookFunc) - (DWORD(API) + 5);
  VirtualProtectEx(THandle(-1), API, 5, OldProtect, PDWORD(nil)^);
end;
 
// Para llamar a ResumeHookFromAddr desconociendo la dirección de la API
procedure ResumeHook(HookFunc: Pointer; dllName, ApiName: PCHAR);
var
  API: Pointer;
begin
  if HookFunc = nil then exit;
  API:= GetProcAddress(GetModuleHandle(dllName), ApiName);
  if API <> nil then
    ResumeHookFromAddr(HookFunc, API);
end;

Ya tenemos hecho el Hook. Parte del código no está expuesto. Quiero comentar que la función GetOverloadBytes calcula el número de bytes que debemos traspasar sin peligro al Buffer apuntado por ToAPI. Para calcularlo usa un desensamblador de longitud de instrucción. Se puede prescindir de ello pero se corre el riesgo de colgar la aplicación víctima si la API “hookeada” comienza con instrucciones completas en 6 bytes, por ejemplo; ¡partiríamos una instrucción asm perdiendo el sentido del resto del código...!

Ahora faltan las labores de limpieza. Deberíamos ser capaces de deshacer el hook dejando todo como estaba antes de nuestra intromisión.
 

delphi

// Suspende momentáneamente el Hook sin desinstalar ToHook
// Restaura los Bytes de la API original guardados en ToAPI
procedure SuspendHookFromAddr(ToAPI, API: Pointer);
var
  OldProtect: DWORD;
begin
  if(ToAPI = nil) or (API = nil) then exit;
  // Autorizo escribir en la API Hookeada
  VirtualProtectEx(THandle(-1), API, 5, PAGE_EXECUTE_READWRITE, OldProtect);
  CopyMemory(API, ToAPI, 5);
  VirtualProtectEx(THandle(-1), API, 5, OldProtect, PDWORD(nil)^);
end;
 
procedure SuspendHook(ToAPI: Pointer; dllName, ApiName: PCHAR);
var
  API: Pointer;
  hLib: HMODULE;
begin
  if(ToAPI = nil) or (dllName = nil) or (ApiName = nil) then exit;
 
  hLib:= GetModuleHandle(dllName);
  if hLib = 0 then  hLib:= LoadLibrary(dllName);
  if hLib = 0 then exit;
 
  API:= GetProcAddress(hLib, ApiName);
  if API <> nil then
    SuspendHookFromAddr(ToAPI, API);
end;
 
// ToAPI:  Función preparada para saltar a la API original.
// Contiene los primeros Bytes de la API original y un salto a ella
procedure UnInstallHook(var ToAPI: Pointer; dllName, ApiName: PCHAR);
var
  hLib: HMODULE;
  API: Pointer;
begin
  hLib:= GetModuleHandle(dllName);
  if hLib = 0 then  hLib:= LoadLibrary(dllName);
  if hLib <> 0 then
  begin
    API:= GetProcAddress(hLib, ApiName);
    if API <> nil then UnInstallHookFromAddr(ToAPI, API);
  end;
end;
 
// Suspende el Hook restaurando la API original y libera el Buffer ToAPI
procedure UnInstallHookFromAddr(var ToAPI: Pointer; API: Pointer);
begin
  if (ToAPI = nil) or (API = nil) then exit;
  SuspendHookFromAddr(ToAPI, API);
  VirtualFree(ToAPI, 0, MEM_RELEASE);
  ToAPI:= nil;
end;

Bueno este es el principal del código. Subo un archivo con todo el fuente y un proyecto listo para compilar.

Debéis usar esto con cuidado pues un error va a hacer caer la aplicación. Como comenté antes este ejemplo realiza un Hook a MessageBox en nuestra propia aplicación, como ejemplo vale, pero el objetivo útil sería una aplicación ajena. Para ello escribiremos el Hook en una dll que inyectaremos en el proceso anfitrión. Esa dll, una vez inyectada realizaría el Hook y desde ese momento ya tenemos el control de nuestra API...

Los Platinos podréis disfrutar de un Hook a un par de APIs un tanto especiales en un proceso que no lo es menos.

Espero haber sabido explicarme y que este pequeño tutorial sirva de ayuda.


PD: Subo el código

Saludos.

Attached Files

•  APIHook_Delphi.rar   163.23KB   77 downloads

[egostar]

Es facinante el asunto de acceder a la API de windows, pero dado que mi conocimiento está muy por debajo de lo que expones, quiero preguntar,

¿ Para que nos sirve hacer esto ?

¿ Con ese salto, estás modificando el comportamiento de la función (en este caso) MessageBoxA ?

¿ Que pasa con el asunto de las restricciones a WRT en Windows8 ?

¿ Se está sobreescribiendo el API ?

Perdón pero soy un total ignorante en esto de las API's

Saludos

[escafandra]

Te respondo en desorden...

¿ Se está sobreescribiendo el API ?

Si, la estamos invadiendo, ultrajando...

¿ Para que nos sirve hacer esto ?

Para espiarla y variar su comportamiento si procede. Este ejemplo la espía y extrae datos. Este otro hace variar el comportamiento. Este otro hilo está basado en una miniApp antivirus que me tuve que hacer, usaba un Hook a CreateProcessInternalW.

¿ Con ese salto, estás modificando el comportamiento de la función (en este caso) MessageBoxA ?

En este caso si pero puedes desear sólo vigilar...

¿ Que pasa con el asunto de las restricciones a WRT en Windows8 ?

Ya lo iremos viendo...


Saludos.

[cadetill]

Yo sólo puedo quitarme el sombrero con vuestro conocimiento del API de Wndows

[Delphius]

La idea y el propósito de un hook entiendo. Ahora bien, meterme conceptualmente en sus berenjales ¡primero debo morir y nacer dos veces! A mi sólo me queda leer y sentirme chiquitito antes semejantes explicaciones de los genios.

Saludos,

[jeivarmarr]

Gracias por este gran tutorial pero me causo curiosidad lo de windows 8 actualmente tengo windows 8 y he intentado lo del hook y nunca me funciono, podrias explicarme mejor sobre la proteccion.

[jeivarmarr]

Una pregunta mas, para hacerlo a un proceso externo por ejemplo Calc.exe, como lo haría?

[escafandra]

jeivarmarr, para realizar un Hook a la API precisas inyectar código en tu proceso anfitrión. El código lo inyectas con una dll o de forma directa. El método mas común de inyectar una dll es obligar su carga con CreateRemoteThread aquí dejé un ejemplo en C. Las técnicas de inyección directa son mas complejas, dejé un tutorial aquí.

No se puede inyectar código compilado de 32bits en procesos de 64bits ni de forma directa ni con dll. Solución: usar un compilador de 64 bits.

El Hook a la API que describo es válido sólo en teoría para win8 pero en la práctica usa un desensamblador de 32 bits lo que lo hace no operativo para 64 bits

No dispongo de un PC con Win8, por el momento, con lo que no puedo hacer pruebas para responderte acerca de los sistemas de seguridad.


Saludos.

[c0lo]

Hola escafandra,

Si uno desearía hacer el problema inverso, es decir, si uno se encuentro con algunos Hooks en algunas apis como podría uno atacar o empezar a desarrollar una solución o hacer un unhook a dicha api o n-api?

Digamos que no es el clásico trampolín de 5 bytes si no que uno se encuentra con una modificación de la api del tamaño de 6 bytes?

Es decir, tenemos el inicio de una api de la siguiente forma:
 

delphi

mov edi,edi
push ebp
mov ebp,esp
push ecx
or dword ptr [ebp-04],FF

Pero luego de ejecutar alguna programa X, la api su parte inicial es modificada a:

delphi

jmp dword ptr [71A1001E]
or dword ptr [ebp-4], FFFFFFFF

Es decir, en ves de modificar los primeros 5 bytes el hook del programa X ha modificado los primeros 6 bytes, que hizo? o cual fue su tipo de trampolin y como uno podria hacer un unhook en este caso y cualquiera que fuera el unhook?

Saludos 

[c0lo]

Epa epa... creo que sufri un lapsus, Porque si deseo hacer el unhook solo sobre escribo los bytes que inicialmente tenia la api o reconstruyo la api y listo. Oh no?

Bueno mi pregunta es como puedo utilizar la misma api con su hook sin realizar el hook, no recuerdo como se llama este metodo... Pero se podria?

[escafandra]

Hola c0lo si se podría reconstruir la API original. Pero puede ser algo complicado. Deberemos desensamblar y seguir el código haciendo énfasis en los saltos. La API original tiene direcciones del orden 7EXXXXXXh y el resto del código (Hook) direcciones mas bajas. Si la API original está hookeada con un jmp seguiremos el hook hasta encontrar el jmp de vuelta (salto relativo a direcciones del orden de 7EXXXXXXh). Unas cuantas instrucciones antes nos enseñarán el clásico "paquete de inicio":

php

mov edi,edi
push ebp
mov ebp,esp
..... quizás mas instruciones
jmp XXXXX

Ese paquete hasta el salto de vuelta (sin contar éste) será lo que debemos sobreescribir en la API Hookeada para devolverla a su estado original.

El tema se puede complicar si el sistema de hook es con call, entonces buscaremos un ret pero existen trucos para volver con un salto y no con ret. Así mismo en el paquete que debemos restaurar pueden aparecer saltos intermedios que no correspondan al punto de vuelta... En general el salto de vuelta no debe estar mucho mas alejado de esos 5 bytes clásicos del trampolín, si fuere así, ese salto no es el de vuelta, continuaremos un poco mas adelante hasta encontrarlo, pero el salto intermedio deberemos "convertirlo" pues es relativo, para adaptarlo al código de la API cuando la restauremos.

Una técnica mas sencilla es hacer un hook al hook, es decir cambiar el código hookeado colocando un salto directo al "paquete de vuelta" a la API original. Bastará localizar el paquete y escribir el salto justo al inicio del código que hookea la API original.

No tengo escrito código para realizar un unhook automático cuyo hook no halla hecho yo.

Claro, que si lo que quieres es un unhook de un hook que tu mismo hagas, no tienes mas que guardar el paquete original a buen recaudo para restaurarlo cuando quieras.

Quizás las explicaciones son un poco liosas, pero se entenderán mejor si se vuelve la vista atrás sobre las imágenes del hook de este tutorial.


Saludos.

[FENIXadr]

Hola gente .. estoy buscando por muchos lugares un Hook a CreateProcess para monitorear lo que se ejecuta en mi PC y pregunto.. podemos utilizar este método y reemplazar todo lo referente a MessageBox por CreateProcess??.. de ser así que se debe tener en cuenta además?? serían tan amables de poner un ejemplo??.. desde ya muchas gracias..

[escafandra]

Puedes hacer un Hook a cualquier API. En tu caso sería a CreateProcessInternalW. Revisa este hilo y este otro ejemplo.


Saludos.

[aguml]

hola amigo, tengo un problema y no se si realmente necesito hacer un hook o que es lo que necesito hacer. Estoy creando una clase que te permite crear loaders debuggers y estoy liado con los anti anti debuger y ya tengo solucionados los que usan el peb y ahora queria liarme con NtQueryInformationProcess el cual si le metes como parametro 7 te devuelve en el buffer 0xFFFFFFFF y la cosa es que no devuelva ese valor en el buffer sino otro. Lo mismo me pasará con gettickcount cuando le quiera meter mano. Como el proceso estaria siendo depurado por mi proceso, ¿Tendria que hacer un hook? NtQueryInformationProcess se carga dinamicamente con loadlibrary y getprocaddress ¿Tendria que hacer un hook a getprocaddress y filtrar hasta que quiera cargar la api deseada y ejecutar una funcion mia en lugar de la original?

[escafandra]

Un Hook a la API que quieres modificar es mas apropiado que otro a GetProcAddress, entre otras cosas porque puedes dejar trabajar a la API capturada o no, según tu necesidad.


Saludos.

[aguml]

¿Y se puede hacer que el Hook solo afecte al proceso y sus threads?
Yo hice lo siguiente:

Cree una dll con este codigo:

cpp

#include <vcl.h>
#include <windows.h>
#pragma hdrstop
 
#define HOOKFUNCSDLL_API extern "C" __declspec(dllexport)
#pragma argsused
 
ULONG GetAddressAPI(char* nameDLL,char* nameAPI);
void InlineNtSetInformationThread(void);
void InlineNtQueryInformationProcess(void);
 
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
        InlineNtSetInformationThread();
        InlineNtQueryInformationProcess();
        return 1;
}
//---------------------------------------------------------------------------
 
void InlineNtSetInformationThread() //Funcion para evitar que nos desatachee del proceso usando esa funcion
{
        ULONG Dir;
        BYTE injertoZwSetInformationThread[] = {0x33,0xC0,0xC2,0x10,0x00};
        ULONG nWrite;
 
        MessageBox(NULL,"Entró para parchear NtSetInformationThread.","ATENCION",0);
 
        Dir = GetAddressAPI("ntdll.dll","NtSetInformationThread");
 
        if(Dir == NULL)
        {
                MessageBox(NULL,"Error al obtener la direccion de NtSetInformationThread.","ERROR",0);
        }else{
                WriteProcessMemory(GetCurrentProcess(),(LPVOID)Dir,&injertoZwSetInformationThread,sizeof(injertoZwSetInformationThread),&nWrite);
        }
}
//---------------------------------------------------------------------------
 
void InlineNtQueryInformationProcess(void)
{
        ULONG Dir;
        BYTE injertoZwQueryInformationProcess[] = {0xC7,0x01,0x00,0x00,0x00,0x00,0x33,0xC0,0xC2,0x14,0x00};
        ULONG nWrite;
 
        MessageBox(NULL,"Entró para parchear NtQueryInformationProcess.","ATENCION",0);
 
        Dir = GetAddressAPI("ntdll.dll","NtQueryInformationProcess");
 
        if(Dir == NULL)
        {
                MessageBox(NULL,"Error al obtener la direccion de NtQueryInformationProcess.","ERROR",0);
        }else{
                WriteProcessMemory(GetCurrentProcess(),(LPVOID)Dir,&injertoZwQueryInformationProcess,sizeof(injertoZwQueryInformationProcess),&nWrite);
        }
}
//---------------------------------------------------------------------------
 
ULONG GetAddressAPI(char* nameDLL,char* nameAPI)
{
        HMODULE hMod;
 
        hMod = LoadLibrary(nameDLL);
        return (ULONG)GetProcAddress(hMod,nameAPI);
}

Luego la funcion que hace la inyeccion de la dll es esta:

cpp

void THiloDebugger::InjectDll( HANDLE hProcess, AnsiString DLL )
{
        ULONG bytesWritten, TID;
        HANDLE pThreadStartRoutine,hThread,Parameters;
 
        //Creamos espacio en el proceso
        Parameters = VirtualAllocEx(hProcess,NULL,DLL.Length()+1,MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
        if(Parameters != NULL)
        {
                WriteProcessMemory(hProcess,Parameters,DLL.c_str(),DLL.Length()+1, &bytesWritten);
 
                if(bytesWritten == DLL.Length()+1)
                {
                        pThreadStartRoutine = GetProcAddress(GetModuleHandle("kernel32.dll"),"LoadLibraryA");
 
                        if(pThreadStartRoutine != NULL)
                        {
                                hThread = CreateRemoteThread(hProcess,NULL,0,(LPTHREAD_START_ROUTINE)pThreadStartRoutine,Parameters,0,&TID);
 
                                if(hThread == NULL)
                                {
                                        MessageBox(GetCurrentProcess(),"No se pudo crear el hilo.","Error",0);
                                }
                        }else{
                                MessageBox(GetCurrentProcess(),"No se pudo obtener la direccion base de LoadLibraryA.","Error",0);
                        }
                }else{
                        MessageBox(GetCurrentProcess(),"No se pudo parchear la API.","Error",0);
                }
        }else{
                MessageBox(GetCurrentProcess(),"No se pudo obtener memoria para inyectar la dll.","Error",0);
        }

Luego he creado un ejecutable el cual usa esos dos trucos antidebug y no se que pasa porque la funcion de inyeccion de la dll no me da errores pero las funciones de la dll nunca se ejecutan y de forma extraña me salto el truco anti debug de ZwSetInformationThread porque no me desatache y si no uso la inyeccion de la dll si me desatachea y tengo que cerrar el depurador a las bravas.
Esto que yo hago ademas tendria sus inconvenientes ya que estaria asi siempre y daría igual que parametros mandara como por ejemplo la NtQueryInformationProcess que si le pones como parametro 0 te llena una estructura PROCESS_BASIC_INFORMATION pero si le pones el parametro 7 te da el puerto libre para depuracion del proceso y lo ideal seria solo actuar cuando el parametro sea 7. Me interesaria el tema de crear un hook pero no tengo ni idea ni de como hacer una dll, ya lo veras en el codigo 
A ver si puedes ayudarme porque con el tutorial que has puesto no soy capaz. La idea es que esa api con el parametro 7 ejecute el codigo que yo tengo en el array que es un mov ptr dword[ecx],0; xor eax,eax; retn 14; pero si no es el parametro 7 pues que se ejecute con normalidad.
La de ZwSetInformationThread lo que interesa es que siempre salga sin hacer nada ya que esta api nos desatachea del proceso.

[escafandra]

¿Y se puede hacer que el Hook solo afecte al proceso y sus threads?

Un Hook sólo afecta al proceso que esté inyectado. Para realizar un Hook a la API precisamos inyectar código en el proceso o procesos anfitriones. Esa inyección puede ser directa o a través de una dll que es más sencillo. Inyectar una dll es obligar al proceso anfitrión a cargarla "por narices" de forma que se ejecutará el código del punto de entrada obligatoriamente. En el caso de que sólo queramos afectar a nuestro proceso, no tenemos más que cargar la dll o prescindir de ella colocando el código necesario para realizar el hook en nuestro proceso.

La teoría y código para realizar el hook está en este tutorial.


Saludos.

[aguml]

Amigo estoy mirando atentamente tu código y no veo donde tienes estas funciones implementadas:
function  _SizeOfCode(code: PBYTE): DWORD; cdecl; external;
function  _x_code_flags(code: PBYTE): DWORD; cdecl; external;

La primera supongo que es la que necesito para saber el tamaño del codigo original a copiar en el buffer.
La segunda no se que hace pero tampoco la tengo. ¿no podrias subirlas?
Con lo de cdecl; external supongo que es porque las obtienes desde una dll.
Seria mucho mas facil todo teniendo esas funciones.

Edito:
Estoy traduciendo tu codigo a C++Builder pero me encuentro con cosas que no se como pasarlas.
Esto no se que hace:

cpp

PBYTE(DWORD(ToAPI) + NBytes)^:= $E9 ; //jmp

Lo he dejado así:

cpp

(BYTE*)((DWORD)ToAPI + NBytes) = 0xE9;

y esto:

cpp

PDWORD(DWORD(ToAPI) + NBytes+1)^:= DWORD(API) - DWORD(ToAPI) - 5;

lo traduje como:

cpp

(DWORD*)((DWORD)ToAPI + NBytes+1) = (DWORD)API - (DWORD)ToAPI - 5;

No se si hacen lo mismo pero no compila con eso. ¿como se traduce eso?

Tambien traduje las funciones asi:

cpp

extern "C" cdecl DWORD _SizeOfCode(PBYTE code);
extern "C" cdecl DWORD _x_code_flags(PBYTE code);
 
//procedure InstallHook(HookAPI: Pointer; var ToAPI: Pointer; dllName, ApiName: PCHAR; Resume: BOOL);
void InstallHook(LPVOID HookAPI, LPVOID ToAPI, char *dllName, char *ApiName, bool Resume);
//procedure InstallHookFromAddr(HookAPI: Pointer; var ToAPI: Pointer; API: Pointer; Resume: BOOL);
void InstallHookFromAddr(LPVOID HookAPI, LPVOID ToAPI, LPVOID API, bool Resume);
//procedure SuspendHook(ToAPI: Pointer; dllName, ApiName: PCHAR);
void SuspendHook(LPVOID ToAPI, char *dllName, char *ApiName);
//procedure SuspendHookFromAddr(ToAPI, API: Pointer);
void SuspendHookFromAddr(LPVOID ToAPI, LPVOID API);
//procedure ResumeHook(HookFunc: Pointer; dllName, ApiName: PCHAR);
void ResumeHook(LPVOID HookFunc, char *dllName, char *ApiName);
//procedure ResumeHookFromAddr(HookFunc, API: Pointer);
void ResumeHookFromAddr(LPVOID HookFunc, LPVOID API);
//procedure UnInstallHook(var ToAPI: Pointer; dllName, ApiName: PCHAR);
void UnInstallHook(LPVOID ToAPI, char *dllName, char *ApiName);
//procedure UnInstallHookFromAddr(var ToAPI: Pointer; API: Pointer);
void UnInstallHookFromAddr(LPVOID ToAPI, LPVOID API);
//function  Transfer(Source, Dest: PBYTE): DWORD;
DWORD Transfer(LPVOID Source, LPVOID Dest);
 
//function GetOverloadBytes(pB: PBYTE): DWORD;
DWORD GetOverloadBytes(LPVOID pB);
//function ASMmemcpy(Dest, Source: PBYTE; NBytes: DWORD): DWORD;
DWORD ASMmemcpy(LPVOID Dest, LPVOID Source, DWORD NBytes);

Pero esto ni idea de como pasarlo:

cpp

//function __ltolower(C: integer): integer; cdecl; external 'msvcrt.dll' name '_tolower';
//function __ltoupper(C: integer): integer; cdecl; external 'msvcrt.dll' name '_toupper';
//function __ltowlower(C: integer): integer; cdecl; external 'msvcrt.dll' name 'towlower';
//function __ltowupper(C: integer): integer; cdecl; external 'msvcrt.dll' name 'towupper';
//function  _memcpy(s1, s2: Pointer; n: integer): pointer; cdecl; external 'msvcrt.dll' name 'memcpy';

De momento todo eso. 

[escafandra]

Esas dos funciones son las que usan el desensamblador de longitud que está compilado en el módulo objeto LDasm.obj.
SizeOfCode recibe como parámetro un puntero al opcode asm del que queremos conocer la longitud en Bytes y nos devuelve esa longitud.
x_code_flags también recibe como parámetro un puntero al opcode asm, pero en este caso nos informa de si estamos en una instrucción de salto relativo, en cuyo caso deberemos recalcular el salto al transferir esos opcodes a la función de vuelta a la API original.

El desensamblador de longitud sólo es necesario para aquellas API que no comienzan por la secuencia habitual de 5 bytes:

asm

8BFF    mov edi, edi55      push ebp8BEC    mov ebp, esp

El desensamblador está escrito en C y no lo escribí yo, aquí tienes el enlace. Aunque por el momento creo que no te aportará más luz al tema de lo que te acabo de explicar de dicho desensamblador.


Saludos.