Código fuente del programa Hook
1. Instale un gancho de mouse y obtenga mensajes del mouse a través de la función de gancho.
Función API utilizada: setwindowshookex
2. Obtenga la posición actual del mouse, envíe un mensaje de redibujo a la ventana debajo del mouse y permita que llame a la función del sistema para volver a dibujar la ventana. ventana.
Funciones API utilizadas: windowfrompoint, screentoclient, invalidaterect.
3. Interceptar la llamada a la función del sistema y obtener los parámetros, que es la palabra que queremos obtener.
Para la mayoría de las aplicaciones de Windows, si desea recuperar palabras, debe interceptar la función "textouta" en "gdi32.dll".
Escribamos una función Mytextouta similar a la función textouta, como por ejemplo:
bool winapi mytextouta(hdc hdc, int nxstart, int nystart, lpcstr lpszstring, int cbstring)
{
//Aquí se realiza el procesamiento de salida de lpszstring.
//Luego llama a la función textouta genuina.
}
Coloque esta función en la biblioteca de vínculos dinámicos con el gancho instalado y luego llame a la función hookimportfunction que le dimos en último lugar para interceptar la llamada del proceso a la función textouta y saltar a Nuestro Función mytextouta para capturar la cadena de salida. Uso de la función hookimport:
hookfuncdesc hd
proc porigfuns
hd.szfunc = " textouta
HD . pproc = (proc)mytextouta ;
hookinportfunction(afxgetinstancehandle(), "gdi32.dll", amp HD, porigfuns);
El código fuente de hookimportfunction se proporciona a continuación. Creo que no se permitirán comentarios detallados. Estás abajo. Es difícil entender cómo se implementa la interceptación. Bien, vamos:
////////////////////begin/begin/ comenzar. /begin/begin/begin/begin/begin/begin/begin/begin/begin/begin/begin
# include ltcrtdbg.h gt
//Esto define una macro generada para punteros
#define makeptr(cast,ptr,addvalue)(cast)((dword)(ptr)(dword)(addvalue))
//Definimos la estructura hookfuncdesc. Úselo como un parámetro pasado a la función hookimportfunction
typedef struct tag_hookfuncdesc
{
lpcstr szfunc//El nombre de la función a enganchar /p. >
proc pproc//El programa que se ejecutará rápidamente.
} hookfuncdesc, * lphookfuncdesc
//Esta función monitorea si el sistema actual es windownt.
bool nots();
//Esta función obtiene el módulo h: el descriptor de importación del módulo dll donde se encuentra la función que necesitamos interceptar.
pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr sziportmodule);
//Nuestra función principal
bool hook import function(hmodule hmodule, lpcstr szimportmodule,
lphookfuncdesc pahookfunc, proc* paorigfuncs)
{
/////////////////abajo Parámetros de detección de código /// ///////////////////////////////////////////////// .
_assert(szimportmodule);
_assert(!isbadreadptr(pahookfunc, sizeof(hook func desc)));
#ifdef _debug
if (paorigfuncs) _assert(!isbadwriteptr(paorigfuncs,sizeof(proc)));
_assert(pahook func . SZ func);
_assert(*pahookfunc. szfunc! = \0 );
_assert(!isbadcodeptr(pahook func . pproc));
#endif
if((szimportmodule == null) | | (isbadreadptr(pahook func, sizeof(hookfuncdesc))))
{
_ afirmar(falso);
setlasterrorex(error _ parámetro no válido, SLE_error );
Devuelve falso
}
//////////////////// //// /////////////////////////////////////////////////// ////////
//Supervise si el módulo actual tiene un espacio de memoria virtual de más de 2 GB.
//Esta parte de la memoria de direcciones pertenece al proceso win32 * * *.
if(!not() amp amp((dword)hmodule gt; = 0x80000000))
{
_ afirmar(false);
setlasterrorex(error_invalid_handle, SLE_error);
Devuelve falso
}
//Borrar
if(paorigfuncs)memset (paorigfuncs, null, sizeof(proc));
//Llame a la función getnamedimportdescriptor() para obtener el módulo h; es decir, necesitamos
//Importar el descriptor del módulo dll donde se encuentra la función interceptada.
pimage_import_descriptor pimportdesc = getnamedimportdescriptor(hm odule,sziportmodule);
if (pimportdesc == null)
Devuelve false // si está vacío, el módulo no ha sido introducido por el proceso actual.
//Obtenga la información del procesador original del módulo dll, porque la información original en pimportdesc->matriz firstthunk ha sido
//Cuando la aplicación introduce el dll, es Se sobrescribe toda la información de importación, por lo que necesitamos obtener pimportdesc->originalfirstthunk
//El puntero para acceder a la información, como el nombre de la función importada.
pimage_thunk_data porigthunk = make ptr(pimage_thunk_data,hmodule,
pimportdesc-gt;originalfirsthunk);
//Desde pimportdesc -> Firstthunk obtiene un puntero al matriz image_thunk_data porque la matriz ya estaba completa cuando se introdujo la dll.
// Toda la información entrante, por lo que la interceptación real se realiza aquí.
pimage_thunk_data prealthunk = make ptr(pimage_thunk_data, hmodule, pimportdesc-gt; first thunk);
//Enumere la matriz image_thunk_data y encuentre lo que necesitamos. Función Intercept. ¡Esta es la parte más crucial!
while(porigthunk- gt; u1.function)
{
// Solo busque funciones introducidas por nombres de funciones en lugar de números de secuencia.
if (image_ordinal_flag!=(porigthunk- gt; u1. Indicador de número de serie de la imagen))
{
//Obtener el nombre de la función importada .
pimage_import_by_name pby name = make ptr(pimage_import_by_name, hmodule,
porigthunk-gt; u 1 . dirección de datos);
//Si el nombre de la función; comienza con nulo, salta y continúa con la siguiente función.
if(\ 0 == pbyname- gt; name[0])
Continuar
// bdohook se utiliza para comprobar si la interceptación se realizó correctamente. .
bool bdohook = false
//Comprueba si la función actual es la función que necesitamos interceptar.
if((pahook func . SZ func[0]= = pbyname- gt;name[0]) amp; amp
(strcmpi(pahookfunc.szfunc, (char *) pbyname- gt;name) == 0))
{
//¡Encontrado!
if (pahookfunc.pproc)
bdohook = true
}
if (libro bdo)
{
//Hemos encontrado la función a interceptar, comencemos.
//Lo primero que debemos hacer es cambiar el estado de protección de la memoria de esta memoria virtual para que podamos acceder a ella libremente.
memory_basic_information mbi_thunk;
Consulta virtual (prealthunk amp;mbi_thunk, sizeof(memory_basic_information));
_assert (protección virtual (mbi_thunk.base dirección, mbi_thunk. regionsize,
page_read write & mbi_thunk.protect));
//Guardar lo que queremos interceptar La dirección de salto correcta de la función.
if (paorigfuncs)
paorigfuncs = (proc)prealthunk- gt; u 1
//Dirección de salto de la función en la matriz image_thunk_data. ¡Reescriba en nuestra propia dirección de función!
//En el futuro, todas las llamadas a esta función del sistema por parte del proceso se convertirán en llamadas a funciones escritas por ellos mismos.
prealthunk- gt; u 1 . función = (palabra PD)pahook pproc .
//¡Operación completada! Cambie este bloque de memoria virtual a su estado protegido original.
dword dwoldprotect
_asser(protección virtual(mbi_thunk. dirección base, mbi_thunk.regionsize,
mbi_thunk.protect.dwold protect));
setlasterror(error_success);
Devuelve verdadero
}
}
//Accede a la matriz image_thunk_data al siguiente elemento en .
porigthunk;
prealthunk
}
devuelve verdadero
}
Implementación de la función getnamedimportdescriptor
pimage _ import _ descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule)
{
//Parámetros de detección
_ afirmar(szimportmodule);
_ afirmar(hm odule);
if((szimportmodule == null)| |(hm odule == null))
{
_ afirmar(falso);
setlasterrorex(error_invalid_parameter, SLE_error);
Devolver nulo
}
//Obtener el encabezado del archivo dos
pimage _ dos _ header PDO header =(pimage _ dos _ header)hm odule;
// Compruebe si el encabezado del archivo mz es
if(isbadreadptr(encabezado PDO, tamaño de(image_dos_header)) ||
(encabezado PDO- gt; e_magic!= image_dos_signature))
{
_ afirmar(falso);
setlasterrorex(error_invalid_parameter, SLE_error);
Devolver nulo
}
//Obtener encabezado de archivo pe
pimage _ nt _ headers pntheader = make ptr(pimage _ nt _ headers, encabezado PDO, encabezado PDO- gt; e _ LFA new);
//Detecta si el archivo de imagen pe es
if (isbadreadptr(pntheader, sizeof(image_nt_headers)) ||
(pntheader-gt; firma! =image_nt_signature))
{
_assert(false);
setlasterrorex(error_invalid_parameter, SLE_error);
Devolver nulo
}
//Comprueba la parte de importación (es decir, la parte de datos).
if (pntheader- gt; encabezado opcional. directorio de datos [importación de entrada del directorio de imágenes].
Dirección virtual == 0)
Devolver nulo
//Obtener el puntero a la parte de importación (es decir, parte de datos)
pimage _ import _ descriptor pimportdesc = make ptr(pimage_import_descriptor, pdosheader,
pntheader-gt; encabezado opcional. directorio de datos [importación de entrada de directorio de imágenes]. dirección virtual
//lista exhaustiva matriz pimage_import_descriptor); Encuentre el módulo donde se encuentra la función que necesitamos interceptar.
while(pimportdesc- gt; nombre)
{
pstr szcurrmod = makeptr(pstr, pdosheader, pimportdesc- gt; nombre);
if (stricmp(szcurrmod, szimportmodule) == 0)
Break; // ¡Lo encontré! Ciclo de interrupción
//Siguiente elemento
pimportdesc;
}
//Si no se encuentra, significa el módulo que estamos buscando ¡Porque no ha sido introducido por el proceso actual!
if(pimportdesc- gt; name == null)
Devuelve null
//Devuelve el descriptor del módulo encontrado por la función.
Devolver pimportdesc
}
//Implementación de la función ISNT()
Booleano no es ()
{
osversioninfo stosvi
memset( amp; stosvi, null, sizeof(OS version info));
sto dwosversioninfosize = sizeof(osversioninfo)
bool bret = getversionex(amp; stos VI);
_asser(true == bret);
if (false == bret) devuelve false ;
return(ver _ platform _ win32 _ nt == stos VI . dwplatformid
}