Se necesitan con urgencia ejemplos de API HOOK
#include "APIHook.h"
CAPIHook externo g_OpenProcess;
//Función OpenProcess personalizada
#pragma data_seg("YCIShared")
HHOOK g_hHook = NULL;
DWORD dwCurrentProcessId=0;
#pragma data_seg()
HANDLE WINAPI Hook_ OpenProcess(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId)
{
typedef HANDLE (WINAPI *PFNTERMINATEPROCESS)(DWORD, BOOL, DWORD);
p>if(dwProcessId != dwCurrentProcessId)
{
return ((PFNTERMINATEPROCESS)(PROC)g_OpenProcess)(dwDesiredAccess, bInheritHandle, dwProcessId);
}
return 0;
}
//Función de gancho OpenProcess
CAPIHook g_OpenProcess("kernel32.dll", " OpenProcess",
(PROC)Hook_ OpenProcess);
////////////////////////// // ///////////////////////////////////////////////// ////
Estático HMODULE ModuleFromAddress(PVOID pv)
{
MEMORY_BASIC_INFORMATION mbi
if(:: VirtualQuery(pv; , amp; mbi, tamaño de (mbi)) !p>
{
return (HMODULE)mbi.AllocationBase
}
else
{
return NULL
}
}
estático LRESULT WINAPI GetMsgProc(int código, WPARAM wParam, LPARAM lParam)
{
retorno:: CallNextHookEx(g_hHook, código, wParam, lParam
}
<); p>BOOL WINAPI SetSysHook (BOOL bInstall, DWORD dwThreadId){
BOOL bOk;
dwCurrentProcessId=dwThreadId;
if(
bInstall)
{
g_hHHook = :: SetWindowsHookEx(WH_GETMESSAGE, GetMsgProc,
ModuleFromAddress(GetMsgProc),
bOk); = (g_ hHook != NULL);
}
else
{
bOk = ::UnhookWindowsHookEx(g_hHook); /p>
g_hHook = NULL;
}
devolver libro
}<
API a través de HOOK OpenProcess() 2007-07-04 14:41 En el sistema operativo WINDOWS, cuando no podemos finalizar o no sabemos cómo finalizar el programa, o somos demasiado vagos para encontrar el botón "Salir", generalmente presionamos "CTRLCTRL ALT DEL" para traer Abra el administrador de tareas. Busque el programa que desea finalizar y haga clic en "Finalizar tarea". Jaja, es un poco grosero, pero funciona en la mayoría de los casos, ¿verdad?
Imagínese si existiera un software que impusiera ciertas restricciones a las actividades laborales que los usuarios pueden realizar en la computadora, pero no les permitiera eliminar fácilmente las restricciones "finalizando tareas". Sólo hay tres formas: 1. Bloquear la combinación de teclas de acceso rápido "CTRL ALT DEL" 2. Hacer que el programa no aparezca en la lista del administrador de tareas; 3. Hacer que el administrador de tareas no pueda finalizar la tarea; Para el primer método, esto es demasiado cruel y las personas que están acostumbradas al método de "finalizar tarea" se sentirán muy incómodas. Para el segundo método, se puede implementar fácilmente en WINDOWS 9X registrando un proceso de servicio; ¡No existe tal método para el sistema operativo de arquitectura WINDOWS NT! Es difícil ocultar el proceso. Aunque aún se puede ocultar, el mecanismo de implementación es más complicado. En cuanto al tercer método, es relativamente simple de implementar. Este es mi trabajo: el filtro de URL IPGate utiliza este método para evitar la eliminación. A continuación me gustaría presentarles este método.
"Finalizar tarea" del Administrador de tareas en realidad finaliza el proceso a la fuerza. Utiliza una función API de Win32 llamada TerminateProcess() como aplicación asesina. Echemos un vistazo a su definición:
BOOL. TerminateProcess(
HANDLE hProcess; // Identificador del proceso a terminar
UINT uExitCode; // Especifica el código de salida del proceso
); /p>
Cuando vea esto, no necesita mirar hacia abajo para saber qué hacer a continuación: conecte la función TerminateProcess() y cada vez que llame a TerminateProcess(), debe determinar si el proceso que está ejecutando. Estoy intentando finalizar el proceso, si es así, simplemente devuelve un código de error. ¿Es realmente así de simple? Comencemos con la pregunta, ¿cómo puedo determinar si hProcess es un identificador de mi proceso? La respuesta es: obtener el identificador de mi proceso en mi proceso, luego pasarlo a la función de enlace a través del mecanismo de comunicación entre procesos y compararlo con hProcess, ¿verdad? ¡Equivocado! Debido a que el identificador es un valor que depende del proceso, no tiene sentido comparar el valor del identificador de mi proceso entre diferentes procesos.
¿Qué hacer? Echemos un vistazo a mi hProcess y cómo llega allí. Solo el ID del proceso es único y el sistema operativo utiliza el ID del proceso para identificar el proceso.
Cuando un programa quiere acceder al proceso, primero debe usar la función OpenProcess e ingresar el ID del proceso al que se accederá para obtener un identificador del proceso. p>
DWORD dwDesiredAccess, // Los derechos de acceso que desea obtener
BOOL bInheritHandle, // Indica si desea heredar el identificador obtenido
DWORD dwProcessId // Para acceder al ID del proceso
);
El contexto se aclara gradualmente: antes de llamar a TerminateProcess(), se debe llamar a OpenProcess() y dwProcessId en OpenProcess(). La lista de parámetros es única en todo el sistema Definitivamente. Conclusión: la función a enganchar no es TerminateProcess (), sino OpenProcess (), cada vez que se llama a OpenProcess (), primero debemos verificar si dwProcessId es el ID de mi proceso (usando el mecanismo de comunicación entre procesos). , Solo necesitamos devolver un código de error y listo. El Administrador de tareas no puede controlar mi proceso, entonces, ¿cómo finaliza mi proceso?
A estas alturas, todos los misterios han sido resueltos. El proceso desde Hook TerminateProcess() hasta Hook OpenProcess() encarna el concepto de pensamiento inverso. De hecho, llegué al callejón sin salida de TerminateProcess() y no pude salir durante mucho tiempo, pero finalmente surgió una chispa de inspiración y mi atención se centró en OpenProcess() para evitar que el proceso muriera. Comparte la alegría de esta experiencia con todos.