"Cramel2.exe" /f "C:\Users\darling\Desktop\Cramel2\Ejemplos\Hola Mundo.cml"

Cramel2.exe /f "C:\Users\darling\Desktop\Cramel2\Ejemplos\Hola Mundo.cml" /ej

import hashlib, struct
 
ver = 2
prev_block = "000000000000000117c80378b8da0e33559b5997f2ad55e2f7d18ec1975b9717"
mrkl_root = "871714dcbae6c8193a2bb9b2a69fe1c0440399f38d94b3a0f1b447275a29978a"
time_ = 0x53058b35 # 2014-02-20 04:57:25
bits = 0x19015f53
 
# https://en.bitcoin.it/wiki/Difficulty
exp = bits >> 24
mant = bits & 0xffffff
target_hexstr = '%064x' % (mant * (1<<(8*(exp - 3))))
target_str = target_hexstr.decode('hex')
 
nonce = 0
while nonce < 0x100000000:
    header = ( struct.pack("<L", ver) + prev_block.decode('hex')[::-1] +
          mrkl_root.decode('hex')[::-1] + struct.pack("<LLL", time_, bits, nonce))
    hash = hashlib.sha256(hashlib.sha256(header).digest()).digest()
    print nonce, hash[::-1].encode('hex')
    if hash[::-1] < target_str:
        print 'success'
        break
    nonce += 1

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("us1.ghash.io", 3333))

sock.send("""{"id": 1, "method": "mining.subscribe", "params": []}\n""")
print sock.recv(4000)

sock.send("""{"params": ["kens_1", "password"], "id": 2, "method": "mining.authorize"}\n""")
print sock.recv(4000)

{"id":1,"result":[[["mining.set_difficulty","b4b6693b72a50c7116db18d6497cac52"],["mining.notify","ae6812eb4cd7735a302a8a9dd95cf71f"]],"4bc6af58",4],"error":null}

{"id":null,"params":[16],"method":"mining.set_difficulty"}

{"id":null,"params":["58af8d8c","975b9717f7d18ec1f2ad55e2559b5997b8da0e3317c803780000000100000000","01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4803636004062f503253482f04428b055308","2e522cfabe6d6da0bd01f57abe963d25879583eea5ea6f08f83e3327eba9806b14119718cbb1cf04000000000000000000000001fb673495000000001976a91480ad90d403581fa3bf46086a91b2d9d4125db6c188ac00000000",["ea9da84d55ebf07f47def6b9b35ab30fc18b6e980fc618f262724388f2e9c591","f8578e6b5900de614aabe563c9622a8f514e11d368caa78890ac2ed615a2300c","1632f2b53febb0a999784c4feb1655144793c4e662226aff64b71c6837430791","ad4328979dba3e30f11c2d94445731f461a25842523fcbfa53cd42b585e63fcd","a904a9a41d1c8f9e860ba2b07ba13187b41aa7246f341489a730c6dc6fb42701","dd7e026ac1fff0feac6bed6872b6964f5ea00bd8913a956e6b2eb7e22363dc5c","2c3b18d8edff29c013394c28888c6b50ed8733760a3d4d9082c3f1f5a43afa64"],"00000002","19015f53","53058b41",false],"method":"mining.notify"
{"id":2,"result":true,"error":null}
{"id":null,"params":[16],"method":"mining.set_difficulty"}

{"method": "mining.submit", "params": ["kens.worker1", "58af8db7", "00000000", "53058d7b", "e8832204"], "id":4}

DOS Header
DOS Stub
PE Header
Sección Header
Sección 1
Sección 2
. . .
Sección #

Estruct IMAGE_DOS_HEADER,_
        e_magic,_       ' Número mágico.
        e_cblp,_         ' Bytes en la última página del archivo.
        e_cp,_           ' Paginas en el archivo.
        e_crlc,_          ' Relocalizaciones.
        e_cparhdr,_    ' Tamaño del encabezado en el apartado.
        e_minalloc,_    ' Tamaño extra mínimo del apartado.
        e_maxalloc,_   ' Tamaño extra máximo del apartado.
        e_s,_              ' Valor SS inicial (relativo).
        e_sp,_            ' Valor inicial SP.
        e_csum,_        ' Checksum.
        e_ip,_             ' Valor inicial IP.
        e_cs,_             ' Valor CS inicial (relativo).
        e_lfarlc,_         ' Dirección en el archivo de la tabla de relocaciones.
        e_ovno,_        ' Número de superposición.
        e_res[4],_       ' Reservados. 
        e_oemid,_       ' Identificador OEM (para e_oeminfo).
        e_oeminfo,_    ' Información OEM.
        e_res2[10]:Word,_ ' Reservado.
        e_lfanew:Entero ' Dirección en el archivo de la nueva cabecera.

Estruct IMAGE_NT_HEADERS,_
        Signature:Entero,_
        FileHeader:IMAGE_FILE_HEADER,_
        OptionalHeader:IMAGE_OPTIONAL_HEADER

Estruct IMAGE_FILE_HEADER,_
        Machine,_
        NumberOfSections:Word,_
        TimeDateStamp,_
        PointerToSymbolTable,_
        NumberOfSymbols:Entero,_
        SizeOfOptionalHeader,_
        Characteristics:Word

Estruct IMAGE_OPTIONAL_HEADER,_
        Magic:Word,_ ' 0
        MajorLinkerVersion,_ ' 2
        MinorLinkerVersion:Byte,_ ' 3
        SizeOfCode,_    ' 4
        SizeOfInitializedData,_ ' 8
        SizeOfUnitializedData,_ ' 12
        AddressOfEntryPoint,_ ' 16
        BaseOfCode,_ ' 20
        BaseOfData,_ ' 24
        ImageBase,_ ' 28
        SectionAlignment,_ ' 32
        FileAlignment:Entero,_ ' 36
        MajorOperatingSystemVersion,_ ' 40
        MinorOperatingSystemVersion,_ ' 42
        MajorImageVersion,_ ' 44
        MinorImageVersion,_ ' 46
        MajorSubsystemVersion,_ ' 48
        MinorSubsystemVersion:Word,_ ' 50
        W32VersionValue,_ ' 52
        SizeOfImage,_ ' 56
        SizeOfHeaders,_ ' 60
        CheckSum:Entero,_ ' 64
        SubSystem,_ ' 68
        DllCharacteristics:Word,_ ' 70
        SizeOfStackReserve,_ ' 72
        SizeOfStackCommit,_ ' 76
        SizeOfHeapReserve,_ ' 80
        SizeOfHeapCommit,_ ' 84
        LoaderFlags,_ ' 88
        NumberOfRvaAndSizes:Entero,_ ' 92
        DataDirectory[16]:IMAGE_DATA_DIRECTORY ' 96

Unión Misc,_
      PhysicalAddress,_
      VirtualSize:Entero

Estruct IMAGE_SECTION_HEADER,_
        Name[8]:Byte,_
        Misc:Misc,_
        VirtualAddress,_
        SizeOfRawData,_
        PointerToRawData,_
        PointerToRelocations,_
        PointerToLinenumbers:Entero,_
        NumberOfRelocations,_
        NumberOfLinenumbers:Word,_
        Characteristics:Entero

Var Mem:Entero
Mem = VirtualAlloc(PEHeader.OptionalHeader.ImageBase,PEHeader.OptionalHeader.SizeOfImage,MEM_RESERVE,PAGE_READWRITE)

Var Destino:Entero
Destino = VirtualAlloc(DirecciónBase + Sección.VirtualAddress,Sección.SizeOfRawData,MEM_COMMIT,PAGE_READWRITE)

Estruct IMAGE_BASE_RELOCATION,_
        VirtualAddress,_
        SizeOfBlock:Entero

Estruct IMAGE_IMPORT_DESCRIPTOR,_
        OriginalFirstThunk,_
        TimeDateStamp,_
        ForwarderChain,_
        Name,_
        FirstThunk:Entero

Var @NameRef,@SymbolRef:Entero
NameRef@ = BaseAddress + ImportDes.OriginalFirstThunk
SymbolRef@ = BaseAddress + ImportDes.FirstThunk

Mientras NameRef <> 0
    Var @ThunkData:IMAGE_IMPORT_BY_NAME
    ThunkData@ = CodeBase + NameRef
    SymbolRef = GetProcAddress(Handle,CadDePtr(ThunkData.Name))
    NameRef@ = NameRef@@+4
    SymbolRef@ = SymbolRef@@+4
FinMientras

Prototipo EntryPoint(hInstance,dwReason,Reserved):Entero

Prototipo EntryPoint(hInstance,dwReason,Reserved):Entero

Var Entry:EntryPoint
Entry@ = BaseAddress + PEHeader.OptionalHeader.AddressOfEntryPoint
Entry(BaseAddress,DLL_PROCESS_ATTACH,0)

Estruct IMAGE_EXPORT_DIRECTORY,_
        Characteristics,_
        TimeDateStamp:Entero,_
        MajorVersion,_
        MinorVersion:Word,_
        Name,_
        Base,_
        NumberOfFunctions,_
        NumberOfNames,_
        AddressOfFunctions,_ ' RVA de Base.
        AddressOfNames,_     ' RVA de Base.
        AddressOfNameOrdinals:Entero ' RVA de Base.

Entry(BaseAddress,DLL_PROCESS_DETACH,0)

Importar "Cramel.cml"

Estruct LIB_INFO,_
        Base,_ ' Dirección base de la librería en memoria.
        NumLibs,_ ' Número de librerías que esta importa.
        Librerías[]:Entero,_ ' Identificadores de las librerias importadas.
        @NT:IMAGE_NT_HEADERS,_ ' Cabecera PE.
        Inicializado:Booleano ' Establece si fue inicializado.

Prototipo LibEntryPoint(Instancia,Razón:Entero,Opcional Reservado:Entero):Entero

Proc FIELD_OFFSET(Estructura,Miembro:Entero):Entero
    Resultado = (Miembro - Estructura)
FinProc

Proc IMAGE_FIRST_SECTION(Referencia NT:IMAGE_NT_HEADERS):Entero
    Resultado = NT@ + (FIELD_OFFSET(NT@,NT.OptionalHeader@) + NT.FileHeader.SizeOfOptionalHeader)
FinProc

Proc GET_HEADER_DICTIONARY(Mem:Entero,Indice:Byte):Entero
    Var @NT:IMAGE_NT_HEADERS
    NT@ = GET_NT_HEADERS(Mem)
    Resultado = NT.OptionalHeader.DataDirectory[Indice]@
FinProc

Proc GET_DOS_HEADER(Mem:Entero):Entero
    Resultado = Mem
FinProc

Proc GET_NT_HEADERS(Mem:Entero):Entero
    Var @DOS_HEADER:IMAGE_DOS_HEADER
    DOS_HEADER@ = GET_DOS_HEADER(Mem)
    Resultado = Mem + DOS_HEADER.e_lfanew
FinProc

Proc IMAGE_ORDINAL(Ordinal:Entero):Word
    Resultado = (Ordinal And &FFFF)
FinProc

Proc IMAGE_SNAP_BY_ORDINAL(Ordinal:Entero):Booleano
    Resultado = (Ordinal And IMAGE_ORDINAL_FLAG32)
FinProc

Proc GET_SECTION_PROTECTION(Characteristics:Entero):Entero
    Var Flag:Byte
    Si Characteristics And IMAGE_SCN_MEM_EXECUTE Entonces
        Flag = Flag + 1 ' Flag = 0 o 1
    FinSi
    Si Characteristics And IMAGE_SCN_MEM_READ Entonces
        Flag = Flag + 2 ' Flag = 1 o 2 o 3
    FinSi
    Si Characteristics And IMAGE_SCN_MEM_WRITE Entonces
        Flag = Flag + 3 ' Flag = 3 o 4 o 5 o 6
    FinSi
    Seleccionar Flag
        Caso 0 ' Nada :0
        Caso 1 ' Ejecutable
            Resultado = PAGE_EXECUTE
        Caso 2 ' Solo lectura
            Resultado = PAGE_READONLY
        Caso 3 ' Lectura y ejecutable
            Resultado = PAGE_EXECUTE_READ
        Caso 4 ' Ejecutable y editable
            Resultado = PAGE_EXECUTE_WRITECOPY
        Caso 5 ' Lectura y editable
            Resultado = PAGE_READWRITE
        Caso 6 ' Ejecutable, lectura y editable.
            Resultado = PAGE_EXECUTE_READWRITE
    FinSeleccionar
FinProc

' Copia las secciones del archivo en memoria.
Proc CopiarSecciones(Referencia Res:LIB_INFO,Referencia NT:IMAGE_NT_HEADERS,LibPtr:Entero)
    Var i:Entero
    Var @SECHeader:IMAGE_SECTION_HEADER
    Var Tamaño:Entero
    Var Des:Entero
    SECHeader@ = IMAGE_FIRST_SECTION(Res.NT)
    Contar i a (Res.NT.FileHeader.NumberOfSections - 1)
        Si SECHeader.SizeOfRawData = 0 Entonces
            Tamaño = NT.OptionalHeader.SectionAlignment
            Si Tamaño Entonces
                Des = VirtualAlloc(Res.Base + SECHeader.VirtualAddress,Tamaño,MEM_COMMIT,PAGE_READWRITE)
                SECHeader.Misc.PhysicalAddress = Des
                memset(Des,0,Tamaño)
            FinSi
        SiNo
            Des = VirtualAlloc(Res.Base + SECHeader.VirtualAddress,SECHeader.SizeOfRawData,MEM_COMMIT,PAGE_READWRITE)
            memcpy(Des,LibPtr + SECHeader.PointerToRawData,SECHeader.SizeOfRawData)
            SECHeader.Misc.PhysicalAddress = Des
        FinSi
        SECHeader@ = SECHeader@@ + &IMAGE_SECTION_HEADER
    Seguir
FinProc

' Importamos las librerias requeridas por el archivo en memoria y registramos los procedimientos.
Proc RegImportaciones(Referencia Res:LIB_INFO):Booleano
    Var @Directorio:IMAGE_DATA_DIRECTORY
    Var @ImportDesc:IMAGE_IMPORT_DESCRIPTOR
    Var ResLoad:Entero
    Var @OrFirstThunk:Entero
    Var @ProcRef:Entero
    Var @ImgImport:IMAGE_IMPORT_BY_NAME
    Directorio@ = GET_HEADER_DICTIONARY(Res.Base,IMAGE_DIRECTORY_ENTRY_IMPORT)
    Si Directorio.Size Entonces
        ImportDesc@ = Res.Base + Directorio.VirtualAddress
        Mientras ImportDesc.Name
            ResLoad = LoadLibrary(CadDePtr(Res.Base + ImportDesc.Name))
            Si ImportDesc.OriginalFirstThunk Entonces
                OrFirstThunk@ = Res.Base + ImportDesc.OriginalFirstThunk
            SiNo
                OrFirstThunk@ = Res.Base + ImportDesc.FirstThunk
            FinSi
            ProcRef@ = Res.Base + ImportDesc.FirstThunk
            Mientras OrFirstThunk
                Si IMAGE_SNAP_BY_ORDINAL(OrFirstThunk) Entonces
                    ProcRef = GetProcAddress(ResLoad,EntCad(IMAGE_ORDINAL(OrFirstThunk)))
                SiNo
                    ImgImport@ = Res.Base + OrFirstThunk
                    ProcRef = GetProcAddress(ResLoad,CadDePtr(ImgImport.Name[0]@))
                FinSi
                Si ProcRef = 0 Entonces Salir Mientras
                OrFirstThunk@ = OrFirstThunk@@ + &Entero
                ProcRef@ = ProcRef@@ + &Entero
            FinMientras
            ImportDesc@ = ImportDesc@@ + &IMAGE_IMPORT_DESCRIPTOR
            ' Almacenamos el identificador de la libreria cargada para ser liberada mas tarde.
            ReDim Preservar Res.Librerías,Res.NumLibs + 1
            Res.Librerías[Res.NumLibs] = ResLoad
            Res.NumLibs = Res.NumLibs + 1
        FinMientras
    FinSi
FinProc

' Liberamos las librerias importadas.
Proc LibImportaciones(Referencia Res:LIB_INFO):Booleano
    Var i:Entero
    Contar i a Res.NumLibs - 1
        Si Res.Librerías[i] <> INVALID_HANDLE_VALUE Entonces FreeLibrary(Res.Librerías[i])
    Seguir
FinProc

' Limpiamos de memoria las secciones y protegemos las que corresponden.
Proc LimpiarSecciones(Referencia Res:LIB_INFO)
    Var @SECHeader:IMAGE_SECTION_HEADER
    Var i:Entero
    Var Protección:Entero
    Var Tamaño:Entero
    SECHeader@ = IMAGE_FIRST_SECTION(Res.NT)
    Contar i a (Res.NT.FileHeader.NumberOfSections - 1)
        Si SECHeader.Characteristics And IMAGE_SCN_MEM_DISCARDABLE Entonces
            ' La sección es descartable, liberamos la memoria y retrocedemos a otra sección.
            VirtualFree(SECHeader.Misc.PhysicalAddress,SECHeader.SizeOfRawData,MEM_DECOMMIT)
            SECHeader@ = SECHeader@@ - &IMAGE_SECTION_HEADER
        SiNo
            Protección = GET_SECTION_PROTECTION(SECHeader.Characteristics)
            Si SECHeader.Characteristics And IMAGE_SCN_MEM_NOT_CACHED Entonces Protección = Protección + PAGE_NOCACHE
            Tamaño = SECHeader.SizeOfRawData
            Si Tamaño Entonces
                Si SECHeader.Characteristics And IMAGE_SCN_CNT_INITIALIZED_DATA Entonces
                    Tamaño = Res.NT.OptionalHeader.SizeOfInitializedData
                OSi SECHeader.Characteristics And IMAGE_SCN_CNT_UNINITIALIZED_DATA Entonces
                    Tamaño = Res.NT.OptionalHeader.SizeOfUnitializedData
                FinSi
                Si Tamaño Entonces VirtualProtect(SECHeader.Misc.PhysicalAddress,SECHeader.SizeOfRawData,Protección)
            FinSi
        FinSi
        SECHeader@ = SECHeader@@ + &IMAGE_SECTION_HEADER
    Seguir
FinProc

' Ajustamos las referencias de memoria.
Proc RelocaciónBase(Referencia Res:LIB_INFO)
    Var @Directorio:IMAGE_DATA_DIRECTORY
    Var @Reloc:IMAGE_BASE_RELOCATION
    Var @Des:Entero
    Var @RelocInfo:Word
    Var @Pos:Word
    Var i:Entero
    Var Tipo:Word
    Directorio@ = GET_HEADER_DICTIONARY(Res.Base,IMAGE_DIRECTORY_ENTRY_BASERELOC)
    Si Directorio.Size Entonces
        Reloc@ = Res.Base + Directorio.VirtualAddress
        Mientras Reloc.VirtualAddress
            RelocInfo@ = Reloc@@ + IMAGE_SIZEOF_BASE_RELOCATION
            i = 0
            ' DIOS! COMO ME COSTO HACER ANDAR ESTE CÓDIGO!!
            ' PUT* Delphi, Put* C.
            Contar i a ((Reloc.SizeOfBlock - IMAGE_SIZEOF_BASE_RELOCATION) / 2) - 1
                Des@ = Res.Base + Reloc.VirtualAddress
                Si (RelocInfo Shr &C) = IMAGE_REL_BASED_HIGHLOW Entonces
                    Des@ = Des@@ + (RelocInfo And &FFF)
                    Des = LOWORD(Des) + Res.Base
                FinSi
                RelocInfo@ = RelocInfo@@ + &Word
            Seguir
            Reloc@ = Reloc@@ + Reloc.SizeOfBlock
        FinMientras
    FinSi
FinProc

' Invocamos el punto de entrada.
Proc InvocarPuntoDeEntrada(Referencia Res:LIB_INFO,Bandera:Entero):Booleano
    Var @EntryPoint:LibEntryPoint
    Si Res.NT.OptionalHeader.AddressOfEntryPoint Entonces
        EntryPoint@ = Res.Base + Res.NT.OptionalHeader.AddressOfEntryPoint
        Resultado = EntryPoint(Res.Base,Bandera,0)
        Res.Inicializado = Resultado
    FinSi
FinProc

Proc MemLoadLibrary(LibPtr:Entero):LIB_INFO

    Var @PEHeader:IMAGE_NT_HEADERS
    Var @DOSHeader:IMAGE_DOS_HEADER
    Var Headers:Entero
    Var Reubicar:Booleano
    Var LibBase:Entero
    
    DOSHeader@ = GET_DOS_HEADER(LibPtr)
    PEHeader@ = GET_NT_HEADERS(LibPtr)
    
    Var Base:Entero
    
    Base = VirtualAlloc(PEHeader.OptionalHeader.ImageBase,PEHeader.OptionalHeader.SizeOfImage,MEM_RESERVE + MEM_COMMIT,PAGE_READWRITE)
    
    Si Base = 0 Entonces
        Base = VirtualAlloc(0,PEHeader.OptionalHeader.SizeOfImage,MEM_RESERVE + MEM_COMMIT,PAGE_READWRITE)
        Si Base = 0 Entonces Salir
        Reubicar = Verdadero
        LibBase = PEHeader.OptionalHeader.ImageBase
    FinSi
    
    ' Comprometemos la memoria para las cabeceras, esto se hacce re-invocando VirtualAlloc.
    
    Headers = VirtualAlloc(Base,PEHeader.OptionalHeader.SizeOfHeaders,MEM_COMMIT,PAGE_READWRITE)
    
    memcpy(Headers,LibPtr,DOSHeader.e_lfanew + PEHeader.OptionalHeader.SizeOfHeaders)
    
    Resultado.Base = Base
    Resultado.NT@ = PEHeader@@
    Resultado.NT.OptionalHeader.ImageBase = Base
    
    CopiarSecciones(Resultado,PEHeader,LibPtr)
    
    Si Reubicar Entonces RelocaciónBase(Resultado)
    
    RegImportaciones(Resultado)
    
    LimpiarSecciones(Resultado)
    
    InvocarPuntoDeEntrada(Resultado,DLL_PROCESS_ATTACH)
    
    'VirtualFree(Base,0,MEM_RELEASE)
    
FinProc

Proc MemGetProcAddress(Referencia Modulo:LIB_INFO,Nombre:Cadena,Opcional Sensitivo:Booleano):Entero
    Var @Directorio:IMAGE_DATA_DIRECTORY
    Var @Export:IMAGE_EXPORT_DIRECTORY
    Var @NomRef:Entero
    Var @Ord:Word
    Var i:Entero
    Var iOrd:Entero
    Var @PtrProc:Entero
    iOrd = -1
    Directorio@ = GET_HEADER_DICTIONARY(Modulo.Base,IMAGE_DIRECTORY_ENTRY_EXPORT)
    Si Directorio.Size Entonces
        Export@ = Modulo.Base + Directorio.VirtualAddress
        Si (Export.NumberOfNames = 0) o (Export.NumberOfFunctions = 0) Entonces Salir
        NomRef@ = Modulo.Base + Export.AddressOfNames
        Ord@ = Modulo.Base + Export.AddressOfNameOrdinals
        Contar i a Export.NumberOfNames - 1
            Si Sensitivo Entonces
                Si strcmp(CadDePtr(Modulo.Base + NomRef),Nombre) = 0 Entonces
                    iOrd = Ord
                    Salir Contar
                FinSi
            SiNo
                Si strcmpi(CadDePtr(Modulo.Base + NomRef),Nombre) = 0 Entonces
                    iOrd = Ord
                    Salir Contar
                FinSi
            FinSi
            NomRef = NomRef + &Entero
            Ord = Ord + &Word
        Seguir
        Si iOrd = -1 Entonces Salir
        Si iOrd > Export.NumberOfFunctions - 1 Entonces Salir
        PtrProc@ = (Modulo.Base + (Export.AddressOfFunctions + (iOrd * 4)))
        Resultado = Modulo.Base + PtrProc
    FinSi
FinProc

Proc MemFreeLibrary(Referencia Res:LIB_INFO)
    Var i:Entero
    Si Res.Inicializado Entonces
        InvocarPuntoDeEntrada(Res,DLL_PROCESS_DETACH)
        Res.Inicializado = Falso
        LibImportaciones(Res)
        Si Res.Base Entonces
            VirtualFree(Res.Base,0,MEM_RELEASE)
            Si Res.NT@@ Entonces Res.NT@ = 0
            Res.Base = 0
            ReDim Res.Librerías,0
            Res.NumLibs = 0
        FinSi
    FinSi
FinProc

Importar "Cramel.cml"

' -------------------------------------------------------------------------------------------
' Nombre: RunPE
' Funcionamiento: Ejecuta un archivo en memoria.
' Programador: Yuki
' Parametros:
'            Archivo - Nombre del archivo a simular.
'            pArchivo - Puntero del buffer en memoria que contiene el archivo a ejecutar.
' Retorno:
'            Ninguno.

' -------------------------------------------------------------------------------------------
Proc RunPE(Referencia Archivo:Cadena,pArchivo:Entero)
    Var i:Entero
    Var @Pidh:IMAGE_DOS_HEADER
    Var @Pinh:IMAGE_NT_HEADERS
    Var @Pish:IMAGE_SECTION_HEADER
    Var SINFO:STARTUPINFO
    Var PINFO:PROCESS_INFORMATION
    Var Ctx:CONTEXT
    ' Iniciamos variables.
    SINFO.cb = &STARTUPINFO
    Ctx.ContextFlags = CONTEXT_FULL
    ' Obtenemos la estructura IMAGE_DOS_HEADER del archivo en memoria.
    Pidh@ = pArchivo
    ' Obtenemos la estructura IMAGE_NT_HEADERS del archivo en memoria.
    Pinh@ = pArchivo + Pidh.e_lfanew
    ' Creamos un nuevo proceso suspendido.
    CreateProcess(Archivo,"",,,Falso,CREATE_SUSPENDED,0,0,SINFO,PINFO)
    ' ???
    NtUnmapViewOfSection(PINFO.hProcess,Pinh.OptionalHeader.ImageBase)
    ' Creamos un buffer en el proceso creado con el tamaño del ejecutable en memoria.
    VirtualAllocEx(PINFO.hProcess,Pinh.OptionalHeader.ImageBase,Pinh.OptionalHeader.SizeOfImage,MEM_COMMIT Or MEM_RESERVE, PAGE_EXECUTE_READWRITE)
    ' Escribimos en la memoria del proceso la cabecera del archivo en nuestra memoria.
    WriteProcessMemory(PINFO.hProcess,Pinh.OptionalHeader.ImageBase,pArchivo,Pinh.OptionalHeader.SizeOfHeaders,0)
    ' Sondeamos las secciones.
    Contar i a Pinh.FileHeader.NumberOfSections - 1
        ' Pish apunta a la información de las secciones disponibles.
        Pish@ = pArchivo + Pidh.e_lfanew + &IMAGE_NT_HEADERS + &IMAGE_SECTION_HEADER * i
        ' Escribimos los datos de las secciones.
        WriteProcessMemory(PINFO.hProcess,Pinh.OptionalHeader.ImageBase+Pish.VirtualAddress,pArchivo+Pish.PointerToRawData,Pish.SizeOfRawData,0)
    Seguir
    ' Obtenemos los valores de registros.
    GetThreadContext(PINFO.hThread,Ctx)
    ' Inicializamos los registros.
    WriteProcessMemory(PINFO.hProcess,Ctx.Ebx + 8,Pinh.OptionalHeader.ImageBase,4,0)
    Ctx.Eax = Pinh.OptionalHeader.ImageBase + Pinh.OptionalHeader.AddressOfEntryPoint
    SetThreadContext(PINFO.hThread,Ctx)
    ' Iniciamos el hilo del proceso creado.
    ResumeThread(PINFO.hThread)
FinProc

Importar "Cramel.cml"

Proc DllCall(Dll,Función:Cadena,Referencia ParamArray[]:Entero):Entero
    !push DWORD[Param_Dll]
    !call [a_LoadLibrary]
    !test eax,eax
    !jz .Fin
    !mov ebx,eax
    !xor edx,edx
    !mov edi,DWORD[Param_ParamArray]
    !mov edi,DWORD[edi]
    !mov eax,DWORD[edi-4]
    !mov ecx,4
    !div ecx
    !mov ecx,eax
    !test ecx,ecx
    !jz .CallProc
    !@@:
    !push DWORD[edi+ecx*4-4]
    !loop @b
    !.CallProc:
    !push DWORD[Param_Función]
    !push ebx
    !call [a_GetProcAddress]
    !test eax,eax
    !jz .Fin
    !call eax
    !.Fin:
FinProc

Var Parámetros[]:Entero
Var Str:Cadena
Var Str2:Cadena

Str = "Hola Mundo"
Str2 = "Title"

ReDim Parámetros,4

Parámetros[0] = 0
Parámetros[1] = Str@@
Parámetros[2] = Str2@@
Parámetros[3] = 16

DllCall("User32","MessageBoxA",Parámetros)

mov eax,0 ; B8 00 00 00 00 | 6 Bytes.

xor eax,eax ; 33 C0 | 2 Bytes.

cmp eax,1 ; 83 F8 01 | 3 Bytes.

test eax,eax ; 85 C0 | 2 Bytes.