[Taller] Api Hooking en modo usuario

Iniciado por YST, 1 Agosto 2009, 05:27 AM

0 Miembros y 3 Visitantes están viendo este tema.

Imprimir
Ir Abajo Páginas1 2
Acciones del Usuario

YST

1 Agosto 2009, 05:27 AM Ultima modificación: 2 Agosto 2009, 00:29 AM por YST
Taller de Api hooking

Este texto se puede publicar libremente siempre que se mantenga el autor.
Autores:YST & Hacker_Zero


Conocimientos previos:
  • ASM        
  • Manejo minimo de las apis de windows
  • Formato PE [Metodo IAT patch]


Contenido
  • 1.-Introducción

  • 2.-Inyección de codigo
  • 2.1-Teoría
  • 2.2-Relización

  • 3.-Metodo de trampolín
  • 3.1-Teoría
  • 3.2-Relización

  • 4.-Metodo de IAT patch
  • 4.1-Teoría
  • 4.2-Relización

  • Despedida



    1.Introducción

    En este taller se explicara el api hooking, mediante 2 metodos distintos conocidos como el metodo trampolín y el metodo IAT patch .

    El api hooking para quien no lo conosca es basicamente en modificar el comportamiento de una api por lo que queramos nosotros.

    Todo el taller sera hecho usando el lenguaje ensamblador, a si que si no dominas el lenguaje aunque sea en un nivel basico no comprenderas todo el taller por eso recomiendo leer un poco sobre este lenguaje antes de leer el taller ;) .


    2.Inyección de codigo


    2.1Teoría

    La inyección de codigo consiste en hacer que un codigo que nosotros programemos sea ejecutado por un proceso externo.

    Para esto se crea un hilo con CreateRemoteThread en el proceso externo teniendo su PID ( Process ID ) y se escriber el codigo inyectado en el proceso creando un espacio con VirtualAllocEx y luego escribimos en el espacio generado con WriteProcessMemory .



    2.1Relización


    Para darnos una idea de la inyección de codigo inyectaremos un codigo que muestre un mensaje mediante la api MessageBoxA ;) .

    Entonces inyectaremos la siguiente función
    Código (asm) [Seleccionar]
    ;pGetProcAddress = Puntero a la api GetProcAddress
    proc FuncionInyectada,pGetProcAddress
    locals ; Definimos las variables locales
    BaseKernel32 dd ?    ;MZ de la kernel32.dll
    endl
    ;Leemos el PEB  para obtener la base del kernel
        xor  eax, eax
        add  eax,[fs:eax+30h]
        mov  eax, [eax + 0ch]
        mov  esi, [eax + 1ch]
        lodsd
        mov  eax, [eax + 08h]
        mov [BaseKernel32],eax ;Guardamos en BaseKernel32 el MZ de la kernel32.dll

     stdcall [pGetProcAddress],[BaseKernel32],"LoadLibraryA" ; Sacamos la posición de LoadLibraryA en la kernel32.dll
     stdcall eax,"user32.dll" ;Cargamos la user32.dll
      stdcall [pGetProcAddress],eax,"MessageBoxA";Sacamos la posición de la api MessageBoxA
      stdcall eax,0,0,0,0     ;Mostramos el mensaje
      leave ;Terminamos
        ret ;
        endp
        FinFuncion:

    Para evitar lios los procesos donde trabajaremos seran creados por nosotros mismo mediante la api CreateProcessA y en nuestro code usaremos la siguiente función que mediante esta api crea un proceso.
    Código (ASM) [Seleccionar]

    ;pExe = Nombre del exe
    ;PI = Puntero a una estructura de PROCESS_INFORMATION
    proc LanzarHilo,pExe,PI   ;Función que cre un proceso
       invoke GlobalAlloc,GPTR,sizeof.STARTUPINFO
       mov edi,eax
    invoke CreateProcessA,0,[pExe],0,0,0,CREATE_SUSPENDED,0,0,eax,[PI]  ;creamos el proceso
       invoke GlobalFree,edi
       ret
    endp  

    El siguiente paso es crear un espacio en el proceso donde escribiremos nuestra función :P , para eso usaremos la api  VirtualAllocEx y igual que en la creación del proceso para comodidad nos aremosa una comoda función que use esta api y nos retorne la posición donde se puede escribir
    Código (asm) [Seleccionar]

    ;pTamaño = Tamaño necesitado
    ;pPid = Id del proceso.
    proc ReservarEspacio,pTamaño,pPid        ;Función que crea un espacio en el proceso
       invoke VirtualAllocEx,[pPid],0,[pTamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
       ret
    endp    

    Luego de generar el espacio en el proceso , escribimos nuestra funcion con WriteProcessMemory y creamos el hilo remoto con CreateRemoteThread pasandole por el parametro la direccion del GetProcAddress que usamos en nuestra función inyectada, el codigo nos queda mas o menos a si.

    Código (asm) [Seleccionar]

    ; FinFuncion-FuncionInyectada = tamaño de la funcion
    include 'win32ax.inc' ;Incluimos la libreria
    .code ; Declaramos la sección de codigo
    proc start ; Entry Point
       locals
           PI                      PROCESS_INFORMATION   ;Información del Proceso
           DirFun                  dd ? ;Espacio donde escribiremos    nuestro codigo
       endl
    stdcall LanzarHilo,"notepad.exe",addr PI ; Creamos el proceso donde inyectaremos , el proceso es de un notepad.
    stdcall ReservarEspacio,FinFuncion-FuncionInyectada,[PI.hProcess]     ;Creamos un espacio donde podremos esacribir
     mov [DirFun],eax                    ;Guardamos la direccion donde podemos escribir en DirFun
         invoke WriteProcessMemory,[PI.hProcess],[DirFun],FuncionInyectada,FinFuncion-FuncionInyectada,0  ;Escribimos nuestra funcion en el proceso.
         invoke CreateRemoteThread,[PI.hProcess],0,0,[DirFun],[GetProcAddress],0,0  ;Creamos un hilo en el proceso pasandole por parametro ola direccion de GetProcAddress
    ret
    endp
    proc LanzarHilo,pExe,PI   ;Función que cre un proceso
       invoke GlobalAlloc,GPTR,sizeof.STARTUPINFO
       mov edi,eax
    invoke CreateProcessA,0,[pExe],0,0,0,CREATE_SUSPENDED,0,0,eax,[PI]  ;creamos el proceso
       invoke GlobalFree,edi
       ret
    endp
    ;pTamaño = Tamaño necesitado
    ;pPid = Id del proceso.
    proc ReservarEspacio,pTamaño,pPid        ;Función que crea un espacio en el proceso
       invoke VirtualAllocEx,[pPid],0,[pTamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
       ret
    endp
    ;pGetProcAddress = Puntero a la api GetProcAddress
    proc FuncionInyectada,pGetProcAddress
    locals ; Definimos las variables locales
    BaseKernel32 dd ?    ;MZ de la kernel32.dll
    endl
    ;Leemos el PEB  para obtener la base del kernel
        xor  eax, eax
        add  eax,[fs:eax+30h]
        mov  eax, [eax + 0ch]
        mov  esi, [eax + 1ch]
        lodsd
        mov  eax, [eax + 08h]
        mov [BaseKernel32],eax ;Guardamos en BaseKernel32 el MZ de la kernel32.dll

     stdcall [pGetProcAddress],[BaseKernel32],"LoadLibraryA" ; Sacamos la posición de LoadLibraryA en la kernel32.dll
     stdcall eax,"user32.dll" ;Cargamos la user32.dll
      stdcall [pGetProcAddress],eax,"MessageBoxA";Sacamos la posición de la api MessageBoxA
      stdcall eax,0,0,0,0     ;Mostramos el mensaje
      leave ;Terminamos
        ret ;
        endp
        FinFuncion:
    .end start ; Declaramos el Import data y el Entry Point    



    2.Metodo de trampolín


    2.1-Teoría

    El metodo trampolín consiste en hacer que la api salte a nuestra función , esto se consigue cambiando los primeros bytes de la api por un codigo que salte a nuestra función ( por eso lo de trampolín) .

    Para lograrlo se inyecta un codigo que saca el MZ de la dll mediante la api GetModuleHandle , se saca la dirección de la api con GetProcAddress y luego se le da permisos de escritura a los 6 primeros bytes con VirtualProtectEx .

    Muchos se preguntaran por que a los 6 primeros bytes , esto es por que escribiremos un
    Código (asm) [Seleccionar]
    push DireccionDeNuestraFuncion
    ret
    que esto ocupa un total de 6 bytes ( 0x68 = PUSH[1byte] , 1 Dword la posicion y 0xC3 = Ret[1 byte] ) , para los que no sepan el ret hace algo que se podria describir como un "pop EIP" haciendo un salto a lo ultimo pusheado en la pila.

    Para lograr hookear se necesita estar en su mismo espacio en memoria , para esto se inyectara de la manera anteriormente explicada el codigo que hace el hook.


    2.2-Realización

    Para explicar un poco mas la idea nos "autohookearemos" , la api que hookearmos en nosotros mismos es la api lstrlenA de la libreria kernel32.dll y haremos que devuelva siempre 0.

    Ya explicado lo que vamos a hacer nos ponemos en marcha  :P .


    Lo primero que haremos sera sacar la posición de la libreria kernel32.dll usando la api GetModuleHandle
    , de la siguiente manera:

    Código (asm) [Seleccionar]
    include 'win32ax.inc'     ;Incluimos la libreria
    .code                 ;Declaramos la sección de codigo .
    start:  ;Entry point
    invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
    ret ; salimos
    .end start ;Establecemos el EntryPoint y el

                                                                     

    Luego obtendremos la dirección de la api lstrlenA( la que hoockearemos ) mediante la api GetProcAddress de la siguiente manera ;)

    Código (asm) [Seleccionar]

    include 'win32ax.inc'     ;Incluimos la libreria
    .code                 ;Declaramos la sección de codigo .
    start:  ;Entry point
    invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
    invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
    mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx
    ret ; salimos
    .end start ;Establecemos el EntryPoint y el

                                                         


    Luego le tenemos que dar permisos de escritura a los primeros 6 bytes de la api lstrlenA que tenemos guardada su posición previamente en ebx , entonces para esto usaremos la api VirtualProtectEx de la siguiente manera

    Código (asm) [Seleccionar]

    include 'win32ax.inc'     ;Incluimos la libreria
    .code                 ;Declaramos la sección de codigo .
    start:  ;Entry point
    invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
    invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
    mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx

    lea edx,dword[ebp-4]
    invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA

    ret ; salimos
    .end start ;Establecemos el EntryPoint y el

                                                 
    La fuunción con que remplazaremos la lstrlenA sera la siguiente
    Código (asm) [Seleccionar]

    ;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
    proc MylstrlenA,p1
    mov eax,0
    ret
    endp  


    Ya teniendo la función y permisos de escritura , escribiremos nuestro codigo que saltara hacia nuestra función quedando de la siguiente manera nuestro code
    Código (asm) [Seleccionar]

    include 'win32ax.inc'     ;Incluimos la libreria
    .code                 ;Declaramos la sección de codigo .
    start:  ;Entry point
    invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
    invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
    mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx

    lea edx,dword[ebp-4]
    invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA

       mov byte[ebx],0x68   ;Escribimos un PUSH en el primer byte de lstrlenA
       inc ebx   ;Nos vamos al segundo byte de lstrlenA
       mov dword[ebx],MylstrlenA  ;escribimos la direccion de nuestra funcion ( Estaria quedan un PUSH MylstrlenA )
       add ebx,4         ;Nos saltamos 4 bytes(1 dword)
       mov byte[ebx],0xC3;Escribimos el ret
    ret ; salimos
    ;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
    proc MylstrlenA,p1
    mov eax,0
    ret
    endp
    .end start ;Establecemos el EntryPoint y el import data                                                


    En este codigo la api ya estaria hookeada , para comprobarlo mostraremos un MessageBox con lo que devuelve ( Si no devuelve 0 daria error el MessageBoxA ).

    Código (asm) [Seleccionar]
    include 'win32ax.inc'     ;Incluimos la libreria
    .code                 ;Declaramos la sección de codigo .
    start:  ;Entry point
    invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
    invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
    mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx

    lea edx,dword[ebp-4]
    invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA

       mov byte[ebx],0x68   ;Escribimos un PUSH en el primer byte de lstrlenA
       inc ebx   ;Nos vamos al segundo byte de lstrlenA
       mov dword[ebx],MylstrlenA  ;escribimos la direccion de nuestra funcion ( Estaria quedan un PUSH MylstrlenA )
       add ebx,4         ;Nos saltamos 4 bytes(1 dword)
       mov byte[ebx],0xC3;Escribimos el ret
       invoke lstrlen,"Hola" ; Esto deberia devolver 4
       invoke MessageBox,0,eax,0,0 ; Mostramos lop que devuelve , si se muestra el MessageBox LO LOGRAMOS!!
    ret ; salimos
    ;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
    proc MylstrlenA,p1
    mov eax,0
    ret
    endp
    .end start ;Establecemos el EntryPoint y el import data

                                     

    En la idea la unica diferencia entre el Autohook que hicimos y un Hook a otro proceso es que tenemos que inyectar nuestro codigo que hace hook en el proceso  ;D.


    Ya sabiendo inyectar y teniendo la idea de como se hace el API Hook, vamos a hacer algo más divertido, inyectaremos nuestro código en otro proceso para modificar su comportamiento, en éste caso Hookearemos MessageBoxA. Para ésto será necesario crear un buffer con los 5 bytes (en éste caso) que pisamos en la API, para así, cuando queramos llamar a la API original poder hacerlo sin que la llamada caiga tambien en nuestra función  :xD. Con una imagen queda más claro  :P:

    Por qué 5 bytes? Porque a la hora de modificar los bytes del comienzo de la Api, no podemos cortar instrucciones, y en el caso de Messagebox, la Api comienza por:

    Código (asm) [Seleccionar]

           mov edi,edi
            push ebp
            mov ebp,esp


    Eso ocupa exactamente 5 bytes, si lo reemplazamos por un jmp dirección, no cortaríamos ninguna instrucción. Pero ésto no es una constante, no todas las apis empiezan por lo mismo, por lo que en cada Api que vayamos a hookear, necesitaremos echar mano del debuger para fijarnos de no cortar ningúna instrucción  ;).

    MANOS A LA OBRA!

    Lo primero será inyectar nuestra función en el proceso que queremos Hookear:

    Código (asm) [Seleccionar]

    proc start
       locals
           ProcessName             db                              "MessageBoxA.exe",0
       endl

       stdcall Inyectar,addr ProcessName,FINFuncion-FuncionInyectada,FuncionInyectada,[GetProcAddress]
       cmp eax,-1
       jne salir

       invoke MessageBoxA,0,"No se encontró el proceso!",0,0

       salir:
       invoke ExitProcess,0
    endp

    proc Inyectar,ProcessName,Tamaño,Funcion,Datos
       locals
           struct PROCESSENTRY32
               dwSize                  dd ?
               cntUsage                dd ?
               th32ProcessID           dd ?
               th32DefaultHeapID       dd ?
               th32ModuleID            dd ?
               cntThreads              dd ?
               th32ParentProcessID     dd ?
               pcPriClassBase          dd ?
               dwFlags                 dd ?
               szExeFile               rb MAX_PATH
           ends

           pInfo                   PROCESSENTRY32                  ?
           Handle                  dd                              ?
           PID                     dd                              ?
           DirFuncion              dd                              ?
           hProcess                dd                              ?
       endl

       ;Obtenemos el PID del proceso
       invoke CreateToolhelp32Snapshot,0x00000002,0
       mov [Handle],eax

        mov eax,sizeof.PROCESSENTRY32
        mov [pInfo.dwSize], eax

       BuclePid:
           invoke Process32Next,[Handle],addr pInfo
           cmp eax,0
           je FinProcBuclePID ;No hay más procesos
           invoke lstrcmp,addr pInfo.szExeFile,[ProcessName]
           cmp eax,0
           jne BuclePid
           jmp FinBuclePid

       FinProcBuclePID:
       invoke CloseHandle,[Handle]
       mov eax,-1
       ret

       FinBuclePid:
       invoke CloseHandle,[Handle]
       push [pInfo.th32ProcessID]
       pop [PID]

       ;Lazamos el proceso
       invoke OpenProcess,PROCESS_CREATE_THREAD+PROCESS_VM_OPERATION+PROCESS_VM_WRITE,FALSE,[PID]
       mov [hProcess],eax

       ;Reservamos espacio en el proceso
       invoke VirtualAllocEx,[hProcess],0,[Tamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
       mov [DirFuncion],eax

       ;Escribimos los datos en memoria
       invoke WriteProcessMemory,[hProcess],[DirFuncion],[Funcion],[Tamaño],0

       ;Creamos el hilo
       invoke CreateRemoteThread,[hProcess],0,0,[DirFuncion],[GetProcAddress],0,0

       ret
    endp                    


    No explicaré el código de inyección, con los comentarios es más que suficiente, ya lo explicó mi compañero YST y se supone que dominamos la inyección y queremos hacer un Rootkit  ;D.

    Ahora lo interesante, la función que inyectaremos:

    Código (asm) [Seleccionar]

    proc FuncionInyectada,pGetProcAddress

        locals
            BaseKernel32                   dd               ?
            OriginalProtection             dd               ?
        endl

        ;Leemos el PEB  para obtener la base de KERNEL32.DLL
        xor  eax, eax
        add  eax,[fs:eax+30h]
        mov  eax, [eax + 0ch]
        mov  esi, [eax + 1ch]
        lodsd
        mov  eax, [eax + 08h]
        mov [BaseKernel32],eax

        ;Obtenemos la dirección de MessageBoxA
        stdcall [pGetProcAddress],[BaseKernel32],"GetModuleHandleA"
        mov edi,eax
        stdcall edi,"USER32.DLL"
        stdcall [pGetProcAddress],eax,'MessageBoxA'

        ;ebx contendrá la dirección de la Api MessageBoxA
        mov ebx,eax

        ;Obtenemos la dirección de VirtualProtect y damos permisos
        ;de lectura, escritura y ejecución a los 5 primeros bytes de la Api
        stdcall [pGetProcAddress],[BaseKernel32],"VirtualProtect"
        stdcall eax,ebx,5,PAGE_EXECUTE_READWRITE,addr OriginalProtection

        ;Calculamos el delta offset para saber en que
        ;dirección nos estamos ejecutando
        call delta
        delta:
        pop edx
        sub edx,delta  ;edx=delta

        ;Lo guardamos en la pila para no perderlo
        push edx

        ;Mostramos un Messagebox para indicar que nos inyectamos correctamete en el proceso
        ;(Obtenemos la dirección de las variables a partir del delta offset)
        mov eax,edx
        add edx,RMensaje             ;Obtenemos la direccion de las variables RMensaje y msgTitulo
        add eax,msgTitulo             ;a partir del delta offset
        stdcall ebx,0,edx,eax,0    ;ebx=puntero MessageBoxA

        ;Recuperamos el valor de delta de la pila y lo volvemos a guardar
        pop edx
        push edx

        ;Guardamos la dirección de MessageBoxA en la variable dirMessageBoxA
        add edx,dirMessageBoxA
        mov dword[edx],ebx

        pop edx  ;Recuparamos el valor de delta offset de la pila

        ;Modificamos los 5 primeros bytes de la API por un jmp a FuncionHook
        mov byte[ebx],0xE9   ;0xE9=jmp
        inc ebx
        mov ecx,FuncionHook
        add ecx,edx
        sub ecx,ebx
        sub ecx,4
        mov dword[ebx],ecx   ;la dirección a la que saltará

        ret          ;Terminamos, ya hemos modificado el principio de la api,
                      ;cuando el programa llame a MessageBoxA, saltará a FuncionHook

    ;--------------------------------------------------------------------------------------------------------------------------------------------

        ;Contiene los 5 primeros bytes de la Api MessageBoxA y una rutina para saltar a MessageBox+5
        ApiOriginal:
            ;edx=delta
            mov edi,edi         ; Primeros bytes de la api MessageBoxA
            push ebp            ; que pisamos poniendo nuestro salto,
            mov ebp,esp       ;

            add edx,dirMessageBoxA  ;Obtenemos la dirección de MessageBoxA leyendo
            mov eax,dword[edx]       ;la variable dirMessageBoxA y la guardamos en eax
            add eax,5           ;Nos desplazamos 5 bytes
            jmp eax             ;Saltamos a MessageBoxA+5

    ;--------------------------------------------------------------------------------------------------------------------------------------------

        ;Función a la que salta el programa cuando se llama a la API hookeada
        FuncionHook:
            ;Calculamos el delta offset
            call delta2
            delta2:
            pop edx
            sub edx,delta2  ;edx=delta

            ;Limpiamos la pila de los parametros originales
            pop eax
            mov ebx,eax ;Guardamos la dirección de retorno en ebx
            pop eax    
            pop eax
            pop eax
            pop eax

            push edx edx   ;Copiamos el delta a eax y ecx
            pop ecx eax

            ;pusheamos nuestros parámetros obteniendo la dirección de las variables
            ;a partir del delta offset
            push 0
            add ecx,msgTitulo
            push ecx
            add eax,ApiHookedMensaje
            push eax
            push 0

            ;Pusheamos la dirección de retorno
            push ebx

            ;Obtenemos la dirección de ApiOriginal
            mov ecx,edx
            add ecx,ApiOriginal

            ;Saltamos a ApiOriginal
            jmp ecx

    ;-------------------------------------------------------------------------------------------------------------------------------------------

            RMensaje                       db               "Soy el RootKit, me inyecté! :D!",0
            ApiHookedMensaje               db               "Soy un MessageBoxA Hookeado! :D!",0
            msgTitulo                      db               "xD",0
            dirMessageBoxA                 dd               ?
    endp                


    Con eso tendríamos nuestro Rootkit terminado usando el método trampolín:

    Éste es el ejecutable Llamando a MessageboxA:

    Ejecutamos el Rootkit:

    Y cuando el programa hace MessageBoxa(0,"No estoy Hookeado :( !",":(",0) sucede ésto:

    Subo el código fuente completo: Descargar


    En construcción



Yo le enseñe a Kayser a usar objetos en ASM

[Zero]

#1
1 Agosto 2009, 13:31 PM Ultima modificación: 1 Agosto 2009, 14:01 PM por Hacker_Zero
Bravo amigo  ;-). Muy bueno, si señor.

Lo del push ret que te dije no es buena idea, porque muchas apis si pisas 5 bytes (con un jmp) no cortas instrucciones en cambio con el push ret ya pisas un byte de más (en la mayoría de apis). Con el jmp ya queda clavado  y luego si quieres crear el buffer para llamar a la api original no tienes que copiar tantos bytes.

Saludos  ;-)

BlackStack

"El Hombre, en su orgullo, creó a Dios a su imagen y semejanza.”
Nietzsche

Karcrack

#2
1 Agosto 2009, 14:52 PM
Muy bueno, te pongo chincheta ;D Espero verlo acabado pronto ;)

Como dice Hacker_Zero ves con cuidado de no pillar instrucciones a medias...sino habrá un error muy feo :-\

(PGP ID)

h0oke

#3
1 Agosto 2009, 14:54 PM
Muy buen, hasta que ganó chincheta.

Seguiré el tallercito YST  ;)

Éxitos!!!

YST

#4
1 Agosto 2009, 20:13 PM
Cita de: Karcrack en  1 Agosto 2009, 14:52 PM
Muy bueno, te pongo chincheta ;D Espero verlo acabado pronto ;)

Como dice Hacker_Zero ves con cuidado de no pillar instrucciones a medias...sino habrá un error muy feo :-\

Muchas gracias karccrack , en la noche lo continuo :P


Yo le enseñe a Kayser a usar objetos en ASM

cassiani

#5
1 Agosto 2009, 20:42 PM
Hasta que te animaste  :silbar:

LixKeÜ

#6
7 Agosto 2009, 14:54 PM
 muy bueno me gustaría aplicar esto ala api del winsock  :rolleyes: ever si me sale algo :D

[Zero]

#7
7 Agosto 2009, 15:28 PM
Cita de: LixKeÜ en  7 Agosto 2009, 14:54 PM
muy bueno me gustaría aplicar esto ala api del winsock  :rolleyes: ever si me sale algo :D

Googleando puedes encontrar código del MsnNightmare de Mazard que hace hook a send y recv en C  ;D.

Saludos  ;)

BlackStack

"El Hombre, en su orgullo, creó a Dios a su imagen y semejanza.”
Nietzsche

Jaixon Jax

#8
7 Agosto 2009, 16:13 PM
 ;D
[
Citarhook a send y recv en C

  Jeje estuve tanto tiempo buscando estas funciones pero tengo entendido que estas funciones no son apis sino mudulos de la libreria winsock ? y si son api me entero ? si pudieras Hacker Zero extenderias mas tu explicacion sino  :rolleyes: me podrias pasar el link del manual de mazard jeje.  :laugh:

Karcrack

#9
7 Agosto 2009, 20:16 PM
Si que son APIs... APIs de la libreria de Winsock(ws2_32.dll/wsock32.dll)...

Aqui tienes el enlace al codigo:
Código [Seleccionar]
http://mzrdzoneforo.tomahost.org/index.php?topic=30.0

(PGP ID)
Imprimir
Ir Arriba Páginas1 2
Acciones del Usuario