> For the complete documentation index, see [llms.txt](https://ne0b1t3.gitbook.io/vault/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ne0b1t3.gitbook.io/vault/prolabs/dante.md).

# Dante

## <mark style="color:$warning;">Certificado de Superación</mark>

<figure><img src="/files/9VernF0dZuAPnrsL44oQ" alt=""><figcaption></figcaption></figure>

Aunque Dante está considerada la Pro Lab más accesible de Hack The Box, personalmente me pareció una de las más útiles como preparación para entornos más grandes y complejos.&#x20;

No destaca por técnicas especialmente avanzadas ni por vulnerabilidades rebuscadas, sino que te obliga a desarrollar una **metodología sólida**, mantener una **buena organización** y aprender a **encadenar** correctamente la **información** obtenida durante la enumeración.

A lo largo de la Pro Lab hay una serie de habilidades con las que recomiendo sentirse cómodo antes de afrontarla.

***

### <mark style="color:$primary;">Enumeración Sistemática</mark>

La enumeración es, sin duda, la habilidad más importante de toda la Pro Lab ya que estaremos enfrentando infraestructura con docenas de usuarios, múltiples hosts (\~15 equipos), servicios, aplicaciones y redes segmentadas.&#x20;

<figure><img src="/files/Bw39ZbemREgXvEexE8Tr" alt="" width="263"><figcaption><p>Todos los equipos a comprometer</p></figcaption></figure>

Es necesario sentirse cómodo enumerando servicios, revisando configuraciones, analizando aplicaciones web y CMS, así como buscando información sensible almacenada en el sistema (ej. rutas esenciales como `/opt`, `/var`, `/etc`, etc)

También es frecuente realizar enumeración local, revisando usuarios, sus grupos y descripciones, servicios en ejecución, procesos activos, tareas programadas, hosts internos y cualquier tipo de configuración sensible que pueda dar una pista de escalada o movimiento lateral.

En entornos Windows, además, merece la pena prestar especial atención a software instalado fuera de lo habitual, especialmente aquel ubicado en rutas como `C:\Program Files`, `C:\ProgramData` o `C:\Users\<user>\AppData`, ya que muchos de los hallazgos interesantes provienen de aplicaciones añadidas por usuarios o administradores más que del propio sistema.

### <mark style="color:$primary;">Explotación Web</mark>

Las vulnerabilidades web presentes en Dante son relativamente comunes, por lo que conviene sentirse cómodo identificando y explotando escenarios como Local File Inclusion (LFI), Path Traversal, PHP Wrappers o SQL Injection.

<figure><img src="/files/EWOJqE2uNEQiwLaxRAF1" alt=""><figcaption><p>Local File Inclusion</p></figcaption></figure>

Además de explotar la vulnerabilidad en sí, es importante comprender qué información puede obtenerse posteriormente: credenciales almacenadas en archivos de configuración, información sensible de bases de datos o usuarios reutilizados en otros sistemas.

<figure><img src="/files/VfffWF8i534WbVDKScTm" alt=""><figcaption><p>SQL Injection</p></figcaption></figure>

***

### <mark style="color:$primary;">Reutilización de Credenciales</mark>

Probablemente la habilidad más importante de toda la Pro Lab.\
Una gran parte del movimiento lateral en Dante se basa en reutilizar información previamente obtenida.

Cada nueva credencial debe validarse inmediatamente contra todos los servicios identificados hasta el momento, incluyendo SSH, SMB, FTP, NFS, aplicaciones web y bases de datos.

Si no se obtiene acceso directo, resulta recomendable realizar password spraying contra el resto de usuarios descubiertos durante la enumeración, o generar wordlists personalizados, algo que fue necesario en algún que otro paso.

Durante esta Pro Lab terminé desarrollando un pequeño script en Python a modo de "vault" personal donde almacenaba usuarios, contraseñas, hosts, servicios, puertos, relaciones de confianza y reglas de firewall, además de notas de enumeración.

<figure><img src="/files/cBqYOGRlMnW2eKAX146d" alt=""><figcaption></figcaption></figure>

Comparto el pequeño script por aquí por si alguien quiere utilizarlo, modificarlo o inspirarse en él. Aun así, siempre recomiendo intentar crear vuestras propias herramientas. Aunque sean más simples, es una de las mejores formas de practicar lenguajes como Python, Bash, PowerShell, Rust o Go y entender realmente cómo funcionan las técnicas que utilizamos a diario.

{% code title="/usr/bin/vault" overflow="wrap" lineNumbers="true" expandable="true" %}

```python
#!/usr/bin/python3
import json
import os
import hashlib
from datetime import datetime

VAULT_FILE = "vault.json"

# ---------- NTLM HASH ----------
def ntlm_hash(password):
    return hashlib.new('md4', password.encode('utf-16le')).hexdigest()

# ---------- LOAD / SAVE ----------
def load_vault():
    if not os.path.exists(VAULT_FILE):
        return []
    with open(VAULT_FILE, "r") as f:
        return json.load(f)


def save_vault(data):
    with open(VAULT_FILE, "w") as f:
        json.dump(data, f, indent=4)

# ---------- TABLE RENDER ----------
def render_table(data):
    headers = ["ID", "Username", "Password", "Machine", "IP", "Hash", "Date"]

    # Calculate column widths
    col_widths = [len(h) for h in headers]

    rows = []
    for i, row in enumerate(data, 1):
        r = [
            str(i),
            row["username"],
            row["password"],
            row["machine"],
            row["ip"],
            row["hash"],
            row["date"]
        ]
        rows.append(r)
        for idx, val in enumerate(r):
            col_widths[idx] = max(col_widths[idx], len(str(val)))

    def separator():
        return "+" + "+".join("-" * (w + 2) for w in col_widths) + "+"

    def format_row(row):
        return "| " + " | ".join(str(val).ljust(w) for val, w in zip(row, col_widths)) + " |"

    print(separator())
    print(format_row(headers))
    print(separator())

    for r in rows:
        print(format_row(r))

    print(separator())

# ---------- DISPLAY ----------
def show_vault(data):
    os.system("cls" if os.name == "nt" else "clear")

    print(r"""
██╗   ██╗ █████╗ ██╗   ██╗██╗  ████████╗     ██████╗██████╗ ███████╗██████╗ ███████╗
██║   ██║██╔══██╗██║   ██║██║  ╚══██╔══╝    ██╔════╝██╔══██╗██╔════╝██╔══██╗██╔════╝
██║   ██║███████║██║   ██║██║     ██║       ██║     ██████╔╝█████╗  ██║  ██║███████╗
╚██╗ ██╔╝██╔══██║██║   ██║██║     ██║       ██║     ██╔══██╗██╔══╝  ██║  ██║╚════██║
 ╚████╔╝ ██║  ██║╚██████╔╝███████╗██║       ╚██████╗██║  ██║███████╗██████╔╝███████║
  ╚═══╝  ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝        ╚═════╝╚═╝  ╚═╝╚══════╝╚═════╝ ╚══════╝

        by Ne0Byte

----------------------------------------------------------------------
""")

    print("[+] Stored Credentials:\n")
    if data:
        render_table(data)
    else:
        print("(empty)")

    print("\nCommands:")
    print("1 - New Creds --continue-on-success --no-bruteforce")
    print("2 - Exit")
    print("3 - Edit Creds")
    print("5 - Reset Vault")

# ---------- ADD CREDS ----------
def add_creds(data):
    print("\n[+] Enter new credentials")

    username = input("Username: ")

    hash_value = input("NTLM Hash (leave empty if unknown): ")
    password = input("Password (leave empty if unknown): ")

    if password and not hash_value:
        hash_value = ntlm_hash(password)

    machine = input("Machine: ")
    ip = input("IP: ")

    date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    entry = {
        "username": username,
        "password": password,
        "machine": machine,
        "ip": ip,
        "hash": hash_value,
        "date": date
    }

    data.append(entry)
    save_vault(data)

    # --- append files ---
    with open("users.txt", "a") as f:
        f.write(username + "\n")

    with open("passwords.txt", "a") as f:
        f.write(password + "\n")

    with open("hashes.txt", "a") as f:
        f.write(hash_value + "\n")

# ---------- EDIT -----------
def edit_creds(data):
    if not data:
        print("[-] Vault empty")
        input("Press Enter...")
        return

    render_table(data)

    try:
        idx = int(input("\nSelect ID to edit: ")) - 1
    except ValueError:
        print("Invalid ID")
        return

    if idx < 0 or idx >= len(data):
        print("ID out of range")
        return

    entry = data[idx]

    print("\n[+] Editing entry (leave empty to keep current value)\n")

    username = input(f"Username [{entry['username']}]: ") or entry["username"]

    hash_value = input(f"NTLM Hash [{entry['hash']}]: ") or entry["hash"]
    password = input(f"Password [{entry['password']}]: ") or entry["password"]

    # regenerate hash if password changed and hash missing/old empty
    if password and not hash_value:
        hash_value = ntlm_hash(password)

    machine = input(f"Machine [{entry['machine']}]: ") or entry["machine"]
    ip = input(f"IP [{entry['ip']}]: ") or entry["ip"]

    entry.update({
        "username": username,
        "password": password,
        "machine": machine,
        "ip": ip,
        "hash": hash_value,
        "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    })

    save_vault(data)

    print("\n[+] Entry updated")
    input("Press Enter...")

# ---------- RESET ----------
def reset_vault():
    confirm = input("Are you sure? (y/n): ")
    if confirm.lower() == "y":
        save_vault([])
        print("[!] Vault reset!")

# ---------- MAIN ----------
def main():
    data = load_vault()

    while True:
        show_vault(data)
        choice = input("\nSelect option: ")

        if choice == "1":
            add_creds(data)
        elif choice == "2":
            break
        elif choice == "3":
            edit_creds(data)
        elif choice == "5":
            reset_vault()
            data = []
        else:
            print("Invalid option")

if __name__ == "__main__":
    main()
```

{% endcode %}

Puede parecer algo trivial, pero cuando empiezas a gestionar más de una decena de sistemas, usuarios y múltiples segmentos de red, la organización deja de ser una ventaja para convertirse en una necesidad.

### <mark style="color:$primary;">Escalada de Privilegios</mark>

A nivel de escalada de privilegios, conviene sentirse cómodo enumerando privilegios del usuario actual (`sudo -l`), cron jobs, procesos ejecutados por usuarios privilegiados, servicios personalizados y permisos inseguros.

{% tabs %}
{% tab title="Linux" %}
En Linux aparecen técnicas como **library hijacking** o **Python module hijacking**, además de binarios con **configuraciones o permisos inseguras** o **tareas programadas** ejecutadas como usuario privilegiado (generalmente root)
{% endtab %}

{% tab title="Windows" %}
En Windows no hay prácticamente contenido relacionado con Active Directory, pero sí varias **escaladas de privilegios locales**. \
Conviene sentirse cómodo enumerando servicios **SMB/MSSQL**, tareas programadas, permisos inseguros, **Unquoted Service Paths** y otras vulnerabilidades famosas de Windows.
{% endtab %}
{% endtabs %}

Muchas veces la diferencia entre obtener acceso administrativo o quedarse atascado reside únicamente en identificar correctamente qué procesos se ejecutan de forma periódica y bajo qué contexto.

***

### <mark style="color:$primary;">Post-Explotación</mark>

Una vez comprometido un sistema, es importante ir más allá de la obtención de una shell.\
Algunas tareas que realicé constantemente durante la Pro Lab fueron el escape de restricted shells, el uso de [GTFOBins](https://gtfobins.org/), la persistencia mediante claves SSH, la revisión de historiales y configuraciones, la enumeración de usuarios locales y la extracción de hashes desde `/etc/shadow` para su posterior crackeo.

<figure><img src="/files/JcB00PgCyZPrVmq7K86y" alt=""><figcaption><p>GTF Obins - Lista de ejecutables Unix para bypassear restricciones de seguridad locales</p></figcaption></figure>

En el caso de Windows, también era necesario saber dumpear SAM, LSASS o NTDS, así como credenciales almacenadas en tareas programadas.

La persistencia mediante claves SSH merece una mención especial. \
En entornos donde dependemos continuamente de túneles y pivots, perder una sesión puede obligarnos a reconstruir una cadena completa de acceso. No fue mi caso ya que operaba con Ligolo pero conozco de muchas experiencias donde si les fue más dificil al pivotar con socat y chisel.

### <mark style="color:$primary;">Movimiento Lateral</mark>

Una habilidad extremadamente infravalorada. Gran parte del movimiento lateral en Dante no proviene de vulnerabilidades complejas, sino de información descubierta durante la revisión de archivos aparentemente inocentes.

Mi recomendación es sencilla: **todo archivo que no parezca pertenecer al sistema operativo merece ser revisado**: Correos electrónicos, documentos internos, exports de aplicaciones, configuraciones personalizadas, scripts desarrollados por usuarios o aplicaciones instaladas manualmente suelen contener información mucho más valiosa que muchas vulnerabilidades.

Y aquí surge una pregunta habitual: <mark style="color:$primary;">**¿Cómo sé si un archivo es normal o no?**</mark>

La respuesta es simple: **experiencia**. Con el tiempo desarrollas la capacidad de diferenciar rápidamente qué pertenece al sistema operativo y qué ha sido añadido posteriormente por usuarios o administradores. Por eso siempre recomiendo resolver una gran cantidad de máquinas y **familiarizarse con la estructura habitual de Linux y Windows** antes de afrontar laboratorios de este tamaño.

***

### <mark style="color:$primary;">Topología Aproximada al Laboratorio</mark>

He de reconocer que las topologías de la infraestructura completa las creaba (en [Excalidraw](https://excalidraw.com/)) una vez finalizado cada Pro Lab, ya que en mi caso me organizaba lo suficientemente bien como para no depender de un esquema visual.

Sin embargo, conozco a varios compañeros y personas que las recomiendan y les han servido de gran apoyo, ya que suelen ser una forma muy útil de visualizar toda la infraestructura en tiempo real.

<figure><img src="/files/BMPKA0HAdWs8hPA8TWns" alt=""><figcaption><p>Infraestructura del Laboratorio</p></figcaption></figure>

***

### <mark style="color:$primary;">Herramientas Principales</mark>

Durante todas las Pro Labs terminé utilizando decenas de **herramientas distintas**, pero hay algunas que **aparecieron de forma recurrente** y con las que considero imprescindible **sentirse cómodo** antes de enfrentarse a entornos de este tamaño.

No es necesario dominar todas estas herramientas de memoria; lo importante es comprender qué problema resuelve cada una y cuándo utilizarla.

#### <mark style="color:$tint;">Tunelización y Pivoting</mark>

La herramienta que utilicé fue [Ligolo-ng](https://github.com/nicocha30/ligolo-ng). Personalmente me parece una de las mejores opciones actualmente para pivoting, ya que es sencilla de desplegar, muy estable y extremadamente cómoda de utilizar.

<figure><img src="/files/4pxEOdmVWy0zsuMj8qmP" alt=""><figcaption></figcaption></figure>

Su principal ventaja es que permite tunelizar todo el tráfico de red, haciendo que los hosts internos sean accesibles desde nuestra máquina atacante como si formaran parte de nuestra propia red local. Esto simplifica enormemente las tareas de enumeración, explotación y movimiento lateral.

Aun así, siempre es recomendable dominar alternativas, ya que no todos los entornos permiten usar Ligolo o binarios modernos. Entre ellas destacan el **port forwarding local**, el **dynamic port forwarding** (SOCKS), el **remote port forwarding**, **Chisel**, **Socat**, **Metasploit** con autoroute y socks proxy, o **FoxyProxy** para el acceso a aplicaciones web.

Estas opciones permiten construir cadenas de pivoting más manuales mediante **SOCKS** y **ProxyChains**, algo especialmente útil en entornos antiguos o muy restringidos.

#### <mark style="color:$tint;">Enumeración</mark>

La enumeración representa probablemente más del 70% del trabajo durante la Pro Lab. Las herramientas más utilizadas fueron:

{% code title="" overflow="wrap" lineNumbers="true" %}

```
Nmap
NetExec (NXC)
Showmount
SMBClient
SMBMap
Burp Suite
Curl/Wget
RpcClient
MSSQLClient
LinPEAS
WinPEAS
PowerUp
Pspy
Metasploit (local exploit suggester)
```

{% endcode %}

Más importante que conocer cada herramienta es entender qué información buscar y cómo relacionarla con el resto de hallazgos obtenidos.

#### <mark style="color:$tint;">Transferencia de archivos</mark>

La transferencia de herramientas y payloads es una tarea constante durante cualquier evaluación.

{% tabs %}
{% tab title="First Tab" %}
En Linux se utilizó principalmente **SCP** mediante SSH, **HTTP servers** con **Curl** o **Wget** y codificación en **Base64**.
{% endtab %}

{% tab title="Windows" %}
En Windows, en cambio, fueron comunes **SMB servers**, **HTTP servers** con **CertUtil**, **Invoke-WebRequest**, **PowerShell** y **Base64** mediante `System.Text.Encoding`.
{% endtab %}
{% endtabs %}

Tener varios métodos preparados resulta clave cuando existen restricciones de red o limitaciones en PowerShell (que no fueron el caso en esta ProLab)

#### <mark style="color:$tint;">Persistencia y Cracking</mark>

Aunque no fue el foco principal, herramientas como **Hashcat**, **John the Ripper**(john), **Hydra**, **NetExec** parar password spraying y **SSH-Keygen** y **Mimikatz** fueron recurrentes.

Hashcat y John permitían crackeo de hashes, mientras que Hydra y NetExec servían para validar reutilización de credenciales. \
SSH-Keygen, por su parte, fue especialmente útil para mantener persistencia mediante claves SSH, algo crítico en entornos con pivoting constante.

#### <mark style="color:$tint;">Explotación</mark>

A nivel de explotación no suelen aparecer vulnerabilidades especialmente complejas, pero sí es importante manejar herramientas como **SQLMap**, **WPScan**, **Metasploit** y **Burp Suite**.

No obstante, la mayoría de compromisos en Dante no provienen de herramientas automáticas, sino de una buena enumeración, correlación de información y reutilización de credenciales.

***

### <mark style="color:$primary;">Lección Aprendida</mark>

Personalmente, me sorprendió a bien la primera ProLab.

Nada en Dante es especialmente complejo de forma individual, sino que el verdadero reto reside en conectar correctamente cada pequeña pieza de información obtenida durante la enumeración:

> Una credencial conduce a un nuevo sistema. Ese sistema contiene un archivo interesante. Ese archivo revela una nueva contraseña. Esa contraseña proporciona acceso a otro servicio.\
> Y así sucesivamente.

Precisamente esa capacidad de encadenar pequeños hallazgos y convertirlos en una cadena de compromiso completa es una de las habilidades más importantes para afrontar Pro Labs más avanzadas como Zephyr, Offshore o RastaLabs.

Por esa razón, considero que la mayor lección fue practicar la organización. Tanto para completar Pro Labs como para desenvolverse eficazmente en entornos reales sin perder tiempo.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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://ne0b1t3.gitbook.io/vault/prolabs/dante.md?ask=<question>
```

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.