AYUDA Hookear Función

[sebah97]

La función (enrealidad es un sub de un juego en vb6) a hookear es la siguiente.

Código (vb) [Seleccionar] Expandir

Sub SendData(sdData As String)
Dim retcode
Dim AuxCmd As String

If Pausa Then Exit Sub

If CONGELADO And UCase$(sdData) <> "/DESCONGELAR" Then Exit Sub
If Not frmMain.Socket1.Connected Then Exit Sub

AuxCmd = UCase$(Left$(sdData, 5))

Debug.Print ">> " & sdData

If Left$(sdData, 1) = "/" And Len(sdData) = 2 Then Exit Sub

sdData = ReplaceData(sdData)

If sdData = "NOPUDO" Then Exit Sub

bO = bO + 1
If bO > 10000 Then bO = 100

If Len(sdData) = 0 Then Exit Sub

If AuxCmd = "DEMSG" And Len(sdData) > 8000 Then Exit Sub
If AuxCmd = "GM" And Len(sdData) > 2200 Then
    NoMandoElMsg = 1
    Exit Sub
End If

If Len(sdData) > 300 And AuxCmd <> "DEMSG" And AuxCmd <> "GM" Then Exit Sub

NoMandoElMsg = 0

bK = 0

sdData = sdData & "~" & bK & ENDC

retcode = frmMain.Socket1.Write(sdData, Len(sdData))

End Sub

El problema que se me presenta es encontrar la dirección de la función con OllyDbg. Y una vez encontrada, qué es lo que tengo que hacer?

Me fijé en el  Código de Luchoz95 pero hasta el momento no logré compilar la Dll :S

[85]

Eso es vb6 ok, bueno esa idea que viste no es la mejor, en realidad lo que podés hacer es implementar algo conocido como "patching", fijate esto
Patching

no confundir con "HotPatching"
http://technet.microsoft.com/en-us/library/cc781109(v=ws.10).aspx

para lo primero, osea 'patching' que significa "parchear la memoria", para eso podés implementar lo que se conoce como 'detours'.
Oficialmente 'detours' es una librería de Microsoft para realizar parches a funciones API de Win32, pero se ha actualizado bastante. fijate la última versión si te interesa..
http://research.microsoft.com/en-us/projects/detours/

Pero este concepto de un 'detour' más precisamente un 'jmp detour' lo podés aplicar a cualquier función sin la necesidad de una librería.

Se trata de parchear los primeros bytes de una función o en otra parte específica, escribiendo la memoria con una instrucción jmp o call y seguido de una dirección de memoria (VA o RVA, ver instrucción JMP).
JMP
http://stackoverflow.com/questions/2170843/va-virtual-adress-rva-relative-virtual-address

Podés poner 'detours' en las funciones de Opengl32 como en lo que trataba de hacer Luchoz95, y en lo referente a tu código podés investigar como aplicarlo.

Básicamente necesitás la dirección en memoria de la función objetivo, y luego implementar el parche que sería un salto a la dirección de memoria de tu función de reemplazo. Luego lógicamente tenés que hacer que tu función de reemplazo regrese a la original ( Esto es a grandes rasgos, hay algunos detalles más).

[sebah97]

Hola, gracias por responder. Estuve buscando y encontré ésto...

Link

Sirve para lo que estoy buscando hacer?

[85]

lo que tenés que hacer es obtener la dirección de la función que te interesa interceptar, si estás en un sistema de 32 bits una dirección de memoria son 4 bytes, entonces vas a parchear los primeros 5 bytes de la función, con un JMP + dirección de memoria, lo que serían un total de 5 bytes.

Las consideraciones que te decía antes eran que, aunque sólo necesites 5 bytes, a veces es necesario parchear más, por ejemplo 6 o 7, dependiendo del contenido de la memoria en esas posiciones. Eso se rellena con NOPs en algunos casos o en otros se arregla de otra forma. No hay 1 sólo procedimiento específico para seguir cuando hacés un 'detour'.

Antes de parchear tenés que obtener los permisos de escritura en ese lugar de la memoria.

Los bytes que vas a reemplazar no se pierden, sino que los guardás porque necesitás ejecutarlos luego.

Fijate la información acerca de la instrucción JMP. Y lo de VA y RVA.

fijate, te dejo está función que hace todo directamente.

Código [Seleccionar] Expandir


void* DetourFunc( BYTE* src, const BYTE* dst, const int len )
{
BYTE* jmp = (BYTE*)malloc( len + 5 );
DWORD dwback;
VirtualProtect( src, len, PAGE_READWRITE, &dwback );
memcpy( jmp, src, len );
jmp += len;
jmp[0] = 0xE9;
*(DWORD*)( jmp + 1 ) = (DWORD)( src + len - jmp ) - 5;
src[0] = 0xE9;
*(DWORD*)( src + 1 ) = (DWORD)( dst - src ) - 5;
VirtualProtect( src, len, dwback, &dwback );
return ( jmp - len );
}


Los argumentos son:
src: dirección de la función
dst: dirección de tu función de reemplazo
len: cantidad de bytes para parchear/guardar

[sebah97]

Perdón que siga preguntando, es que soy nuevo en el tema y me interesa.

lo que tenés que hacer es obtener la dirección de la función que te interesa interceptar, si estás en un sistema de 32 bits una dirección de memoria son 4 bytes, entonces vas a parchear los primeros 5 bytes de la función, con un JMP + dirección de memoria, lo que serían un total de 5 bytes.

Quiere decir que JMP vale 1 byte??

Y otra cosa con respecto a los punteros... SIEMPRE son necesarios sin importar el método que se use?

[85]

para trabajar directamente con la memoria son necesarios, a menos que te manejes con las direcciones de las variables o de las funciones directamente, o utilices "pseudopunteros" o typecasting de variables de tipo DWORD por ejemplo que guarden direcciones de memoria. Es decir, la idea es usar punteros si.
Claro en un sistema x32 con JMP+ADDRESS son 5 bytes, 1 del JMP y 4 de la ADDRESS.

Te recomiendo que desensambles algunos programas muy simples en C para examinar el código ASM, al menos para ver de que se trata. No es necesario saber programar en ASM para observar algunos conceptos.

Bajate algún desensamblador o sino utilizando un depurador, El tema es que veas los bytes en la memoria, que corresponden a tu programa.