|
41
|
Seguridad Informática / Análisis y Diseño de Malware / Inyecciones de código en memoria
|
en: 6 Enero 2016, 23:26 pm
|
Inyecciones de código en memoria Conocimientos previos: -ASM -WinApi Contenido:1- ¿Qué es la inyección de código en memoria? 2- ¿Cómo realizarla? 2.1- Teoría 2.2 -Práctica 3- Ejemplos de inyecciones 4- Despedida 1- ¿Qué es la inyección de código en memoria?La inyección de código en memoria consiste en que otro proceso ejecute el código que nosotros queramos. 2- ¿Cómo realizarla?2.1 - TeoriaPara realizar la inyección lo que haremos será crear un espacio en el proceso donde queremos inyectar el código con la api VirtualAllocEx a continuación escribiremos nuestro código con WriteProcessMemory y finalmente lanzamos el hilo con CreateRemoteThread 2.2- PrácticaPara poner en práctica la teoría anterior vamos a inyectar nuestra funcion en el proceso del buscaminas y haremos que nuestra función haga un MessageBox: 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
Como se puede apreciar no es muy difícil pero si plantea un problema grande y es que nuestro ejecutable sabe en que dirección se encuentra la variable mMessageBoxA cuando compilamos pero al inyectar el código la dirección de la variable cambiara… y nuestra función fallara -_- para eso se usa la tecnica del Delta Offset para recalcular la dirección de las variables y que nuestro código se ejecute bien este en la dirección que este. Para entender que hace el delta Offset pinchar Aquí
3- Ejemplo de inyecciónes Un simple ejemplo que lanza la calculadora, se inyecta en su proceso cambia el nombre a la ventana y hace un MessageBox 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
4- Despedida Bueno, ya solo queda la despedida…. Jajaja pues eso que espero que les sea utíl el tuto, la barrera de lo que podais hacer con las inyecciones de código la poneis vosotros Saludos.
|
|
|
42
|
Programación / .NET (C#, VB.NET, ASP) / Email y C#.
|
en: 4 Enero 2016, 17:31 pm
|
Buenas, alguien sabe alguna manera de enviar un correo desde C#? He probado de la siguiente manera y no lo consigo, el servidor me responde que necesito una conexion segura. 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(); } } }
saludos.
|
|
|
44
|
Foros Generales / Foro Libre / Feliz navidad.
|
en: 21 Diciembre 2015, 09:01 am
|
Feliz Navidad a todos los usuarios de este gran foro. Que estos dias llenen las casas de alegría y felicidad y que intentemos este proximo año ser un poco mas buenos saludos!!
|
|
|
46
|
Seguridad Informática / Análisis y Diseño de Malware / El arte del API Hooking.
|
en: 12 Diciembre 2015, 21:18 pm
|
Bueno, en este texto voy a intentar explicar de que se trata el API hooking. Una descripción rapida de lo que es este metodo sería algo así: realizar un gancho a una función del sistema para poder modificar su retorno o bién sus parametros. ¿Que podemos hacer con este metodo?Pues de todo lo que se nos ocurra desde ocultar archivos, procesos, hasta espiar conversaciones de skype, bloquear llamadas al sistema de detecminados procesos, etc. ¿Que nociones debo tener para aplicar correctamente esta técnica?Se deberá tener nociones de ensamblador, ademas el ejemplo que aquí usare esta en FASM, además de saber manejar un poco Ollydbg. ¿En que consiste dicha técnica?Consiste en modificar los primeros bytes de la funcion que queremos hookear, en esos primeros bytes escribiremos un salto a nuestra funcion (Que emulara la función original pero con los parametros que nosotros queramos). Para modificar los primeros bytes de la API deberémos dar permisos de escritura y ejecución ya que si no no podremos escribir nuestro salto. Dicho todo esto pasemos al código y a aprender su funcionamiento. En este caso hookearemos la API MessageBoxA, para ello crearemos nuestro propio ejecutable: include 'win32ax.inc' .data msg1 db 'hola',0 .code start: invoke MessageBoxA,0,msg1,0,0 ret .end start
la salida del programa es la siguiente: Obtetivo: que nuestro programa cante lo que nosotros queramos. El primer paso será ver el inicio de la API desde el olly DBG para que cuando nosotros escribamos el salto no dejemos ninguna instruccion a medias (si dejamos alguna instruccion a medias nuestro programa petara) Asique abrimos OllyDbg y vemos que contiene el inicio de la API. A nosotros en realidad solo nos interesan los primero 5 bytes, que es lo que ocupa el salto (jmp + Direccion). En este caso nos viene perfecto ya que las 3 primeras instrucciones: mov edi, edi push ebp mov ebp, esp
Ocupan exactamente 5 bytes. Bien, copiamos esas 3 instrucciones y las guardamos en un archivo de texto para no olvidarlas, ya que nos harán falta mas adelante. Una vez hecho esto, lo que haremos será lo siguiente, obtendremos la dirección de MessageBoxA, y sobreescribiremos sus primeros bytes para que salte a nuestra función. 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
El texto esta comentado pero de igual forma puntualizaré algunas cosillas. 1- Para poder escribir sobre la API original es OBLIGATORIO dar derechos de escritura, en este ejemplo esto se hace con VirtualProtect2- Tendremos que calcular el salto relativo a nuestra función, como se ve claramente en el código 3- Llegados a este punto ya tenemos establecido el hook por lo que si probamos a ejecutar el programa de arriba no imprimira nada en pantalla, ya que hemos roto los primeros bytes de la API, es más, queda totalmente inutilizada llegados a este punto. Ahora tendremos que programar la funcion mMessageBox, para que cante lo que nosotros queramos. Algunos datos que tenemos que tener en cuenta es que los valores que se introdujeron en la pila sigue ahí, junto con la dirección de retorno de la función, nosotros tendremos que recuperar la funcion de retorno para que el programa siga su ejecución correctamente. Para aplicar esto debemos saber que, al realizar un call lo que hace el procesador es introducir en la pila la siguiente instruccion que se ejecutara cuando la función a la que llamamos retorne. Por eso lo que nosotros hacemos será recuperarla, introducir lo que nosotros queramos que cante la API, ejecutar los primeros bytes originales de la API y saltar a la dirección original de la API + 5 bytes (recordemos que en esos primeros 5 bytes esta el hook, por eso los emulamos desde nuestra funcion). Ahí va el código completo del hook comentado. 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
Ejecutamos nuestro programa y veremos que solo cantará lo que nosotros queramos. ¿Pero, como puedo hookear una función que esta en otro proceso?Estando en su mismo proceso, esto se puede conseguir inyectando nuestra DLL con el hook en el proceso o bién desde una inyección de código. Bueno pues de momento eso ha sido todo, lo he intentado explicar de manera simple y para que se entienda bien. Decir también que los ejemplos han sido desarrollados y probados en una máquina x64 con Windows 7. Cualquier duda o colsulta será respondida gustosamente. saludos!
|
|
|
47
|
Programación / Ingeniería Inversa / Problema con OllyDbg y ejecutables en FASM
|
en: 12 Diciembre 2015, 20:26 pm
|
Bueno pues el caso es que cuando cargo mi programa hecho en FASM para debuguearlo antes me carga una serie de instrucciones y unos SYSENTER que no los he programado yo y de hecho en ocasiones nisiquiera salen las instrucciones verdaderas que yo programe o ni aparecen alguien sabe algo? saludos.
|
|
|
48
|
Programación / Programación General / [RETO] Algoritmo de compresión
|
en: 17 Febrero 2015, 08:55 am
|
Bueno, pues como esta la cosa muy parada y viendo una interesante pregunta que han realizado hace poco ( esta), he pensado que se podría realizar un concurso en el que los usuarios tendrían que desarrollar un software de compresión/descompresión, en el que, el algoritmo que mas comprima los archivos gana. Reglas: -El código tiene que ser liberado. -No vale usar librerías de terceros. ¿Os animáis?
|
|
|
49
|
Sistemas Operativos / GNU/Linux / Donde se guarda la contraseña Wifi en Ubuntu.
|
en: 17 Febrero 2015, 08:38 am
|
Seguro que mas de uno se lo a preguntado, tienes que conectar algún otro aparato que no sea el PC al WIFI y no tienes a mano el router Bien, a mi me paso y por suerte encontré la solución. Se guarda en la siguiente ruta: /etc/Network Manager/system-connections/Dentro de ella aparecerán los archivos con los nombres de las redes a las que nos hemos conectado, basta con abrir el archivo de nuestra red y encontraremos toda su configuración e información. [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 Espero que a alguien le sirva. saludos!
|
|
|
50
|
Seguridad Informática / Análisis y Diseño de Malware / Hook API Calculando cantidad opcodes.
|
en: 5 Febrero 2015, 16:45 pm
|
Bueno este código lo tenía por ahí de hace un par de años, y al final lo voy a perder así que aquí os lo dejo por a alguien le sirve. ; 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
No recalcula todas las API pero si la gran mayoría. saludos.
|
|
|
|
|
|
|