Foro de elhacker.net

INTRODUCCIÓN:
 
Bienvenidos al taller de ASM. Abril Negro 2008.

En este taller vamos a aprender a programar en ASM :P. Usaremos FASM como ensamblador ya que es gratuito y open source, lo podéis descargar de su página oficial: http://flatassembler.net/download.php . Así mismo nuestras aplicaciones serán de 32bits y correrán en procesadores x86.


¿QUÉ ES ASM?

Bueno, como no quiero agobiaros con mucha teoría que casi todo el mundo conocerá simplemente cito de la wikipedia, que esto es un taller ¡nos interesa la práctica!


Convendría que os leyerais lo que pone en la wikipedia, por enteraros un poco de lo que trata el taller.


LOS REGISTROS DEL MICROPROCESADOR:

ASM es totalmente diferente a cualquier otro lenguaje de alto nivel que podáis conocer. Al usar ASM nos valemos directamente de los registro de nuestro microprocesador. No voy a explicar para que valen todos y cada uno de los registros, simplemente os indico los más representativos, que nos sobrarán para diseñar cualquier programa:

EAX, EBX, ECX, EDX: Estos cuatro registros serán los que usemos principalmente para almacenar datos. Tienen el tamaño de un DWORD, es decir 4 bytes o lo que es lo mismo 32 bits. A su vez los podemos dividir en dos para referirnos a datos del tamaño de un WORD o 2 bytes y a su vez en dos para almacenar datos que ocupen un único byte. Para que quede más claro os dejo un dibujo de cómo queda dividido el registro y el nombre que toma:

Por si el link está roto (http://es.geocities.com/e0n_ftp/TallerASM/Imagen1.jpg)

En la imagen e puesto el registro EAX de ejemplo, pero esto mismo es aplicable a los otros tres cambiando la A por una B, una C o una D según corresponda.

EDI, ESI: Al igual que los cuatro anteriores los usaremos para almacenar datos, aunque tienen otras funciones. También podemos referirnos a ellos como SI o DI si queremos modificar sus 2 bytes más bajos.

EIP: Este registro contendrá la dirección de la siguiente instrucción que se ejecutará.

EBP, ESP: El registro EBP apunta a la Base de la pila y el ESP apunta a la parte Superior de la pila. La pila no es más que una estructura de tipo LIFO ( http://es.wikipedia.org/wiki/LIFO ) que nos servirá para pasar parámetros a las funciones o almacenar datos entre otras cosas. Más adelante todo esto se explicará con mayor claridad, pero para que os hagáis una idea, cuando vosotros en C o en otro lenguaje llamáis al api MessageBox por ejemplo en realidad pasa esto:

Por si el link está roto (http://es.geocities.com/e0n_ftp/TallerASM/Imagen2.gif)

Lo último que se mete en la pila con el call es la dirección de retorno, es decir, el valor que tomará el registro EIP al salir de la función para que el programa siga su curso normal. Si no entendéis muy bien esto ahora mismo no os preocupéis, luego se irá explicando todo con mayor detalle.


Aparte de estos hay muchos más registros en el microprocesador, pero nosotros con estos pocos tendremos más que suficiente para hacer la gran mayoría de nuestras aplicaciones en ASM.


OLLY DGB: EL DEBUGGER

Un debugger o depurador es una herramienta que nos permitirá ejecutar nuestro programa paso a paso para solucionar ciertos problemas de programación con los que nos podamos encontrar cuando estemos programando en ASM o en cualquier otro lenguaje.

Lo primero que debemos hacer es descargarnos este debugger de manera totalmente gratuita de su página oficial ( http://www.ollydbg.de/odbg110.zip ). Una vez lo tengamos todo preparado comenzaremos la primera practica de nuestro taller ;D

Empezamos. Copiamos este código en el FASM y ensamblarlo pulsando Control+F9. Por ahora no tenéis que entender nada del código, esta práctica es solamente para que veáis lo que pasa dentro del microprocesador al ejecutar un programa:

include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.data
   cuerpo db 'Hola mundo', 0
   titulo db 'xD', 0
 
.code
start:
 
   mov eax, NULL    ; Esto equivale a eax = 0
   mov ebx, 0x1234  ; Esto equivale a ebx = 1234 (el 0x de delante indica que es hexadecimal)
 
   push 0           ; Observamos la pila para ver que pasa
   push titulo
   push cuerpo
   push 0
   call [MessageBoxA]
 
   mov edi, NULL
   mov di, 2
 
   push 0
   call [ExitProcess]
 
 
.end start 

Apretamos Control+F9, guardamos este código en cualquier ruta con el nombre de Practica1.asm y vereis como se genera un .exe.

Ahora abrimos el olly, File -> Open y seleccionamos nuestro ejecutable. Veremos algo como esto:

Por si el link está roto (http://es.geocities.com/e0n_ftp/TallerASM/Imagen3.jpg)

En rojo os he indicado las partes fundamentales de las que consta nuestra ventana. Las analizo a continuación una a una ;)

Código del programa: Aquí podemos ver varias cosas interesantes. En la primera columna empezando por la izquierda podemos ver la dirección de memoria en la que se encuentra cierta instrucción. Presupongo que todo el mundo sabe más o menos como se carga un archivo en memoria. En la segunda columna podemos ver nuestro código en forma de opcodes, o lo que es lo mismo, nuestro código expresado en unos y ceros, solo que en base 16 para una mayor claridad, es decir, en hexadecimal. En la tercera columna vemos nuestro código tal y como lo hemos escrito en el FASM y en la última columna vemos algunas aclaraciones que nos pone el olly que nos serán de gran ayuda para entender mejor lo que hace el programa.

Registros: En esa parte del debugger podemos ver los registro que hemos explicado antes y los datos que contienen.

Editor hexadecimal: Vemos nuestro programa tal y como está cargado en memoria. De nuevo todo eso son unos y ceros, pero se expresa en hexadecimal por que para un humano es más facil comprenderlo.

Pila: Aquí podemos ver nuestra famosa pila. Según vayamos ejecutando el programa veremos las cosas que entran y salen de ella y de que manera lo hacen.


Bien, ahora ya sabemos donde están los datos que nos interesan de nuestro programa, pero el programa no se está ejecutando ni haciendo nada, ¿por qué? Este es precisamente el objetivo de un debugger, ejecutar el programa paso a paso, así que vamos a aprender lo necesario para lograrlo.

F8: Si pulsamos esta tecla el programa se ejecutará instrucción a instrucción permitiéndonos ver en cada momento el valor que tienen los registros, las variables y de mas.

F7: Causa el mismo efecto que F8, con la diferencia de que si nos encontramos en un call y pulsamos F8 el programa no entrará dentro de la función, si pulsamos F7 si lo hará y podemos ver como funciona por dentro la misma.

F2: Sirve para poner un breakpoint. Es decir, una “marca” que hará que el programa se para al llegar a ella.

F9: Ejecuta con normalidad el programa a no ser que se encentre con un breakpoint.

Bien, ahora ya conocemos todo lo necesario para depurar nuestros programas, así que manos a la obra. Lo primero que vamos a hacer es poner un breakpoint justo después de la llamada a MessageBoxA pulsando F2. Veréis que el 40201E que indica la posición de memoria de esta instrucción (por lo menos esa es la dirección en mi caso) se pone en rojo.

Ahora vamos a ir pulsando F8 poco a poco para ir viendo lo que sucede. Ejecutamos el mov eax, NULL y si miramos a la derecha, en la zona de los registros, podemos ver como el registro eax se a puesto a cero. Si pulsamos F8 de nuevo veremos como el ebx toma valor 1234.

Ahora entramos en la zona de los push, así que miramos a la pila (abajo a la derecha). Ejecutamos con F8 el primer push y veremos como “empujamos” dentro de la pila un 0. Pulsamos F8 hasta que estemos justamente en el call. Ahora en vez de F8 pulsamos F7 para entrar dentro de la llamada al api MessageBoxA. Lo primero que notaremos es que en la pila entra un parámetro más, el 0x40102E en mi caso por lo menos, que es la dirección de retorno, esto le indica al programa que cuando termine la llamada al api tiene que regresar a ese punto la ejecución.
Si queremos podemos ir pulsando F8 dentro del api, pero como ese código no nos interesa pulsamos F9 para que el programa se ejecute con normalidad. Si lo hacemos veremos que se nos muestra un mensaje emergente y que el programa se detiene donde habíamos puesto nuestro breakpoint.

Finalmente podemos seguir pulsando F8 para ver como van cambiando los registros indicados (incluido el EIP, que apuntará constantemente a la siguiente instrucción) y finalmente salir del programa al llamar al api ExitProcess.


INSTRUCCIONES BÁSICAS DE ASM:

Ha continuación explicaré algunas instrucciones básicas que nos proporcionan los micros de la familia x86. Hay más, podéis googlear un poco para verlas, pero con estas nos apañharemos.
Cuando me refiero a miDWORD, miByte o algo por el estilo, me estoy refiriendo a una variable del tamaño especificado después de "mi". Para hacer las pruebas poned el código entre las etiquetas indicadas a continuación, por ejemplo esto sería para el MOV (se explica a continuación):

include 'H:\Archivos de programa\FASM\INCLUDE\WIN32AX.inc'
 
.data
        miByte  db ?
        miWORD  dw ?
        miDWORD dd ?
 
.code
start:
 
 
; ---> Aqui haz las pruebas
 
mov eax, ebx    ; eax = ebx
mov eax, 1 ; Hace eax = 1
mov eax, miDWORD ; eax = Puntero a una variable
mov eax, [miDWORD]  ; eax = Contenido de la variable
mov [miDWORD], eax ; MiDWORD pasa a valer lo que valga eax
;mov [miDWORD], [otroDWORD] ; No válido
 
; <--- FIN
 
invoke ExitProcess, 0
 
.end start

MOV destino, origen
 Sirve para mover información del origen al destino. Por ejemplo de un registro a otro, de un registro a una variable, etc. Aunque no nos sirve para mover datos entre dos variables.

Ejemplos:

mov eax, ebx    ; eax = ebx
mov eax, 1 ; Hace eax = 1
mov eax, miDWORD ; eax = Puntero a una variable
mov eax, [miDWORD]  ; eax = Contenido de la variable
mov [miDWORD], eax ; MiDWORD pasa a valer lo que valga eax
;mov [miDWORD], [otroDWORD] ; No válido

Es muy importante distinguir que en FASM si ponemos una variable entre “[ ]” nos estamos refiriendo a su contenido y si no a su posición en memoria.

INC/DEC Variable o registro

INC suma uno a una variable o registro y DEC le resta uno.

Ejemplos:

inc eax
dec ecx
inc [miDWORD]
dec [miDWORD]

ADD/SUB Destino, Cantidad

ADD suma un determinado número a un registro o variable. SUB lo resta. Como siempre no está permitido sumar o restar datos directamente entre variables.

Ejemplos:

add eax, 5
add edi, [miDWORD]
add [miDWORD], eax
sub [miDWORD], 2

MUL Multiplicando

MUL varía dependiendo de si el Multiplicando tiene 8 bits, 16 bits o 32 bits:
- Para 8 bits se hace AL * Multiplicando. Se guarda el resultado en AX.
- Para 16 bits se hace AX * Multiplicando. Se guarda el resultado en DX..AX (DX..AX significa que se concatenan los valores, es decir si DX = 0001 y AX = 2001 DX..AX = 00012001)
- Para 32 bits se hace EAX * Multiplicando. Se guarda el resultado en EDX:EAX

Ejemplo:

mov [miDWORD], 0x12932
mov eax, 0x54562
mul [miDWORD]
; EDX..EAX = 0x000000061E863F24

DIV Divisor

DIV de nuevo varía un poco dependiendo de si el divisor tiene 8 bits, 16 bits o 32 bits:
- Para 8 bits se hace AL / Divisor. Se guarda el resultado AL y el resto en AH.
- Para 16 bits se hace DX..AX / Divisor. Se guarda el resultado en AX y el resto en DX.
- Para 32 bits se hace EDX..EAX / Divisor. Se guarda el resultado en EAX y el resto en EDX.

Ejemplo:

mov [miByte], 4
mov al, 9
div [miByte]
; al = Resultado entero = 9/4 = 2
; ah = Resto = 1

PUSH DWORD

PUSH mete un DWORD en la pila. La pila se utiliza por ejemplo para pasar parámetros a las funciones o para utilizar variables locales. Es importante que cada PUSH tenga un POP (ahora lo explico).

Ejemplos:

push [miDWORD]
push eax
push edi

POP DWORD

POP al contrario que PUSH saca un DWORD de la pila.

Ejemplos:

push [miDWORD]
pop ebx
push eax
pop [miDWORD]

Como ya sabéis podéis ver como cambia la pila con el olly por ejemplo ;)

RET

RET se usa generalmente para regresar de una función. Lo que hace realmente es “popear” un DWORD de la pila y saltar a él. De ahí que en las funciones se meta la dirección de retorno en la pila y con el RET continúe la ejecución del programa donde corresponde.
A los interesados en el Stack Overflow esto les puede interesar bastante ;)

JMP Etiqueta/Dirección

JMP viene de jump y como el nombre indica vale para saltar a una determinada posición de memoria. FASM nos permite utilizar etiquetas que no son más que una palabra seguida de “:” para facilitar el salto. Luego el linker ya se encarga de ajustarlo todo. Con un ejemplo se entiende mejor.

Ejemplo:

jmp continuar
mov eax, eax ; Esto no se ejecutaría
continuar:

CMP Valor1, Valor2

CMP compara dos valores. En realidad lo que hace esta instrucción es restar el Valor2 del Valor1 y activar el Flag correspondiente a el resultado. Por ejemplo si son iguales, si uno es mayor que el otro… (un Flag es como un registro pero que solo almacena 1 bit).
Usaremos esta instrucción para los saltos condicionales que se explicarán a continuación.

SALTOS CONDICIONALES:

Estos saltos se diferencian del JMP en que mientras que el primero salta donde le indiquemos siempre estos pueden hacerlo o no. Esto nos puede resultar muy útil para simular lo que sería la estructura IF de un lenguaje de alto nivel por poner un ejemplo.

Hay muchos tipos, así que no pondré todos, pero por citar algunos:
JE – Salta si los números comparados son iguales.
JNE – Salta si no son iguales.
JG – Salta si Valor1 es mayor que Valor2.
JGE – Salta si Valor1 es mayor o igual que Valor2.
JB – Salta si Valor1 es menor que Valor2.
JBE – Salta si Valor1 es menor o igual que Valor2.

Como ya he dicho hay muchos más, así que buscad un poco por google, que son unos cuantos para ponerlos todos.

Ejemplo:

mov eax, 2
cmp eax, 2
je salir

 invoke MessageBox, 0, 'No salta', '', 0 ; Esto no se ejecuta

salir:
        invoke ExitProcess, 0


Ejercicos propuestos (no seais vagos!  :¬¬ )

- Hacer un programa que inicialice a 2 el registro eax, a 5 el ebx y los sume quedando su resultdo en eax

- Hacer un programa que halle la media de los valores 7, 8, 5, 2 ,9 ,1 ,0  y 3

- Hacer un programa que meta en la pila los valores 1, 2, 3, 4, 5 y 6 y los asigne a los registros eax, ebx, ecx, edx, edi y esi respectivamente con un pop

- Implementar la instrucción IF de los lenguajes de alto nivel con saltos condicionales

- Hacer un programa que sume dos números que indikemos en el código y si la suma es mayor que 5 muestre un mensaje, si no salga (para mostrar el mensaje poner esa línea: invoke MessageBox, 0, 'Mayor que 5', '', 0 )



INSTRUCCIONES LÓGICAS:

Aparte de las instrucciones que he puesto (y las que no he puesto :P) hay una serie de operaciones lógicas que nos sirven para tratar con bits. Aquí dejo las tablas de verdad de algunas de ellas. No os preocupéis si no sabéis aun que significa cada cosa, más abajo las explico todas, solo echadle un ojo a la tabla:

         X   Y      AND         OR        XOR                 |                X   NOT
         0    0      0             0          0                      |                0   1
         0    1      0             1          1                      |                1   0
         1    0      0             1          1                      |
         1    1      1             1          0                      |

Aparte de las que hay en la tabla también vamos a ver otras ;) No voy a entrar en mucho detalle, se usan como todas las instrucciones que ya he explicado, solo hay que seguir la tabla.


NOT Destino

Lo que hace esta operación lógica es cambiar 1’s por 0’s y viceversa. Imaginaos que tenemos en eax el valor 001101 (en binario), tras hacer un “not ax” nos quedaría almacenado en ese mismo registro 110010.

AND Destino, Dato

Imaginemos que tenemos guardado en eax el valor 101011 y en ebx el valor 011101,. Tras hacer “and eax, ebx” nos quedaría guardado en eax el valor  001001.

OR Destino, Dato

Imaginemos que ahora tenemos guardado en eax 1010 y en ebx 1100. Tras hacer “or eax, ebx” nos quedaría guardado en eax 1110.

XOR Destino, Dato

Ahora tenemos en eax 10110 y en ebx 11011. Tras hacer “xor eax, ebx” nos quedaría en eax 01101. Esta operación es especialmente útil (y muy utilizada) en métodos de cifrado, ya que si os fijáis en su tabla de verdad al hacer un xor a un bit “destino” con otro bit “dato” que valga 5 por poner un ejeplo, el bit “destino” quedará totalmente irreconocible. Lo gracioso del asunto es que si volvemos a hacer al bit “destino” un xor de nuevo con un 5 volverá a valer lo que valía en un inicio.

ROL/ROR Destino, Rotación

Estas operaciones a nivel bit lo que hacen es mover hacia la izquierda (ROL) o hacia la derecha (ROR) un grupo de bits tantas posiciones como indique “Rotación”. Imaginemos que hacemos “ror eax, 2” pues moveríamos todos los bits de eax dos posiciones hacia la derecha. ¿Qué pasa con los bits que estan muy a la derecha y se salen? Pues simplemente “entran” por la izquierda. Podemos imaginar que los bits están formando un círculo y los vamos desplazando por el mismo con ROR y ROL. Por poner un ejemplo si tenemos estos bits “101011” y les hacemos un ROL con “rotación” 1 nos quedaría 010111.

SHL/SHR Destino, Rotación

SHL es como ROL y SHR como ROR con la diferencia de que los bits que se salen al ser desplazados no entran por el otro lado, si no que los bits que se pierden son reemplazados por ceros. Por poner un ejemplo si hacemos un SHL con “rotación” 2 a 000101 nos quedaría 010100. Si os fijáis un poco veréis que 000101 en decimal es 5 y 010100 es 20. Es decir que SHL con rotación 1 es como multiplicar por 2, con rotación 2 es como multiplicar por 4….



Hasta aquí el apartado de instrucciones lógicas. Hay muchas más, al igual que hay muchas más instrucciones propias de ensamblador, pero por falta de tiempo no puedo explicarlas todas, así que recomiendo mirar las que faltan. Por recomendar algunas webs interesantes:

http://www.jegerlehner.com/intel/IntelCodeTable_es.pdf
http://www.wikilearning.com/curso_gratis/curso_de_programacion_de_virus-introduccion/4312-1


ESTRUCTURA DEL CÓDIGO EN FASM:

Una vez ya conocemos todas las instrucciones básicas con las que cuenta nuestro microprocesador ya podemos empezar a programar cosas más serias y útiles :P.
Para ello tenemos que saber como escribir nuestro código para que FASM lo entienda y genere un ejecutable.
FASM tiene diversas formas de estructurar el código, entre ellas destacan estas tres:


1 - Lo primero de debemos hacer es incluir el win32ax: include 'C:\archivos de programa\fasm\include\win32ax.inc' claro, que variará dependiendo de donde tengáis instalado el FASM ;)

Con este método nos ahorramos construir el ImportData a mano, es decir, ir poniendo el nombre de cada api que usamos indicando la dll a la que pertenece.
La estructura básica es esta:

include 'win32ax.inc'
 
.data
; Aqui van las variables
 
.code
start: ; Aqui empezaria el programa
	; Aqui va el código
 
	; Aquí abajo tambien podemos poner variables :D
.end start ; Aqui terminaria el programa
 

Si os fijais en el ejecutable generado mediante este método y sabéis un poco del formato PE veréis que aparte de las secciones .data y .code que le hemos indicado nosotros también a creado el solo una sección .idata con los nombres de todas las apis que hemos utilizado.

La ventaja de esta forma de estructurar el código es clara: nos ahorramos un montón de trabajo generando el ImportData a mano.
Las desventajas son que si por ejemplo queremos usar un api que no esté declarada en la win32ax.inc tenemos que cargarla con LoadLibrary y GetProcAddress, mientras que si hubiesemos creado el ImportData a mano esto no pasaría.

2 - Para este método podemos incluir de nuevo win32ax o win32a (la ax es la versión extendida, tiene mas declaraciones:

format PE GUI ; Tipo de ejecutable
entry start  ; El "main" de nuestro código
 
section '.code' code readable executable
 
start:
 
        ; Aqui el codigo
 
section '.data' data readable writeable
 
 	; Aqui las variables
 
section '.idata' import data readable writeable
 
	; Aqui el ImportData 

Mirad el ejemplo que viene con FASM en la ruta FASM\EXAMPLES\PEDEMO para ver como funciona ;) Este formato es de lo más útil para manejar cuantas secciones queremos que tenga el archivo, sus características y donde queremos que vaya cada cosa dentro de las mismas.

3 - Otra opción es no señalar ninguna sección, con lo que FASM creará una única sección llamada “.flat” en la que pondrá todo, las estructura es esta:

include 'H:\Archivos de programa\FASM\INCLUDE\WIN32A.inc'
	; Aqui el codigo
	; Aqui las variables
data import
	; Aqui el ImportData
end data

Mirad el ejemplo FASM\EXAMPLES\BEER para más información :P


VARIABLES EN FASM:

A diferencia de los lenguajes de programación de alto nivel en ensamblador no tenemos variables del tipo char, integer, long o cosas por el estilo, con ensamblador trataremos directamente con bytes y conjuntos de bytes. Los tipos principales de datos y con los que nos apañharemos son tres. El byte, el word (16 bits, es decir, 2 bytes) y el dword (32bits, es decir, 4 bytes).

La declaración de variables es muy simple, solamente hay que poner (en el sitio donde corresponda, que eso ya lo hemos visto en el punto anterior) el nombre de la variable, seguido de su tipo (db si es un byte, dw si es un word o dd si es un dword) seguido de un ? si queremos que no se inicialice con ningún valor o también podemos indicar el valor con el que queremos que se inicialice la variable. Por ejemplo:

 
        cad db 'Hola', 0  ; Variable de tipo byte. Como podeis apreciar
                          ; la inicialozamos con un valor que es muy superior
                          ; a un unico byte, ya que FASM nos permite construir
                          ; cadenas de texto de esta manera. Fiajaos en el 0
                          ; final, es es caracter de fin de cadena, que es un
                          ; caracter que debemos poner para saber donde termina
                          ; la cadena.
        palabra dw ?      ; Word no incializado
        doble   dd 5      ; Dword inicializado a 5, es decir, esos cuatro bytes
                          ; contienen el valor 5
 

Si en vez de usar db, dd o lo que sea ponemos rb, rd seguido de un número lo que haremos será reservar tantas veces se indique en ese número, hechadle un ojo con el olly a este código:

include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.data
        doble    rd 4  ; Reservamos 4 dwords
        cadena   rb 50 ; Reservamos 50 bytes
        palabra  rw 2  ; Reservamos 2 words
 
.code
start:
 
       mov [doble+4], 5
       leave
       ret
 
.end start  

Pues ya está con esto ya sabemos declarar variables. Para utilizarlas solo tenéis que referiros a ellas como hemos hecho en los puntos anteriores con mov’s, and’s y de más ;)

---

Tras todo esto ya solo os queda aprender un poco el api del vuestro sistema operativo (podéis usarla con invoke o push + call) y empezar a realizar vuestras propias aplicaciones ;) Mucha suerte.

1S4ludo E0N

Versión para leer sin conexión:
http://e0n-productions.blogspot.com/2009/01/taller-asm.html

Bravo E0N, a leer se ha dicho, felicidades y muchas gracias ;D

Aunque no haz explicado mucho me gustó. :D
Sigue asi. :D :D :D :D
Aunque tu imagen se fue a abajo :P

Saludos.

Gracias EON! A leer se ha dicho!

 ;)

Ta bueno pa los que no tienen ni idea del ASM. Sigue asi. =]

Hola de nuevo EON, excelente trabajo,

Pero tengo un problema, no domino mucho sobre ASM, al intentar compilar me sale el siguiente error:

(http://s1.subirimagenes.com/otros/322722dibujo.jpg)

Ya volvi a bajar el FASM pero sigue sin funcionar, de que puede ser el fallo??

Mi imagen de q? tengo imagen y todo? xDD No hay mucho que explicar por ahora, ya iré poniendo pokito a poko


@nitr0x: Veras yo tengo el fasm instalado en H:\archivos de programa\fasm, cuando lo normal es que se encuentre en C:\archivos de programa\fasm. Cambia la H de detras del include por una C (y si la ruta es otra pues la ruta completa) y ya te funcionará ;)

Salu2

Muchas Gracias E0N soluccionado, que error mas tonto, pues aun me llevo un rato pensando de que podia ser.

Gran trabajo sigue asi

Saludos

 :o Excelente EON Graxias XD buena teorica de sus varibles y demas aver si vamos adelante y profundismos en el tema  ;)

Salu2s y aver que consigo aprender pa mejorar mi cracking  >:D

muchas gracias por empezar el taller, lo esperaba con ansias desde que apareció la votación

No estabilizas la pila ni un poco? :S

y esto de donde te lo sacas?


una vez llamado a exitprocess el programa termina, no hay que usar ret ni nada de nada. ¿que hay que estabilizar? esplicate mas afondo.

Le meti use registro coomo podia haberle metido otro fue simple paranoia

y el


Es verdad no hace falta, pero ese cumple una accion si la condiciones de salir no se sumple?.

:)


De todas formas el cambio esta en la pila lo otro fue simple paranoia :)

pero que condicion? ademas leave equivale a pop ebp... no veo ni un enter ni su equivalente push ebp etc etc.  entonces que estas sacando de la pila?

Rozor, lo que estás haciendo no tiene mucho sentido, siento decirtelo. Pero en fin no pasa nada, esto es un taller, es weno q demos ideas, y ademas yo tb me puedo ekivocar q no soy programador profesional ni nada de eso ;)

Salu2

Me ha encantado el manual ;D Sigue así E0N...
A pesar de no saber nada sobre ASM he pillado algunas cosas.. solo falta leérmelo 5 veces más :xD

A ver cuanto tarda la próxima entrega >:D :P No se si podre esperar mucho :xD

Muy buena primera parte :), lo unico a la gente que sabe mas por favor no desvirtuen con cosas que aun no hemos visto. :rolleyes:

PD: A no ser que claro, expliquen de lo que estan hablando como EON asi entendemos todos. ;)

Espero la segunda parte :D


Me referia a que las imagenes del taller no se veian ;D

= D buena parada de carro para los que iba, creo.. jaja =)

paciencia no ?

Weno a ponerse a aprender ASM...lo seguiré...

Weno tube mirando y asta ahora bastante facil...lo k observé es k para llamar a la API usamos un include...pero como sería para llamar a una API sin el include?

Saludos ;)

NO HE DIXO NADA

mirate los ejemplos que trae fasm, permite definir tu mismo las funciones que usaras de varias formas.

hay mas, si vas a ir de listo lo minimo es que te informes.


o tu estas muy mal o cambia de depurador. la respuesta a una funcion se da en eax y GetProcAddress no es que sea otra cosa.


si, esque usar el PEB es nuevo ahora. (no tiene años ya).


deslumbranos con tus artes viricas que nos vamos a reir un rato.

ROZOR eres un patan y un petardo de tio, igual que todos los codigos que pones en el foro que amontonas instrucciones y no sabes ni para que funcionan.

no me funciona esto ¿alguien sabe pq?.


yo quiero que lo contestes tu, maestro de las artes ocultas.

PD: E0N no sera pro, pero tampoco va de pro. si hace una introduccion al lenguaje ensamblador esta en su derecho y mas ¿tu que ofreces? (aparte de las risas que nos pegamos a tu costa) solo intentas tirar a tierra el trabajo de los demas.

sigue con este estupendo manual EON mucho te lo vamos a agradecer mucho , ya lo estoy leyendo y practicando  :D muchas gracias!!!

Ha palabras necias oidos sordos. Habre tu propio post no desvirtualices a los demas, ademas esta claro que la casa se empieza por los cimientos. Weno aqui una duda, se puede 'apañar' para que el segmento de datos ocupe lo justo y tambien estaria bien eliminar los DB 0 del final que ocupan mas que el codigo propio. Supongo que habra que modificar el PE indicando al compilador lo que queremos.
Gracias por el manual tengo mi asm un poco oxidado jeje y solo habia programado en 16 bits.
Un saludo.

lo de el tamaño extra se debe a los redondeos que se hacen. en el tutorial de ferchu se explica.

@Distorsion

Si, mira, por poner un ejemplo compila esto con el fasm:

format PE GUI 4.0
include 'H:\archivos de programa\fasm\include\win32a.inc'
 
 
        invoke  MessageBox,0,cuerpo, titulo,MB_OK
        invoke  ExitProcess,0
 
        cuerpo db 'Hola mundo', 0
        titulo db ':P', 0
 
data import
 
 library kernel32,'KERNEL32.DLL',\
         user32,'USER32.DLL'
 
  import kernel32,\
        ExitProcess,'ExitProcess'
  import user32,\
        MessageBox,'MessageBoxA'
 
end data   

Veras que solo se crea una sección en el ejecutable, la flat, q es la crea fasm por defecto cuando se estructura de esta manera el código ;)

Ahora haz esto: borras todos los bytes con un editor hexadecimal a partir del 0x2BC
y cambias el RawSize de la sección por 0xBC. Con esto te kedará un archivo de 700 bytes ;)


Posiblemente se pueda reducir un poco mas el tamaño del ejecutable, pero de esta manera ya tienes la sección de "codigo" bien ajustadita

---

Respecto a lo de Rozor, ya lo hemos hablado por privado y me a pedido disculpas, parece q por fin ha entrad en razon, asi q si algun mod puede borrar todos los post q no estén relaccionados con el taller pues mejor.

Salu2

E0N, tengo una duda, estaba trasteando con los ejemplos que trae el FASM, y modifiqué el BEER.ASM quedando así

; Beer - example of tiny (one section) Win32 program
 
format PE GUI 4.0
 
include 'H:/Archivos de Programa/FASM/include/win32a.inc'
 
; no section defined - fasm will automatically create .flat section for both
; code and data, and set entry point at the beginning of this section
 
	invoke	MessageBoxA,0,_message,_caption,MB_ICONQUESTION+MB_YESNO
	cmp	eax,IDYES
	jne	exit
 
	invoke	mciSendString,_cmd_open,0,0,0
	invoke	mciSendString,_cmd_eject,0,0,0
	invoke	mciSendString,_cmd_close,0,0,0
	invoke	MessageBoxA,0,_aburrimiento, _aburres,MB_ICONQUESTION+MB_OK
 
exit:
	invoke	ExitProcess,0
 
_message db 'Te veo aburrido, quieres echar unas canastas?',0
_caption db 'Estás aburrido',0
 
_cmd_open db 'open cdaudio',0
_cmd_eject db 'set cdaudio door open',0
_cmd_close db 'close cdaudio',0
 
_aburrimiento db 'Hala! Haz un Triple!',0
_aburres db 'NBA',0
 
; import data in the same section
 
data import
 
 library kernel32,'KERNEL32.DLL',\
	 user32,'USER32.DLL',\
	 winmm,'WINMM.DLL'
 
 import kernel32,\
	ExitProcess,'ExitProcess'
 
 import user32,\
	MessageBoxA,'MessageBoxA'
 
 import winmm,\
	mciSendString,'mciSendStringA'
 
end data
 

Añadí un mensaje despues de que se abriese la bandeja del CD, mi duda es, como puedo cambiar el icono?, lo he compilado y funciona perfecto, pero no puedo cambiarlo (el código lo adjunta para mostrar como quedó y nada más, aunque solo he añadido y traducido, no he cambiado más)

Fijate en los parametros del MessageBoxA. Si miras en la MSDN la descripcion de este api veras que para modificar el icono hay que cambiar el último parametro.
http://msdn2.microsoft.com/en-us/library/ms645505(VS.85).aspx

Por poner un ejemplo:

En la MSDN encontrarás prácticamente todo lo que necesites respecto a apis
Salu2 E0N

no me refiero a eso, aunque tambien me viene bien, gracias, me refiero al icono del ejecutable

A ok xD pues para eso tienes que añadir una sección de resources al ejecutable, fijate en el ejemplo "MINIPAD" al final del todo ;)

Para q te hagas una idea tienes que añadir algo así:

section '.rsrc' resource data readable
 
  directory RT_ICON,icons,\
            RT_GROUP_ICON,group_icons
 
  resource icons,\
           1,LANG_NEUTRAL,icon_data
 
  resource group_icons,\
           17,LANG_NEUTRAL,main_icon
 
 
  icon main_icon,icon_data,'NombreDeTuIcono.ico'     

Salu2

Gracias por tu tiempo tio ;)

lo he añadido y no sale el icono (he cambiado la linea del icono para poner el nombre del icono que quiero que tenga), y con el resource hacker me aparecen las categorías de Icon y Icon Group, pero me dan un error diciendo Out of System Resources

Te pongo un ejemplo 100% funcional y miras a ver en lo que te has ekivocado:

format PE GUI 4.0
entry start
 
include 'H:\Archivos de programa\FASM\INCLUDE\win32ax.inc'
 
section '.data' data readable writeable
 
        mensaje db 'Tengo icono!!', 0
        titulo  db 'lol', 0
 
 
section '.code' code readable executable
start:
 
       invoke MessageBox, 0, mensaje, titulo, 0
       invoke ExitProcess, 0
 
section '.idata' import data readable writeable
 
  library kernel,'KERNEL32.DLL',\
          user,'USER32.DLL'
 
  import kernel,\
         ExitProcess,'ExitProcess'
 
  import user,\
         MessageBox, 'MessageBoxA'
 
 
section '.rsrc' resource data readable
 
  directory RT_ICON,icons,\
            RT_GROUP_ICON,group_icons
 
  resource icons,\
           1,LANG_NEUTRAL,icon_data
 
  resource group_icons,\
           17,LANG_NEUTRAL,main_icon
 
  icon main_icon,icon_data,'icono.ico' 

Solo tienes que poner un icono llamado icono.ico en la misma ruta y ya tira
Salu2

vale, es que habría que reestructurar el codigo casi al completo, muchas gracias, ahora lo pruebo,


funciona, pero ahora no consigo hacerlo para que haga como el beer.asm

Mira, en la sección '.code' tienes que meter el código ejecutable, las variables las metes en la seción '.data' y la it en la sección '.idata' (las apis que usas vamos). Este es el estandar por así decirlo aunke a las secciones las pudes llamar como kieras y darles los permisos q kieras ;) Resumiendo:

format PE GUI 4.0
entry start
 
include 'H:\Archivos de programa\FASM\INCLUDE\win32ax.inc'
 
section '.data' data readable writeable
 
        _message db 'Te veo aburrido, quieres echar unas canastas?',0
        _caption db 'Estás aburrido',0
 
        _cmd_open db 'open cdaudio',0
        _cmd_eject db 'set cdaudio door open',0
        _cmd_close db 'close cdaudio',0
 
        _aburrimiento db 'Hala! Haz un Triple!',0
        _aburres db 'NBA',0
 
 
section '.code' code readable executable
start:
 
        invoke   MessageBoxA,0,_message,_caption,MB_ICONQUESTION+MB_YESNO
        cmp     eax,IDYES
        jne     exit
 
        invoke  mciSendString,_cmd_open,0,0,0
        invoke  mciSendString,_cmd_eject,0,0,0
        invoke  mciSendString,_cmd_close,0,0,0
        invoke  MessageBoxA,0,_aburrimiento, _aburres,MB_ICONQUESTION+MB_OK
 
       exit:
        invoke  ExitProcess,0
 
section '.idata' import data readable writeable
 
 library kernel32,'KERNEL32.DLL',\
         user32,'USER32.DLL',\
         winmm,'WINMM.DLL'
 
 import kernel32,\
        ExitProcess,'ExitProcess'
 
 import user32,\
        MessageBoxA,'MessageBoxA'
 
 import winmm,\
        mciSendString,'mciSendStringA'
 
 
section '.rsrc' resource data readable
 
  directory RT_ICON,icons,\
            RT_GROUP_ICON,group_icons
 
  resource icons,\
           1,LANG_NEUTRAL,icon_data
 
  resource group_icons,\
           17,LANG_NEUTRAL,main_icon
 
  icon main_icon,icon_data,'icono.ico'    

Todo esto lo explicaré mas adelante, q no me esta dando tiempo! xD
Saludos E0N ;)

muchas gracias, lo estaba haciendo bien, menos porque en la  sección '.idata' no puse el

Está bien enfocado, a ver si saco tiempo, pienso seguir el taller. Yo ya me habia iniciado un poco en TASM, con el debug... pero me he decidido profundizaré con FASM.

Enhorabuena E0N

Saludos

Rozor te dejo una pista asi dejas de hacer el ridiculo: STDCALL.

Yo tengo una pregunta, no se si lo estoy compilando bien, pero al guardarlo como E0N explica en el primer post, no se me crea el ejecutable.. :-( ... Perdon por mi ignorancia,pero tengo conocimientos nulos sobre este tema y me parece muy interesante..

PD:E0N me ha encantado esta parte de taller, muy bien explicada, te felicito  ;)..

un saludo!

El primer post se ha actualizado. Se a añadido el capitulo "INSTRUCCIONES BÁSICAS DE ASM" Para hacer los ejercicos, ya que aun no se ha explicado por falta de tiempo como se estructura el código en FASM, pegad este código y haced las prácticas donde se indica:

include 'C:\archivos de programa\fasm\include\win32ax.inc'
 
.code
start:
 
    ; Colocad aqui vuestro codigo
 
.end start 

Para comprobar si os el código hace lo que quereis utilizad el olly y para cualkier duda preguntad ;)

Salu2 E0N

---

Te da algún tipo de error al intentar ensamblar el código o ensambla bien y no se te crea el ejecutable?

Las mejores herramientas de depuracion para Windows (sic): Debugging Tools for Windows (http://www.microsoft.com/whdc/devtools/debugging/default.mspx).

No me sale ningún tipo de error, lo guarda como ".Asm", pero el ejecutable no hay forma de crearlo, por lo menos yo no lo consigo... :-\ , tampoco guardandolo con extension ".Exe"..

Bueno haber si lo consigo solucionar!. Un saludo!

no tienes mas que darle a ctlr+F9, despues F9 (run).

Ya lo conseguí!, mi problema era que lo guardaba con formato de texto, porque habia escrito las etiquetas ".code" & "start:"todo junto,es decir (".codestart:"), y no saltaba error...Pero ya esta solucionado, muchas gracias ;) ;)

un saludo ;D

felicitaciones por la segunda parte de tu manual ! , pero pudieras profundisarla un poco mas con mas ejemplos (como lo hiciste con la primera parte)??? ya se que estoi pidiendo ,pero cuando tengas tiempo ,  ya que la verdad entendi al 100% la primera parte i un 70% la segunda,bueno ya se que ese es mi problema i que tu estas haciendo un aporte noo mas i nadie te tiene por que exigir (igual la voi a leer dos veces mas).bueno eso se espera la tercera parte (i la modificacion de la segunda XD) .
s4lu2!

Pues no se que mas quieres que profundice, son instruccioes básicas y viene un ejemplillo de cada una. Lo mejor es que hagas una prueba de cada una y mires con un debugger (el olly mismo q es el que yo he explicado o con los que a dicho Eternal Idol) para ver bien como funcionan. Una vez las entiendas intenta hacer los ejercicios y si te salen es q ya las tienes casi dominadas :P

Salu2 y si no entiendes alguna pregunta

no consigo comprender en los ejemplos lo de miByte y miDWORD, no se supone que ahi van registros de la CPU? precisamente por el uso de mibyte no consigo hacer una división en ASM a la hora hacer el ejercicio de sacar la media

Es verdad, se me ha olvidado explicar eso. Eso se supone que son variables que hemos tenido que definir nosotros. Les e puesto ese nombre para que se entendiese que eran DWORD's bytes o lo que fueresen. Por ejemplo, para el mov sería asi:

include 'H:\Archivos de programa\FASM\INCLUDE\WIN32AX.inc'
 
.data
        miByte  db ?
        miWORD  dw ?
        miDWORD dd ?
 
.code
start:
 
 
; ---> Aqui haz las pruebas
 
mov eax, ebx    ; eax = ebx
mov eax, 1 ; Hace eax = 1
mov eax, miDWORD ; eax = Puntero a una variable
mov eax, [miDWORD]  ; eax = Contenido de la variable
mov [miDWORD], eax ; MiDWORD pasa a valer lo que valga eax
 
; <--- FIN
 
invoke ExitProcess, 0
 
.end start  

Simplemente coloca los ejemplos entre el espacio señalado para ver como funciona
Salu2 ;)

muchas gracias, ahora ha quedado claro, aunque debería estar puesto eso en el post principal para evitar dudas de más gente.

Saludos

te dejo los ejercicios hechos por MP, no se si el 4º (el del IF) está bien, pero lo demás supongo que si

para que no diga nadie que le fastidié los ejercicios, posteo aquí el código por petición de E0N:

Ejercicio 1:

include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.code
start:
 
mov eax, 12  ;Puede ser cualquier valor, yo les he dado estos porque me apetecía
mov ebx, 8    ;Usar esos numeros
add eax, ebx
 
.end start
 

ejercicio 2

include 'H:\archivos de programa\fasm\include\win32ax.inc'
.data
	miByte	db  ?
 
.code
 
start:
 
mov [miByte], 8
mov al, 7
add al, 8
add al, 5
add al, 2
add al, 9
add al, 1
add al, 0
add al, 3
div [miByte]     ; el resultado aparecerá en AL y el resto en AH
 
 
.end start

ejercicio 3

include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.code
 
start:
 
push 1
pop eax
push 2
pop ebx
push 3
pop ecx
push 4
pop edx
push 5
pop edi
push 6
pop esi
 
 
.end start

Ejercicio 4 (no se si lo tengo bien o no)

include 'H:\Archivos de programa\FASM\INCLUDE\WIN32AX.inc'
.code
start:
 
mov eax, 23
mov ebx, 39
cmp eax,ebx
je iguales
jne distintos
 
iguales:
 
invoke MessageBox, 0, 'eax y ebx son iguales', '', 0
invoke ExitProcess, 0
 
distintos:
 
invoke MessageBox, 0, 'eax y ebx son distintos', '', 0
invoke ExitProcess, 0
 
.end start

Ejercicio 5: (se que es así, pero no se si he elegido bien los saltos, creo que si)

include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.code
 
start:
 
mov eax, 7
mov ebx, 1
add eax, ebx
cmp eax, 5
JBE salir
JG mensaje
 
mensaje:
 
	invoke MessageBox, 0, 'Mayor que 5', '', 0
 
salir:
 
	invoke ExitProcess, 0
 
.end start

Aquí podeis descargar los códigos fuente y los ejecutables compilados, lo he resubido porque vi que el código del primer ejercicio estaba en balco a la hora de postearlo:

http://www.megaupload.com/?d=Y1O3BY3K (http://www.megaupload.com/?d=Y1O3BY3K)

Creo que estan todos bien...los he mirado por encima. Tan solo decir que para simplificar un poco el codigo en el ejecicio 4 yo haria asi

	mov eax, 23
	mov ebx, 39
	cmp eax,ebx
	jne distintos
 
	invoke MessageBox, 0, 'eax y ebx son iguales', '', 0
	invoke ExitProcess, 0
 
	distintos:
 
	invoke MessageBox, 0, 'eax y ebx son distintos', '', 0
	invoke ExitProcess,0

Pero sabiendo que se trata de utilizar muchos saltos... esta bien como esta  ;)

Yo usaria JE o JNE para hacer los saltos despues de un CMP o como dijo SheKel es mas correcto si es JNE que salte y si es JE no hacerle el salto si no que las siguientes instrucciones sea el si pasa.

no pasa nada, ya está hecho y tambien es correcto no?, pues ya está, no le demos más vueltas al asunto

Despues de leer 3 veces XD pude hacer los ejercicios .
una pregunta como se puede hacer que si la respuesta de un mensage es "si" hacer tal cosa i si la respuesta es "no" hacer otra cosa 

Pues lo comparas igual que si fuese un número pero con la cadena, piensa que comparas bytes, solo eso, como ya puse lo q hace cmp en realidad es esto:


Seria asi:

mov eax, 'SI'
cmp eax, 'SI'
jne NO
        invoke MessageBox, 0, 'Es si', '', 0
NO:
invoke ExitProcess

Claro, que en eax tendrías que obtener el valor pidiendosolo al usuario, ya sea creando un formulario, una aplicación de consola o como tu quieras ;)

Salu3

si te refieres al típico mensaje con los botones de si y no usa este (lo he sacado del código al que le quería meter el icono y lo he retocado un poco)

include 'H:\archivos de programa\fasm\include\win32ax.inc'  ;He usado H: porque es mi unidad de disco donde tengo el FASM, tu usa la tuya
 
.code
start:
 
invoke   MessageBoxA,0,'aqui va el mensaje','y aqui el titulo de la ventanita',MB_YESNO
cmp eax,IDYES
jne no
 
invoke   MessageBoxA,0,'le has dado al si','SI',0
invoke   ExitProcess
 
no:
 
invoke   MessageBoxA,0,'le has dado al no','NO',0
invoke   ExitProcess
 
.end start                 
 

muchas gracias me funciono  ;D,por cierto eso de MB_YESNO sirve = como en VB?
s4lu2!

supongo que si, ya que es una API de Windows

Si, solo q FASM a diferencia de VB ya trae muchas constantes predefinidas en la win32ax y otras librerias, por eso no tienes como hacer como en VB de andar poniendo el valor de la constante MB_YESNO.
Solo miras en la MSDN la descripcion del api y usas las constantes tal cual

Salu2

muchas gracias por responderme :D i la ultima preguntita que ago ,en codes de E0n i en ejemplos e visto esto:

format PE GUI 4.0
entry start       

¿para que sirve?
gracias de antgemano
s4lu2!

indica el formato y el punto de entrada "main".

muchas gracias por todas las respuestas!!!!!!  , ya se que dije que era mi ultima pregunta pero tengo otra espero no molestar.bueno mi pregunta es eax no acepta mas de 4 letras?? por que por ejemplo en este code que acabode hacer no me deja meter mas de 4 caracteres a eax mirad:

include 'C:\Documents and Settings\krackwar\Escritorio\fasmw16726\INCLUDE\win32ax.inc'
.data
msg dd ?
.code
start:
mov eax , "pre"
mov [msg],eax
pop eax
push MB_YESNO
push msg
push msg
push 0
call [MessageBoxA]
cmp eax , IDNO
je no
mov eax , "si"
mov [msg] , eax
push 0
push msg
push msg
push 0
call [MessageBoxA]
push 0
call [ExitProcess]
no:
mov eax , "no"
mov [msg] , eax
push 0
push msg
push msg
push 0
call [MessageBoxA]
jmp start
.end start              

es logico, estamos trabajando con registros de 32 bits. eax es un DWORD.

Para poner palabras con mas caracteres simplemente pusheas un puntero en la pila y arreglado ;)

hellou bob marley, hey puedo abrir el stub del Xcrypter y copiar su codigo y pasarlo a asm, de alli puedo coger los movs que coge el av y puedo quitar o redireccionarlos a otra pila?? algo asi? me esta dando cacao esta chimbada. Helpme man

No :P Puedes adaptarte un poco el codigo, pero copiando y pegando tal cual no te va a funcionar. Mejor aprende a programarte un crypter tu mismo ;)

---

He actualizado el primer post. Se han añadido tres capitulos, uno con unas cuantas instrucciones que nos faltaban por aprender, otro con las distintas estructuras que puede tomar el código en FASM y otro en el que explico como declarar variables, asi que cuando los leais ya sabreis hacer algún programilla básico ;)

Salu2 E0N

ola ,bueno muy buenas las partes agregadas .Inspirandome en un downloader que hizo Hendrix ise el mio propio y les paso el code para quien le sirva.

include 'C:\Documents and Settings\ezzexziimohn\Escritorio\fasmw16726\INCLUDE\win32a.inc'
format PE GUI 4.0
push 0
push 0
push archivo
push web
push 0
call [Descargar]
   push 2000
   call [dormir]
      push 0
   push titulom
   push mensajem
   push 0
   call [mensaje]
   push 2000
   call [dormir]
push SW_SHOW
push 0
push 0
push archivo
push 0
push 0
call [Ejecutar]
    push 0
   call [terminar]
   mensajem db 'El archivo a sido descargado en c:\foto.jpg', 0
   titulom db 'downloader basico by krackwar', 0
   web db 'http://es.geocities.com/e0n_ftp/bob.jpg' , 0
   archivo db 'c:\foto.jpg' , 0
data import
 
  library kernel,'KERNEL32.DLL',\
          user,'USER32.DLL',\
           dlldes, 'urlmon.dll',\
          shell, 'SHELL32.DLL'
 
  import kernel,\
   dormir , 'Sleep',\
         terminar,'ExitProcess'
import dlldes ,\
    Descargar ,'URLDownloadToFileA'
 import user,\
       mensaje,'MessageBoxA'
 
  import shell,\
         Ejecutar, 'ShellExecuteA'
 
end data         

Veo q has hecho progresos ^^ Si quieres dejar el código un poco más legible te recomiendo el uso de invoke para poder llamar a las apis como se haria en un lenguaje de alto nivel. Por ejemplo esto:

push 0
push 0
push archivo
push web
push 0
call [Descargar]

Te quedaría así:

invoke Descargar, 0, web, archivo, 0, 0

Mucho más legible :P
Salu2

gracias por el consejo , pero lo hice asi por que no me quedaba bien claro lo de los push entonces para probar los hice de esta forma.
s4lu2!

algo que me interesaria mucho saber es como se trabajo con archivos ,osea como en vb6 pongo: i asi puedo leer el archivo i luego ago un split para obtener informacion , osea lo que me interesa es como hacer un edit server pero que este en asm el "server"

Pues usando el api como todo en asm :P Eso lo explicaré mas adelante, q no me das tiempo!!

Puedes usar CreateFile para abrir el archivo deseado y a partir de aki tienes dos opciones:
1 - Usar ReadFile y WriteFile para escribir y leer el archivo
2 - Mapear el archivo con CreateFileMapping y MapViewOfFile

Para obtener el tamaño del archivo usa GetFileSize y no se te olvide usar CloseHandle y UnmapViewOfFile.

Salu3 E0N

PD - Mirate el código de mi Small Joiner, que te será útil para lo que quieres hacer

GRaqcias por la respuesta lo e leido y creo que debo aprender un poquito mas antes de irme a ese nivel(Me tiene mal acostumbrado el vb),Bueno tambien e traducido codes i les dejo una musiquita con el Beep del pc que hizo lympex en vb6 i yo lo pase a asm:

include 'C:\Documents and Settings\krackwar\Escritorio\fasmw16726\INCLUDE\WIN32a.inc'
format PE GUI ; Tipo de ejecutable
push 95
push 300
call [Beep]
push 50
call[dormir]
push 95
push 300
call [Beep]
push 100
call[dormir]
push 95
push 300
call [Beep]
push 250
push 400
call [Beep]
push 100
call[dormir]
push 250
push 400
call [Beep]
push 100
call[dormir]
push 250
push 400
call [Beep]
push 100
call[dormir]
 
push 100
call[dormir]
push 600
push 600
call [Beep]
push 160
push 500
call[Beep]
push 160
push 400
call[Beep]
push 100
call[dormir]
push 160
push 400
call [Beep]
push 50
call[dormir]
push 160
push 400
call [Beep]
push 200
push 500
call [Beep]
push 50
call[dormir]
push 160
push 400
call[Beep]
push 225
push 375
call [Beep]
push 100
call [dormir]
push 700
push 540
call [Beep]
push 100
call[dormir]
push 275
push 450
call [Beep]
push 75
push 375
call [Beep]
push 50
call [dormir]
push 650
push 400
call [Beep]
push 0
call [terminar]
data import
 
  library kernel,'KERNEL32.DLL',\
          user,'USER32.DLL'
 
 
  import kernel,\
   dormir , 'Sleep',\
         terminar,'ExitProcess',\
         Beep , 'Beep'
 
end data                                      

krackwar, ese code está muy bien, se lo he enseñado a mi primo que esta haciendo segundo de ingenieria informática y se ha empezado a reir solo con verlo, despues casi acaba por tierra al enseñarselo ya compilado

Tengo un pequeño problema, estoy haciendo el tipico programa de broma tocahuevos, lo he compilado y va todo bien, al cerrar el mensaje vuelve a salir una y otra vez, y solo se puede cerrar con control alt suprimir, ahora lo que quiero hacer es que lleve un contador, diciendo cuantas veces ha cerrado ya la ventana (por recochineo más que nada), te dejo el código, y cuando puedas me dices como podria hacerlo, lo he hecho mas o menos como pensaba que sería

include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.code
 
start:
mov eax,1
invoke	 MessageBoxA,0,'Quieres que te toque los huevos?','Quieres?',MB_YESNO
jmp putada ; si no pongo el JMP no pasa a la siguiente sección, por lo que no sale la ventanita y empieza a usar sobre el 90% de mi CPU
 
putada:
invoke	 MessageBoxA,0,eax'veces','te he tocado los huevos',0
add eax,1
jmp putada
 
 
.end start

Eso así obiamente no te va a funcionar nunca, tienes que usar el api wsprintf para concatenar texto con números. Ojito a esto:


Vamos, que tienes que cuadrar la pila tu, por que el api no lo hace por ti. El programa sería así:

include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.data
      veces db ' veces',0
      texto dd 0
 
.code
 
start:
 
        invoke   MessageBoxA,0,'Quieres que te toque los huevos?','Quieres?',0
 
        mov ebx, 1 ; No uses eax como contdor porque cambia tras llamar a un api :P
        putada:
                invoke LocalAlloc, LPTR, 100
                mov [texto], eax
 
                push veces
                push ebx
                invoke wsprintf, [texto], '%d%s'
                add esp, 16
 
                invoke MessageBox, 0, [texto], 'te he tocado los huevos', 0
                invoke LocalFree, [texto]
 
                add ebx,1
        jmp putada
 
.end start 

Hechale un ojo con el debugger para ver como el api no restaura la pila y por que hay que poner ese add esp,16 ;)

Salu2

e estado viendo codes de troyanos en asm i todos estan compilados con masm i e visto el code de eon de un manual que esta en C i no e logrado saber como se conecta¿alguien me podria dar un code de un troyano en fasm? o ¿orientarme como hacerlo?

Que estén ensamblados en masm, nasm, fasm o lo que sea te da lo mismo, si lo unico q tienes q ver son las apis que usan para crear el socket y de mas. Mira:
http://mipagina.cantv.net/numetorl869/asmsockguide_es.html

Ahí viene explicaditas todas las apis necesarias, para mas detalle, MSDN  >:D

yo no lo recomiendo, ya que se deberia entender a la perfeccion el como y pq se usa cada instruccion.


como ya te dicen, esto mismo pasa en otros lenguajes. dependiendo del ide el codigo puede ser ligeramente diferente pero la base del lenguaje es el mismo por lo que lo primero es entender el lenguaje y despues no hay problema en entender un codigo en masm,tasm etc.  yo recomendaria no querer meterse ya en sockets y similares cuando aun no se saben cosas tan basicas como buscar un caracter en un buffer (que para un troyano seguramente lo necesitaras) o simplemente llevar un control de flujo correcto, esto es un ejemplo hay muchas cosas que aun no se han tocado.

SALTOS CONDICIONALES

En el esnasmblador no existe ninguna forma de ÍF, CASE, FOR ninguna estructura por lo tanto se usan brincos parecidos a la funcion GOTO pero solo si cumplen ciertas condiciones
La siguiente lista es INSTRUCCION--Traduccion--significado, recordando que el ASM son palabras tanto entendibles por el hombre como la maquina

JO: Jump if overflow. Salta si el flag de desbordamiento est a uno
JNO: Jump if not overflow. Salta si el flag de desbordamiento esta cero.
JC, JNAE, JB: Los tres sirven para lo mismo. Significan: Jump if Carry, Jump if Not Above or Equal y Jump if Below. Saltan por lo tanto si al haber una comparacion el flag de acarreo se pone a 1, es entonces equivalente a "<" en una operacion sin signo.
JNC, JAE, JNB: Otros tres que valen exactamente para lo mismo. Jump if not Carry, Jump if Above or Equal y Jump if Not Below. Saltan si al haber una comparacion el flag de acarreo vale 0, o sea, es equivelente al operador ">=".
JZ o JE: Jump if Zero o Jump if Equal. Salta si el flag de cero esta a 1, o sea, si las dos instrucciones comparadas son iguales.
JNZ o JNE: Jump if Not Zero o Jump if Not Equal. Salta si el flag de cero esta a 0, o sea, si las dos instrucciones comparadas no son iguales.
JBE o JNA: Jump if Below or Equal o Jump if Not Above. Saltaria si en resultado de la comparacion el primer miembro es menor o igual que el segundo ( <= )
JA o JNBE: Jump if Above o Jump if Not Below of Equal. Justo lo contrario que la anterior, salta si en el resultado de la comparacion el primer miembro es mayor al segundo.
JS: Jump if Sign. Salta si el flag de signo esta  a uno.
JNS: Jump if Not Sign. Salta si el flag de signo esta  a cero.
JP, JPE: Jump if Parity o Jump if Parity Even. Salta si el flag de paridad esta a uno.
JNP, JPO: Jump if Not Parity, Jump if Parity Odd. Salta si el flag de paridad esta a cero.
JL, JNGE: Jump if Less, Jump if Not Greater of Equal. Salta si en el resultado de la comparacion, el primer numero es inferior al segundo, pero con numeros con signo.
JGE, JNL: Jump if Greater or Equal, Jump if Not Less. Salta si en el resultado de la comparacion, el primer numero es mayor o igual que el segundo, pero con numeros con signo.
JLE, JNG: Jump if Lower or Equal, Jump if Not Greater. Salta si en el resultado de la comparacion, el primer numero es menor o igual que el segundo, pero con numeros con signo.
JG, JNLE: Jump if Greater, Jump if Not Lower or Equal. Salta si en el resultado de la comparacion, el primer numero es mayor que el segundo, para numeros con signo.

Estos son saltos condicionales que salen de una comparacion de la forma
CMP parametro 1, parametro 2

Si solo quieren saltar se escribe:
JMP direccion
Esto se aplica a los condicionales
fuente:http://invisiblehack.mforos.com

Aunque quiero aprender, se me hace muy complicado! :S

Entonces de verdad no quieres aprender por que si quisieras te esforsarias.
s4lu2!

veo que lo que dice tu firma es verdad XD

yo soy capaz de pasar horas explicando una cosa si la persona de verdad quiere aprender.
s4lu2!

lo tendré en cuenta ;-)

Muy weno E0N, quizás te ponga en apuros por revivir este taller, pero te animo a que continúes  :D

Os dejo unas tablas de referencias muy útiles.
http://www.megaupload.com/es/?d=ZJ3AC8FK

Na hombre, tengo pensado continuarlo, solo q estoy estudiando pa los examenes y no tengo mucho tiempo, cuando sake un rato escribo algo sobre como usar apis y ya acabo el taller :P

Salu2

Esta perfecto e0n, espero la segunda parte :D
Te quedará un buen taller.

salu2

!! Buenisimo xdd...!! :D

saludos