Mensajes

Transformandolo a cadena, cada digito del numero en cuestion debe ser transformado a caracter (no olvides el cero terminador de cadena). Otra opcion es usar la libc (printf/sprintf por ejemplo).

En el primer codigo eso depende del contenido de ecx ... a lo que apunte y lo que haya en esa direccion.

El segundo parametro de write es un puntero asi que lo primero que le pasas es un puntero erroneo (ecx=2). En el segundo caso le pasas un puntero a una cadena que contiene un solo caracter, \n, es decir un salto de linea, si queres ver algo de texto usa una cadena como la que puse antes ...

Si, edx es el tercer parametro es decir: size_t count.

Si, lo ensamble y enlace (con as y ld) pero no hace nada, no funciona tal como esta, si pones lo que te dije si escribira eso en la consola.

[eax]

A grosso modo en Linux se pone en eax el numero del servicio y los siguientes parametros van en ebx, ecx, edx, esi, edi y ebp.

En /usr/include/asm/ unistd.h/unistd_32.h/unistd_64.h encontraras los numeros de los servicios.

1 es __NR_exit y el 0 que se le pasa como parametro en ebx es el valor de retorno del programa (http://linux.die.net/man/2/exit).

4 es __NR_write y el 1 que le pasas como primer parametro en ebx es STDOUT (salida por consola), el segundo parametro (ecx) deberia ser el puntero a la cadena y el tercer parametro (edx) el tamaño de la cadena.

http://linux.die.net/man/2/write


Un ejemplo funcional:

Código (asm) [Seleccionar] Expandir

movl $6, %edx
movl $msg, %ecx
movl    $1, %ebx        
movl    $4, %eax      
int     $0x80

;;resto del codigo
.data
msg:
.string "DAAAA\n"

[NO]

Esa NO es la manera correcta de hacerlo, es un hack.

Mejor usa la API de Windows.

[SizeOfStackReserve]

Por lo que veo el .STACK no tiene ningun efecto en el ejecutable final.

En la cabecera opcional del PE hay dos campos sobre la pila:
SizeOfStackReserve   Size of stack to reserve. Only the Stack Commit Size is committed; the rest is made available one page at a time, until reserve size is reached.
SizeOfStackCommit   Size of stack to commit.

http://download.microsoft.com/download/e/b/a/eba1050f-a31d-436b-9281-92cdfeae4b45/pecoff.doc

El enlazador (link.exe) se encarga de escribirlos, 0x100000 (1MB) y 0x1000 (4KB=una pagina) son sus valores por defecto. Con la opcion /STACK podes cambiarlos.

No necesitas un driver, en Windows ese lo escribe Microsoft o como mucho el fabricante del hardware. Los programas usan los servicios del S.O. en cuestion (Windows=CreateFile y amigos).

Ademas de ser menos potentes los sistemas de 16 bits son obsoletos, hoy en dia casi todo el mundo tiene maquinas de 64 bits y muchos ya S.O.s de 64 bits.

[Lo siguiente es un articulo/tutorial/lo que sea que escribi hace ya un poco mas de 5 años]

Tenes que hacer coincidir la convencion de llamada (stdcall, cdecl, etc.) en tu codigo y en la declaracion en el lenguaje de alto nivel. Podes enlazar a nivel de codigo objeto (.obj) y usar librerias estaticas (.lib de codigo)  o dinamicas (.dll y .lib de importacion).


Lo siguiente es un articulo/tutorial/lo que sea que escribi hace ya un poco mas de 5 años:



Bueno supongo que todos saben que la mayoria de los compiladores de C++ permiten incluir instrucciones de ensamblador dentro del codigo fuente y estas son ensambladas directamente en el codigo objeto. A esto se le llama inline assembler generalmente.

Pero eso no es siquiera interesante; lo que si es muy interesante es la capacidad de escribir librerias (estaticas y dinamicas) tanto en ensamblador como en C++ (MASM y VC++) y linkearlas en ambos lenguajes.

Osea, que por ejemplo podemos crear una libreria en ensamblador y linkearla estaticamente en un programa de C++. Vamos a ver el ejemplo.

Codigo de la libreria de ensamblador:

Código (asm) [Seleccionar] Expandir

.386
.model stdcall,flat

include windows.inc
include kernel32.inc
include user32.inc

includelib kernel32.lib
includelib user32.lib

CTEXT MACRO text:VARARG
LOCAL TxtName
.data
TxtName BYTE text,0
.code
EXITM <OFFSET TxtName>
ENDM

SayLong PROTO number:DWORD

.code

SayLong PROC number:DWORD
LOCAL pointer:DWORD
invoke GetProcessHeap
invoke HeapAlloc,eax,HEAP_ZERO_MEMORY or HEAP_GENERATE_EXCEPTIONS,1024
mov pointer,eax
invoke wsprintf,pointer,CTEXT("%d"),number
invoke MessageBox,0,pointer,pointer,0
invoke GetProcessHeap
invoke HeapFree,eax,0,pointer
ret
SayLong ENDP

End



Tranquilidad que ahora paso a explicar el codigo anterior.

.386 es una directiva que le indica a MASM que nuestro codigo va optimizado para la arquitectura 386

.model stdcall,flat es una directiva que le indica a MASM que nuestro codigo usa stdcall (convencion de funciones que utiliza la API de Windows) y un modelo de memoria plano (el unico posible en Windows).

Los includes justamente incluyen bibliotecas al estilo de los .H de C++, para conseguir estas bibliotecas hay que tener MASM32 MASM32 instalado y con el path configurado.

Los includelib nos ahorran pasarle en la linea de comandos parametros de librerias que vamos a linkear, tambien hay que tener el MASM32 o sino crearlas (eso lo dejamos para otro tutorial).

El macro CTEXT nos permite utilizar texto al modo de C++ usando CTEXT("TEXTO") cosa que no es posible directamente en ensamblador.

La funcion SayLong simplemente muestra un MessageBox con el numero que hayamos especificado como parametro.

Ustedes diran que carajo hacemos con este codigo, bueno aca esta la respuesta, ensamblamos y linkeamos con MASM:

ml /c /Cp /coff asm_called.asm
lib asm_called.obj

Con eso conseguimos el archivo asm_called.obj que es el codigo objeto y el archivo asm_called.lib que es el codigo ejecutable que vamos a linkear desde C++.

Ahora el codigo de C++ que llama a la funcion de ensamblador:

Código (cpp) [Seleccionar] Expandir

#include <windows.h>
extern "C" void __stdcall SayLong(DWORD number);

void main()
{
 SayLong(50);
}



Muy simple este codigo, muy simple. Declara la funcion externa SayLong con el paso de paremetros de stdcall (la misma que usamos en ensamblador). Y la llama desde un main con un parametro de 50.

Compilamos y linkeamos con VC++:

cl -c calling_asm.cpp
link calling_asm.obj asm_called.lib kernel32.lib user32.lib

Ahora obtenemos un archivo objeto calling_asm.obj y un archivo ejecutable calling_asm.exe.

Ejecuten el archivo calling_asm.exe y veran que aparece un MessageBox con el numero 50, la rutina SayLong (programa en ensamblador) fue llamada desde C++.

Espero que les haya gustado el tutorial y hayan aprendido algo nuevo.

Asi te decia:

Código (asm) [Seleccionar] Expandir

PostMessageX:
push ebp ; Trampolin
mov ebp, esp
jmp Salto; El resultado va hacia salto donde tenemos ya guardada nuestro handle del "PostMessage"

Lo unico es que vas a tener que usar push's + call's en lugar de stdcall.