Problema de win7 hook timeGettime getTickCount

======== ========

escuchar socket conectar socket

=== ======= ==========

socket() socket()

enlazar() enlazar()

escuchar()

conectar()========> aceptar()========>getTickCount fuera de orden escuchar()

conectar ()----->aceptar()------>crear socket de conexión

enviar()------------------- ---->recv()

recv()<--------- ---------------enviar()

.

.

.

closesocket() closesocket() closesocket()

Como podemos ver, el cliente La función connect () realiza la operación de solicitud de conexión real, así que echemos un vistazo a los parámetros de la función connect:

int connect(

SOCKET s, // Especifica en qué socket Operación

const struct sockaddr FAR *name, // Esta es una estructura que describe la dirección IP del servidor

int namelen // Especifica el tamaño de la estructura anterior

) ;

Para parámetros de nombre

unsigned short sin_port; // número de puerto IP

struct in_addr sin_addr // Estructura que identifica la dirección IP

p>

char sin_zero[8]; // Espacio de marcador de posición para compatibilidad con sockaddr

};

Aquí podemos ver que los parámetros entrantes tienen The La información de destino de la solicitud de conexión se describe claramente. Lo siguiente que debe hacer es configurar un enlace API global para conectar todas las llamadas connect() del programa. Antes de realizar la operación connect() real, primero analizaremos los parámetros entrantes. Si se descubre que el objetivo de la conexión es uno al que no podemos acceder y no realizaremos la conexión. Si se descubre que no se permite el acceso al destino de la conexión, la conexión no se realizará y solo se devolverá un código de error. Es así de simple y puedes experimentar el efecto de comerlo en todo el mundo.

De manera similar, también puede utilizar otras funciones de Hook para monitorear diversos aspectos de la comunicación de la red, como interceptar paquetes de datos enviados y recibidos para su análisis, etc. Esto depende de la intención del diseñador, por lo que es posible que desee intentarlo. , siente el encanto de Hook API.

Hook Win32 API Application Research 2: Proceso Anti-kill

En el sistema operativo WINDOWS, cuando no podemos finalizar o no sabemos cómo finalizar un programa, o somos demasiado vagos para busque el botón "salir", generalmente está presionado.

"CTRL+ALT+SUPR" abre el administrador de tareas, busca el programa que desea finalizar y hace clic en "Finalizar tarea Jaja, aunque es un poco grosero, es efectivo en la mayoría de los casos, ¿no?

Imagínese si existiera un software que impusiera ciertas restricciones a las actividades laborales que el usuario podría realizar en la computadora, y el usuario no pudiera eliminar fácilmente las restricciones "finalizando la tarea", ¿qué hacer? ? Sólo hay tres métodos: 1. Bloquear la combinación de teclas de acceso rápido "CTRL+ALT+SUPR"; 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 se sentirá muy incómodo si está acostumbrado al método de "finalizar tarea". Para la segunda dirección, Red INDOWS 9X puede usar fácilmente el método de registrar el proceso de servicio, pero para WINDOWS; NT No existe tal método para el sistema operativo según la arquitectura y el proceso es difícil de ocultar, pero aún puede usar la combinación de teclas de acceso rápido "ALT + SUPR". El proceso de este método es difícil de ocultar. 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 y es mi trabajo: el filtro de sitios web IPGate utiliza este método para evitarlo. matando, a continuación me gustaría presentar este método.

"Finalizar tarea" en el Administrador de tareas en realidad finaliza el proceso a la fuerza. La aplicación asesina utilizada es una función API de Win32 llamada TerminateProcess (). 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

);

Cuando vea esto, no necesita mirar hacia abajo para saber qué hacer a continuación: conecte la función TerminateProcess() y determine el proceso que intenta finalizar cada vez que llama a TerminateProcess(). ¿Es mi 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 control de mi proceso en mi proceso y 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, // Acceso deseado

BOOL bInheritHandle, // Indica si desea heredar el identificador obtenido

DWORD dwProcessId // Acceso deseado ID de proceso

);

El contexto se aclara gradualmente: antes de llamar a TerminateProcess(), se debe llamar a OpenProcess() y el dwProcessId en la lista de parámetros de OpenProcess() se determina de forma única por todo el sistema. 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.

Estudio tres de la aplicación API Hook Win32: control de velocidad variable < < <

Esta es una aplicación más alternativa e interesante de la API Hook Win32.

El control de velocidad variable aquí mencionado no significa que se pueda cambiar la velocidad de cualquier programa, sino que sólo se puede cambiar la velocidad del programa que cumpla estas condiciones: la velocidad del programa depende de la control de tiempo, es decir, el programa La frecuencia de ejecución de la unidad de ejecución está controlada artificialmente por el mecanismo de tiempo, en lugar de depender de la velocidad de la CPU. Por ejemplo, si un programa emite un tic-tac cada segundo, se comportará igual en una computadora rápida que en una lenta. Este tipo de programa se basa en el control de tiempo, que es el objeto de nuestro estudio: "cambio".

Existen muchos mecanismos de sincronización para las aplicaciones de Windows. El programa de muestra mencionado anteriormente se puede utilizar para implementar el mensaje WM_TIMER. El intervalo de tiempo para generar el mensaje WM_TIMER se puede configurar a través de la función SetTimer (). Otros métodos incluyen obtener la hora del sistema mediante funciones como GetTickCount() y timeGetTime(), y luego cronometrar comparando los intervalos de tiempo y configurar eventos de reloj mediante timerSetEvent(). Echemos un vistazo a las definiciones de estas funciones:

UINT_PTR SetTimer(

HWND hWnd, //El identificador de ventana que recibe el mensaje WM_TIMER

UINT_PTR nIDEvent , // El ID del temporizador

UINT uElapse, //El intervalo de tiempo entre las apariciones del mensaje WM_ TIMER

TIMERPROC lpTimerProc //La dirección de entrada de la función de devolución de llamada cuando ocurre el temporizador

);

MMRESULT timeSetEvent(

UINT uDelay, // El intervalo de tiempo entre eventos de reloj

UINT uResolution, // El intervalo de tiempo entre eventos de reloj

UINT uResolution, // Establece la resolución del evento de reloj

LPTIMERCALLBACK lpTimerProc, // Maneja la dirección de entrada de la función de devolución de llamada cuando ocurre el evento de reloj

DWORD dwUser, // ¿No? DWORD dwUser(VOID) // Devuelve cuántos milisegundos han pasado desde que se inició el sistema

DWORD timeGetTime(VOID) // Similar a GetTickCount(), pero con mayor resolución

Por lo tanto, veamos si podemos controlar el parámetro uElapse de SetTimer (), el parámetro uDelay de timeSetEvent () y los valores de retorno de GetTickCount () y timeGetTime (), podemos lograr control de velocidad variable, a menos que la aplicación use otros mecanismos de sincronización, pero la mayoría de las aplicaciones usan estos mecanismos.

Es el turno de los ganchos, ya que generalmente solo queremos cambiar la velocidad de un programa específico (como un juego). programa), no configuramos enlaces globales. Dado que no sabemos exactamente qué mecanismo de sincronización está utilizando la aplicación, tomamos todas las funciones anteriores y escalamos solo los parámetros de sincronización o los valores de retorno.