Enganche

El enganche de funciones se puede lograr modificando el código fuente del ejecutable o la biblioteca antes de que se ejecute la aplicación, mediante técnicas de ingeniería inversa . Esto se suele utilizar para interceptar llamadas a funciones con el fin de monitorizarlas o reemplazarlas por completo.

Por ejemplo, mediante un desensamblador , se puede encontrar el punto de entrada de una función dentro de un módulo . Este punto se puede modificar para cargar dinámicamente otro módulo de biblioteca y ejecutar los métodos deseados dentro de dicha biblioteca. Otra forma de lograr la interceptación, si procede, es modificando la tabla de importación de un ejecutable. Esta tabla se puede modificar para cargar módulos de biblioteca adicionales, así como para cambiar el código externo que se invoca cuando la aplicación llama a una función.

Un método alternativo para interceptar funciones consiste en hacerlo mediante una biblioteca envoltorio . Un envoltorio es una versión de una biblioteca que una aplicación carga, con la misma funcionalidad que la biblioteca original a la que reemplazará. Es decir, todas las funciones accesibles son prácticamente idénticas entre la original y la de reemplazo. Esta biblioteca envoltorio puede diseñarse para llamar a cualquier función de la biblioteca original o reemplazarla con una lógica completamente nueva.

El enlazador GNU admite la --wrap=fooopción CLI. Cuando se utiliza, el enlazador reemplaza todas las llamadas a foocon llamadas a __wrap_foo. La definición original de fooahora se puede referenciar con el símbolo __real_foo. ^{[ 1 ]} Dado que este método no utiliza el enlazador dinámico , este método solo se puede utilizar cuando el código fuente de un programa está disponible y el paso de enlace de la compilación se puede modificar.

Los sistemas operativos y el software pueden proporcionar los medios para insertar fácilmente ganchos de eventos en tiempo de ejecución . Esto es posible siempre que el proceso que inserta el gancho tenga los permisos suficientes para hacerlo. Microsoft Windows , por ejemplo, permite a los usuarios insertar ganchos que se pueden usar para procesar o modificar eventos del sistema y de la aplicación para diálogos , barras de desplazamiento y menús , así como otros elementos. También permite que un gancho inserte, elimine, procese o modifique eventos de teclado y ratón . Linux proporciona otro ejemplo donde los ganchos se pueden usar de manera similar para procesar eventos de red dentro del kernel a través de NetFilter .

Cuando no se proporciona dicha funcionalidad, una forma especial de interceptación emplea la intercepción de las llamadas a funciones de la biblioteca realizadas por un proceso. La interceptación de funciones se implementa modificando las primeras instrucciones de la función objetivo para que salte a un código inyectado. Alternativamente, en sistemas que utilizan el concepto de biblioteca compartida , se puede modificar la tabla de vectores de interrupción o la tabla de descriptores de importación en memoria. En esencia, estas tácticas emplean las mismas ideas que las de la modificación del código fuente, pero alterando las instrucciones y estructuras ubicadas en la memoria de un proceso una vez que este ya se está ejecutando.

Cuando una clase define o hereda una función (o método) virtual , los compiladores añaden una variable miembro oculta a la clase que apunta a una tabla de métodos virtuales (VMT o Vtable). La mayoría de los compiladores colocan el puntero VMT oculto en los primeros 4 bytes de cada instancia de la clase. Una VMT es básicamente una matriz de punteros a todas las funciones virtuales que las instancias de la clase pueden llamar. En tiempo de ejecución, estos punteros se configuran para que apunten a las funciones correctas, ya que en tiempo de compilación aún no se sabe si se debe llamar a la función base o a una versión sobrescrita de la función de una clase derivada (lo que permite el polimorfismo ). Por lo tanto, las funciones virtuales se pueden interceptar reemplazando los punteros a ellas dentro de cualquier VMT en la que aparezcan. El siguiente código muestra un ejemplo de una interceptación VMT típica en Microsoft Windows, escrita en C++. ^{[ 2 ]}

#include <iostream> #include "windows.h" using namespace std ; class VirtualClass { public : int number ; virtual void VirtualFn1 () //Esta es la función virtual que se enganchará. { cout << "VirtualFn1 llamada " << number ++ << " \n\n " ; } }; using VirtualFn1_t = void ( __thiscall * )( void * thisptr ); VirtualFn1_t orig_VirtualFn1 ;void __fastcall hkVirtualFn1 ( void * thisptr , int edx ) //Esta es nuestra función de gancho que haremos que el programa llame en lugar de la función VirtualFn1 original después de que se haya realizado el gancho. { cout << "Función de gancho llamada" << " \n " ; orig_VirtualFn1 ( thisptr ); //Llamar a la función original. } int main () { VirtualClass * myClass = new VirtualClass (); //Crear un puntero a una instancia asignada dinámicamente de VirtualClass. void ** vTablePtr = * reinterpret_cast < void ***> ( myClass ); //Encontrar la dirección que apunta a la base de VMT de VirtualClass (que luego apunta a VirtualFn1) y almacenarla en vTablePtr. DWORD oldProtection ; VirtualProtect ( vTablePtr , 4 , PAGE_EXECUTE_READWRITE , & oldProtection ); //Elimina la protección de página al inicio de la VMT para que podamos sobrescribir su primer puntero. orig_VirtualFn1 = reinterpret_cast < VirtualFn1_t > ( * vTablePtr ); //Almacena el puntero a VirtualFn1 de la VMT en una variable global para que se pueda acceder a él más tarde después de que su entrada en la VMT haya sido //sobrescrita con nuestra función de gancho. * vTablePtr = & hkVirtualFn1 ; //Sobrescribe el puntero a VirtualFn1 dentro de la tabla virtual con un puntero a nuestra función de gancho (hkVirtualFn1). VirtualProtect ( vTablePtr , 4 , oldProtection , 0 ); //Restaura la protección de página anterior. myClass -> VirtualFn1 (); //Llama a la función virtual desde nuestra instancia de clase. Debido a que ahora está enganchada, esto realmente llamará a nuestra función de gancho (hkVirtualFn1). myClass -> VirtualFn1 (); myClass -> VirtualFn1 (); delete myClass ; devolver 0 ; }

Todas las funciones virtuales deben ser funciones miembro de la clase, y todas las funciones miembro de la clase (no estáticas) se llaman con la convención de llamada __thiscall (a menos que la función miembro tome un número variable de argumentos, en cuyo caso se llama con __cdecl). La convención de llamada __thiscall pasa un puntero a la instancia de la clase que realiza la llamada (comúnmente denominado puntero "this") a través del registro ECX (en la arquitectura x86). Por lo tanto, para que una función de gancho pueda interceptar correctamente el puntero "this" que se pasa y tomarlo como argumento, debe buscar en el registro ECX. En el ejemplo anterior, esto se hace configurando la función de gancho (hkVirtualFn1) para que use la convención de llamada __fastcall, lo que hace que la función de gancho busque en el registro ECX uno de sus argumentos.

Cabe destacar que, en el ejemplo anterior, la función de enlace (hkVirtualFn1) no es una función miembro, por lo que no puede utilizar la convención de llamada __thiscall. En su lugar, debe utilizarse __fastcall, ya que es la única otra convención de llamada que busca un argumento en el registro ECX.

El siguiente ejemplo se conectará a los eventos del teclado en Microsoft Windows utilizando Microsoft .NET Framework .

usando System.Runtime.InteropServices ;espacio de nombres Ganchos ;public class KeyHook { /* Variables miembro */ protected static int Hook ; protected static LowLevelKeyboardDelegate Delegate ; protected static readonly object Lock = new object (); protected static bool IsRegistered = false ;/* Importaciones de DLL */ [DllImport("user32")] private static extern int SetWindowsHookEx ( int idHook , LowLevelKeyboardDelegate lpfn , int hmod , int dwThreadId );[DllImport("user32")] private static extern int CallNextHookEx ( int hHook , int nCode , int wParam , KBDLLHOOKSTRUCT lParam );[DllImport("user32")] private static extern int UnhookWindowsHookEx ( int hHook );/* Tipos y constantes */ protected delegate int LowLevelKeyboardDelegate ( int nCode , int wParam , ref KBDLLHOOKSTRUCT lParam ); private const int HC_ACTION = 0 ; private const int WM_KEYDOWN = 0x0100 ; private const int WM_KEYUP = 0x0101 ; private const int WH_KEYBOARD_LL = 13 ;[StructLayout(LayoutKind.Sequential)] public struct KBDLLHOOKSTRUCT { public int vkCode ; public int scanCode ; public int flags ; public int time ; public int dwExtraInfo ; }/* Métodos */ static private int LowLevelKeyboardHandler ( int nCode , int wParam , ref KBDLLHOOKSTRUCT lParam ) { if ( nCode == HC_ACTION ) { if ( wParam == WM_KEYDOWN ) System . Console . Out . WriteLine ( "Tecla pulsada: " + lParam . vkCode ); else if ( wParam == WM_KEYUP ) System . Console . Out . WriteLine ( "Tecla liberada: " + lParam . vkCode ); } return CallNextHookEx ( Hook , nCode , wParam , lParam ); }public static bool RegisterHook () { lock ( Lock ) { if ( IsRegistered ) return true ; Delegate = LowLevelKeyboardHandler ; Hook = SetWindowsHookEx ( WH_KEYBOARD_LL , Delegate , Marshal . GetHINSTANCE ( System . Reflection . Assembly . GetExecutingAssembly (). GetModules ()[ 0 ] ). ToInt32 (), 0 );if ( Hook != 0 ) return IsRegistered = true ; Delegate = null ; return false ; } }public static bool UnregisterHook () { lock ( Lock ) { return IsRegistered = ( UnhookWindowsHookEx ( Hook ) != 0 ); } } }

El siguiente código fuente es un ejemplo de un método de enganche de API/función que se ejecuta sobrescribiendo los primeros seis bytes de una función de destino con una instrucción JMP a una nueva función. El código se compila en un archivo DLL y luego se carga en el proceso de destino mediante cualquier método de inyección de DLL . Utilizando una copia de seguridad de la función original, se pueden restaurar los primeros seis bytes para que la llamada no se interrumpa. En este ejemplo, se intercepta la función MessageBoxW de la API de Win32 . ^{[ 3 ]}

/* Esta idea se basa en el enfoque de chrom-lib, distribuido bajo la licencia GNU LGPL. Fuente de chrom-lib: https://github.com/linuxexp/chrom-lib Copyright (C) 2011 Raja Jamwal */ #include <windows.h> #define SIZE 6typedef int ( WINAPI * pMessageBoxW )( HWND , LPCWSTR , LPCWSTR , UINT ); // Prototipo de cuadro de mensaje int WINAPI MyMessageBoxW ( HWND , LPCWSTR , LPCWSTR , UINT ); // Nuestro desvíovoid BeginRedirect ( LPVOID ); pMessageBoxW pOrigMBAddress = NULL ; // dirección del BYTE original oldBytes [ SIZE ] = { 0 }; // copia de seguridad BYTE JMP [ SIZE ] = { 0 }; // instrucción JMP de 6 bytes DWORD oldProtect , myProtect = PAGE_EXECUTE_READWRITE ;INT APIENTRY DllMain ( HMODULE hDLL , DWORD Reason , LPVOID Reserved ) { switch ( Reason ) { case DLL_PROCESS_ATTACH : // si está adjunto pOrigMBAddress = ( pMessageBoxW ) GetProcAddress ( GetModuleHandleA ( "user32.dll" ), // obtener la dirección del "MessageBoxW" original ); if ( pOrigMBAddress != NULL ) BeginRedirect ( MyMessageBoxW ); // comenzar a desviar break ;case DLL_PROCESS_DETACH : VirtualProtect (( LPVOID ) pOrigMBAddress , SIZE , myProtect , & oldProtect ); // asignar protección de lectura y escritura memcpy ( pOrigMBAddress , oldBytes , SIZE ); // restaurar copia de seguridad VirtualProtect (( LPVOID ) pOrigMBAddress , SIZE , oldProtect , & myProtect ); // restablecer proteccióncase DLL_THREAD_ATTACH : case DLL_THREAD_DETACH : break ; } return TRUE ; }void BeginRedirect ( LPVOID newFunction ) { BYTE tempJMP [ SIZE ] = { 0xE9 , 0x90 , 0x90 , 0x90 , 0x90 , 0xC3 }; // 0xE9 = JMP 0x90 = NOP 0xC3 = RET memcpy ( JMP , tempJMP , SIZE ); // almacenar la instrucción jmp en JMP DWORD JMPSize = (( DWORD ) newFunction - ( DWORD ) pOrigMBAddress - 5 ); // calcular la distancia de salto VirtualProtect (( LPVOID ) pOrigMBAddress , SIZE , // asignar protección de lectura y escritura PAGE_EXECUTE_READWRITE , & oldProtect ); memcpy ( oldBytes , pOrigMBAddress , SIZE ); // hacer copia de seguridad memcpy ( & JMP [ 1 ], & JMPSize , 4 ); // rellenar las instrucciones nop con la distancia de salto (JMP,distance(4bytes),RET) memcpy ( pOrigMBAddress , JMP , SIZE ); // establecer la instrucción de salto al principio de la función original VirtualProtect (( LPVOID ) pOrigMBAddress , SIZE , oldProtect , & myProtect ); // restablecer la protección }int WINAPI MyMessageBoxW ( HWND hWnd , LPCWSTR lpText , LPCWSTR lpCaption , UINT uiType ) { VirtualProtect (( LPVOID ) pOrigMBAddress , SIZE , myProtect , & oldProtect ); // asignar protección de lectura y escritura memcpy ( pOrigMBAddress , oldBytes , SIZE ); // restaurar copia de seguridad int retValue = MessageBoxW ( hWnd , lpText , lpCaption , uiType ); // obtener el valor de retorno de la función original memcpy ( pOrigMBAddress , JMP , SIZE ); // establecer la instrucción de salto nuevamente VirtualProtect (( LPVOID ) pOrigMBAddress , SIZE , oldProtect , & myProtect ); // restablecer la protección return retValue ; // devolver el valor de retorno original }

Este ejemplo muestra cómo usar la técnica de hooking para alterar el tráfico de red en el kernel de Linux usando Netfilter .

#include <linux/module.h> #include <linux/kernel.h> #include <linux/skbuff.h>#include <linux/ip.h> #include <linux/tcp.h> #include <linux/in.h> #include <linux/netfilter.h> #include <linux/netfilter_ipv4.h>/* Puerto en el que queremos descartar paquetes */ static const uint16_t puerto = 25 ;/* Esta es la función de gancho en sí */ static unsigned int hook_func ( unsigned int hooknum , struct sk_buff ** pskb , const struct net_device * in , const struct net_device * out , int ( * okfn )( struct sk_buff * )) { struct iphdr * iph = ip_hdr ( * pskb ); struct tcphdr * tcph , tcpbuf ;if ( iph -> protocol != IPPROTO_TCP ) return NF_ACCEPT ;tcph = skb_header_pointer ( * pskb , ip_hdrlen ( * pskb ), sizeof ( * tcph ), & tcpbuf ); if ( tcph == NULL ) return NF_ACCEPT ;return ( tcph -> dest == port ) ? NF_DROP : NF_ACCEPT ; }/* Se utiliza para registrar nuestra función de gancho */ static struct nf_hook_ops nfho = { . hook = hook_func , . hooknum = NF_IP_PRE_ROUTING , . pf = NFPROTO_IPV4 , . priority = NF_IP_PRI_FIRST , };static __init int my_init ( void ) { return nf_register_hook ( & nfho ); }static __exit void my_exit ( void ) { nf_unregister_hook ( & nfho ); }module_init ( my_init ); module_exit ( my_exit );

El siguiente código muestra cómo interceptar funciones importadas de otro módulo. Esto permite interceptar funciones en un proceso distinto al que las llama. Para ello, el código debe compilarse en un archivo DLL y luego cargarse en el proceso de destino mediante cualquier método de inyección de DLL . La ventaja de este método es que es menos detectable por el software antivirus y/o antitrampas ; se puede crear un gancho externo que no utilice llamadas maliciosas. El encabezado del ejecutable portátil contiene la tabla de direcciones de importación (IAT), que se puede manipular como se muestra en el código fuente a continuación. El código fuente se ejecuta en Microsoft Windows.

#include <windows.h>typedef int ( __stdcall * pMessageBoxA ) ( HWND hWnd , LPCSTR lpText , LPCSTR lpCaption , UINT uType ); //Este es el 'tipo' de la llamada a MessageBoxA. pMessageBoxA RealMessageBoxA ; //Esto almacenará un puntero a la función original.void DetourIATptr ( const char * function , void * newfunction , HMODULE module );int __stdcall NewMessageBoxA ( HWND hWnd , LPCSTR lpText , LPCSTR lpCaption , UINT uType ) { //Nuestra función falsa printf ( "La cadena enviada a MessageBoxA fue: %s \n " , lpText ); return RealMessageBoxA ( hWnd , lpText , lpCaption , uType ); //Llamar a la función real }int main ( int argc , CHAR * argv []) { DetourIATptr ( "MessageBoxA" , ( void * ) NewMessageBoxA , 0 ); //Enganchar la función MessageBoxA ( NULL , "Solo un cuadro de mensaje" , "Solo un cuadro de mensaje" , 0 ); //Llamar a la función: esto invocará nuestro gancho falso. return 0 ; }void ** IATfind ( const char * function , HMODULE module ) { //Busca la entrada IAT (Tabla de direcciones de importación) específica para la función dada. int ip = 0 ; if ( module == 0 ) module = GetModuleHandle ( 0 ); PIMAGE_DOS_HEADER pImgDosHeaders = ( PIMAGE_DOS_HEADER ) module ; PIMAGE_NT_HEADERS pImgNTHeaders = ( PIMAGE_NT_HEADERS )(( LPBYTE ) pImgDosHeaders + pImgDosHeaders -> e_lfanew ); PIMAGE_IMPORT_DESCRIPTOR pImgImportDesc = ( PIMAGE_IMPORT_DESCRIPTOR )(( LPBYTE ) pImgDosHeaders + pImgNTHeaders -> OptionalHeader . DataDirectory [ IMAGE_DIRECTORY_ENTRY_IMPORT ]. VirtualAddress );if ( pImgDosHeaders -> e_magic != IMAGE_DOS_SIGNATURE ) printf ( "Error de libPE: e_magic no es una firma DOS válida \n " );for ( IMAGE_IMPORT_DESCRIPTOR * iid = pImgImportDesc ; iid -> Name != NULL ; iid ++ ) { for ( int funcIdx = 0 ; * ( funcIdx + ( LPVOID * )( iid -> FirstThunk + ( SIZE_T ) module )) != NULL ; funcIdx ++ ) { char * modFuncName = ( char * )( * ( funcIdx + ( SIZE_T * )( iid -> OriginalFirstThunk + ( SIZE_T ) module )) + ( SIZE_T ) module + 2 ); const uintptr_t nModFuncName = ( uintptr_t ) modFuncName ; bool isString = ! ( nModFuncName & ( sizeof ( nModFuncName ) == 4 ? 0x80000000 : 0x8000000000000000 )); if ( isString ) { if ( ! _stricmp ( function , modFuncName )) return funcIdx + ( LPVOID * )( iid -> FirstThunk + ( SIZE_T ) module ); } } } return 0 ; }void DetourIATptr ( const char * function , void * newfunction , HMODULE module ) { void ** funcptr = IATfind ( function , module ); if ( * funcptr == newfunction ) return ;DWORD oldrights , newrights = PAGE_READWRITE ; //Actualizar la protección a READWRITE VirtualProtect ( funcptr , sizeof ( LPVOID ), newrights , & oldrights );RealMessageBoxA = ( pMessageBoxA ) * funcptr ; //Algunos compiladores requieren la conversión (como "MinGW"), aunque no estoy seguro de MSVC * funcptr = newfunction ;//Restaurar las antiguas banderas de protección de memoria. VirtualProtect ( funcptr , sizeof ( LPVOID ), oldrights , & newrights ); }

• Información sobre la función de importación de tablas de direcciones.
• Información de Microsoft sobre el hooking
• Información y diversas técnicas relacionadas con el hooking en x86.
• APISpy32 es una aplicación que se utiliza para interceptar la API de Win32.
• Detours es una biblioteca de enganche de funciones de propósito general creada por Microsoft Research que funciona en C / C++.
• Winspy: Tres maneras de inyectar código en otro proceso.
• HookTool SDK (ACF SDK) ofrece una visión general completa sobre la interceptación de API y la inyección de código . También existe un producto comercial disponible.
• madCodeHook es una biblioteca comercial para la interceptación de API y la inyección de DLL en arquitecturas x86 y x64 para C++ y Delphi.
• EasyHook es un motor de enganche de código abierto que admite arquitecturas x86 y x64 en Windows, tanto en el espacio de usuario como en el núcleo del sistema operativo.
• SpyStudio Application Tracer SpyStudio es un rastreador de aplicaciones que intercepta las llamadas y muestra los resultados de forma estructurada.
• rohitab.com API Monitor es una aplicación gratuita que puede interceptar y mostrar más de 10 000 API de Windows e interfaces COM en aplicaciones y servicios de 32 y 64 bits.
• Deviare API Hook Deviare es un marco de trabajo gratuito para la creación de ganchos entre procesos que se puede utilizar para interceptar las llamadas a la API de otros procesos y mostrar información completa sobre los parámetros o crear monitores de API.
• WinAPIOverride es un software gratuito para uso no comercial. Permite interceptar API de Win32, COM, OLE, ActiveX y .NET en procesos de 32 y 64 bits. Incluye herramientas de análisis y monitorización.
• urmem es una biblioteca multiplataforma de C++11 (x86) para trabajar con memoria (ganchos, parches, envoltorio de punteros, escáner de firmas, etc.).

• Un proyecto de investigación estudiantil que utiliza la técnica del hooking.
• Funcionalidad que permite a un programa informático observar y controlar la ejecución de otro proceso.
• Uso de LD_PRELOAD para interceptar llamadas a bibliotecas compartidas.

• Los hooks de Emacs son un mecanismo importante para personalizar Emacs. Un hook es una variable de Lisp que contiene una lista de funciones que se ejecutarán en una ocasión específica. (Esto se conoce como ejecutar el hook).

• Cydia Substrate es un framework para dispositivos iOS con jailbreak que permite a los desarrolladores integrarse con cualquier otro framework o aplicación.
• Harpoon es una biblioteca de OS X para la interceptación de funciones en tiempo de ejecución.

• Enganches de API x86 desmitificados: Artículo sobre varios métodos de enganche de API para la arquitectura x86.