#include <windows.h>
#include <stdio.h>
 
int main()
{
 
	__asm{
 
		xor eax, eax
		mov eax, fs:[0x30]
		mov eax, [eax+0x0C]
		mov eax, [eax+0x1C]
		mov eax, [eax]
		mov eax, [eax+0x08]
		mov ebx, eax
		add ebx, [eax + 0x3C]
		cmp ebx, 'PE'
		je	bien
 
 
	}
	bien:
	MessageBox(0, "bien hecho", "mensaje", 0 );
	getchar();
 
}

if(argc > 2){
 
char *hst, *file, *dire;
char datos[512];
char buffer[1024];
hst = argv[1];
file = argv[2];
dire = argv[3];
 
int sock;
int i = 0;
int bytes = 0;
int dbytes;
 
memset(buffer, 0, 1024);
 
struct sockaddr_in cox;
struct hostent *ht;
 
sprintf(datos, "GET %s HTTP/1.1\nHost: %s\nUser-Agent: Mozilla/4.0\n\n", file, hst);
 
sock = socket(AF_INET, SOCK_STREAM, 0);
 
ht = gethostbyname(hst);
 
cox.sin_family = AF_INET;
cox.sin_port = htons(80);
cox.sin_addr = *((struct in_addr*)ht->h_addr);
memset(&cox.sin_zero, 0, 8);
 
connect(sock, (struct sockaddr*)&cox, sizeof(struct sockaddr));
 
FILE *fp = fopen(dire, "wb");
 
send(sock, datos, strlen(datos), 0);
 
for(;;){
 
recv(sock, buffer + i, 1, 0);
i++;
if(strncmp(buffer+i-4, "\r\n\r\n", 4) == 0){
break;
}
}
for(;;){
 
memset(buffer,0,1024);
bytes = recv(sock, buffer, 1024, 0);
dbytes += bytes;
printf("%d KB\n", dbytes/1024);
fwrite(buffer, sizeof(char), bytes ,fp);
if(bytes <= 0){
break;
}
}
printf("Bytes: %d\n", dbytes);
fclose(fp);
close(sock);
}
}
 

api_call:
  pushad     ;registros a pila
  mov ebp, esp
  xor edx, edx
  mov edx, [fs:edx+48] ;puntero a PEB
  mov edx, [edx+12]    ;puntero a LDR
  mov edx, [edx+20]    ;puntero al primer modulo de la lista de InMemoryOrder
 
 
next_mod:
  mov esi, [edx+40]    ;puntero al nombre de los modulos
  movzx ecx, word [edx+38] ;logitud a verficar
  xor edi, edi
 
 

loop_modname:
  xor eax, eax
  lodsb
  cmp al, 'a'        ;el nombre del modulo esta en minuscula
  jl not_lowercase   ;lo pasamos
  sub al, 0x20       ;a mayuscula   
 
not_lowercase:
  ror edi, 13        ;rotamos hacia la derecha
  add edi, eax       ;el valor del hash
  loop loop_modname  ;hasta ecx=0

push edx           ;Posicion
  push edi           ;y hash del modulo actual a pila
  mov edx, [edx+16]  ;direccion base del modulo a edx
  mov eax, [edx+60]  ;cabecera PE a eax
  add eax, edx
  mov eax, [eax+120] ;EAT a eax
  test eax, eax      ;hay EAT?
  jz get_next_mod1   ;no, siguiente modulo
  add eax, edx
  push eax           ;EAT del modulo a pila
  mov ecx, [eax+24]  ;numero de funciones del modulo a ecx
  mov ebx, [eax+32]  ;RVA de las funciones a ebx
  add ebx, edx          

 push edx           ;Posicion
  push edi           ;y hash del modulo actual a pila

mov edx, [edx+16]  ;direccion base del modulo a edx

mov eax, [edx+60]  ;cabecera PE a eax
  add eax, edx
  mov eax, [eax+120] ;EAT a eax
  test eax, eax      ;hay EAT?
  jz get_next_mod1   ;no, siguiente modulo

get_next_mod1:
  pop edi         ;hash del siguiente modulo a eax
  pop edx         ;posicion donde quedamos en la lista de modulos a edx
  mov edx, [edx]  ;puntero al siguiente modulo
  jmp short next_mod

add eax, edx
  push eax           ;EAT del modulo a pila
  mov ecx, [eax+24]  ;numero de funciones del modulo a ecx
  mov ebx, [eax+32]  ;RVA de las funciones a ebx
  add ebx, edx     
 
 

get_next_func:
  jecxz get_next_mod ;si no quedan mas funciones, vamos con el siguiente modulo
  dec ecx            ;numero de la funcion - 1
  mov esi, [ebx+ecx*4]  ;RVA de la funcion a esi
  add esi, edx
  xor edi, edi 

loop_funcname:
  xor eax, eax
  lodsb           ;byte por byte del nombre de la funcion en ASCII
  ror edi, 13     ;buscamos
  add edi, eax    ;el caracter
  cmp al, ah      ;nulo que indica el final de la cadena
  jne loop_funcname ;hasta tener el hash completo de la funcion
  add edi, [ebp-8]  ;edi=hash del modulo+hash de la funcion
  cmp edi, [ebp+36] ;es la que buscamos?
  jnz get_next_func ;no, sigamos con la siguiente funcion    
 
  pop eax           ;EAT del modulo a eax
  mov ebx, [eax+36] ;conseguimos RVA
  add ebx, edx      ;le a?adimos la direccion base del modulo
  mov cx, [ebx+2*ecx]
  mov ebx, [eax+28]  ;RVA de la funciones a ebx
  add ebx, edx       ;le a?adimos la direccion base del modulo
  mov eax, [ebx+4*ecx] ;RVA de la funcion que queremos a eax
  add eax, edx       ;le a?adimos la direccion base del modulo y listo, en eax   
 
finish:
  mov [esp+36], eax ;viene un popad asiq salvamos eax, escribiendolo sobre el valor 

loop_funcname:
  xor eax, eax
  lodsb           ;byte por byte del nombre de la funcion en ASCII
  ror edi, 13     ;buscamos
  add edi, eax    ;el caracter
  cmp al, ah      ;nulo que indica el final de la cadena
  jne loop_funcname ;hasta tener el hash completo de la funcion

add edi, [ebp-8]  ;edi=hash del modulo+hash de la funcion
  cmp edi, [ebp+36] ;es la que buscamos?
  jnz get_next_func ;no, sigamos con la siguiente funcion    
 
 

pop eax           ;EAT del modulo a eax
  mov ebx, [eax+36] ;conseguimos RVA
  add ebx, edx      ;le a?adimos la direccion base del modulo
  mov cx, [ebx+2*ecx]
  mov ebx, [eax+28]  ;RVA de la funciones a ebx
  add ebx, edx       ;le a?adimos la direccion base del modulo
  mov eax, [ebx+4*ecx] ;RVA de la funcion que queremos a eax
  add eax, edx       ;le a?adimos la direccion base del modulo y listo, en eax 
 

finish:
  mov [esp+36], eax ;viene un popad asiq salvamos eax, escribiendolo sobre el valor 

[BITS 32]
[ORG 0]
 
  cld                    // clear the direction flag
  call start             // call start, this pushes the address of 'api_call' onto the stack
delta:
  %include "./x86_api_call.asm"
start:
  pop ebp                // pop off the address of 'api_call' for calling later
 
  push byte +1           // push the command show parameter
  lea eax, [ebp+command-delta] // calculate an address to the command line
  push eax               // push the command line parameter
  push 0x876F8B31        // push the hash value for WinExec
  call ebp               // kernel32.dll!WinExec( &command, SW_NORMAL )
 
  push byte 0            // push the desired exit code parameter
  push 0x56A2B5F0        // push the hash value for ExitProcess
  call ebp               // call kernel32.dll!ExitProcess( 0 )
 
command:
  db "calc.exe", 0
 

DWORD Kerbel;
 
	__asm{
 
		xor eax, eax
		mov eax, fs:[0x30]
		mov eax, [eax+0x0C]
		mov eax, [eax+0x1C]
		mov eax, [eax]
		mov eax, [eax+0x08]
		mov Kerbel, eax
 
	}
 
	printf("PEB asm: %8X", Kerbel );

format PE GUI 4.0
 
include 'C:\fasm\include\win32ax.inc'
 
push MB_YESNO
push mensaje
push captio
push 0
call [MessageBoxA]
cmp eax, IDYES
jne exit
jmp gracias
 
gracias:
 
push MB_OK
push mensaj
push capt
push 0
call [MessageBoxA]
jmp exit
 
exit:
 
push 0
push [ExitProcess]
 
mensaje db 'mensaje', 0
captio db 'exito!!', 0
mensaj db 'mensaje', 0
capt db 'XD', 0
 
 
data import
 
library kernel32, 'KERNEL32.DLL', user32, 'USER32.DLL'
import user32, MessageBoxA, 'MessageBoxA'
import kernel32, ExitProcess, 'ExitProcess'
 
end data                                

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
 
typedef int (CALLBACK *MSBX)(HWND, LPCTSTR, LPCTSTR, UINT); 
 
int main(int *argv, char *argc){
 
	HMODULE han;
	MSBX msgbox;
 
	han = LoadLibrary(L"User32.dll");
	msgbox = (MSBX)GetProcAddress(han, "MessageBoxA");
 
	msgbox(NULL,"mensaje","exito!!", NULL);
 
}

han = LoadLibrary(L"User32.dll");

han = LoadLibrary(L"User32.dll");

msgbox(NULL,"mensaje","exito!!", NULL);