Introducción
En los sistemas Linux, el comando sudo permite a los usuarios estándar ejecutar programas con los privilegios de seguridad de otro usuario, generalmente el administrador root. Los administradores de sistemas a menudo configuran el archivo /etc/sudoers para permitir que usuarios específicos ejecuten ciertos comandos como root sin necesidad de contraseña. Esto se hace habitualmente por conveniencia, por ejemplo, para permitir que un desarrollador reinicie un servidor web o busque archivos en todo el sistema.
La lección de seguridad aquí es que las reglas de sudo son, en realidad, confianza delegada. Si el binario delegado es más potente de lo que el administrador supone, la regla puede otorgar efectivamente una shell en lugar de solo una acción segura.
Sin embargo, estos atajos administrativos bienintencionados pueden introducir graves vulnerabilidades de seguridad. Si a un usuario se le permite ejecutar un binario que tiene la capacidad de ejecutar otros comandos o generar una shell (como find, vim o awk), un atacante puede abusar de este permiso para salir del comando restringido y obtener una shell de root completa. Esta técnica se conoce comúnmente como "escape de shell" o explotación "GTFOBins".
En este laboratorio, te pondrás en la piel de un auditor de seguridad. Enumerarás los permisos de sudo de tu usuario actual, identificarás un binario autorizado mal configurado y lo explotarás para escalar tus privilegios a root.
Comprobar permisos de Sudo (sudo -l)
En este paso, aprenderás a enumerar los privilegios de sudo asignados a tu cuenta de usuario actual.
Al evaluar un sistema Linux en busca de oportunidades de escalada de privilegios, una de las primeras comprobaciones es ver qué comandos puede ejecutar el usuario actual como root. El comando sudo proporciona una bandera integrada, -l (list), que muestra los comandos permitidos y prohibidos para el usuario que invoca.
Esta es una comprobación de alta prioridad porque las configuraciones erróneas de sudo pueden proporcionar una escalada directa y sencilla con muy pocas suposiciones.
Para mantener un registro de nuestros hallazgos, redirigiremos la salida de este comando a un archivo de texto dentro de nuestro directorio de proyecto.
Ejecuta el siguiente comando para listar tus privilegios de sudo y guardar la salida en un archivo llamado sudo_privs.txt:
sudo -l > /home/labex/project/sudo_privs.txt
Ahora, veamos el contenido del archivo que acabas de crear para analizar los permisos:
cat /home/labex/project/sudo_privs.txt
Deberías ver una salida similar a la siguiente:
Matching Defaults entries for labex on this host:
env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin
User labex may run the following commands on this host:
(root) NOPASSWD: /usr/bin/find
Algunos entornos pueden mostrar entradas de sudo adicionales además de la regla de find. Para este laboratorio, céntrate en la línea que permite explícitamente a labex ejecutar /usr/bin/find como root sin proporcionar una contraseña (NOPASSWD). Esa configuración específica es la que atacaremos en los próximos pasos.
Analizar binarios permitidos para escapes de shell
En este paso, analizarás el binario /usr/bin/find para comprender cómo puede ser abusado para ejecutar comandos arbitrarios.
El comando find es una utilidad potente utilizada para buscar archivos y directorios en una jerarquía de directorios. Sin embargo, incluye un parámetro altamente flexible llamado -exec. La bandera -exec permite al usuario ejecutar un comando especificado en cada archivo que find localiza.
El problema no es que find sea malicioso. El problema es que es expresivo. Cualquier binario capaz de ejecutarse como root y que sea expresivo es un candidato para un escape de shell si no está estrictamente limitado.
La falla de seguridad crítica surge cuando find se ejecuta con sudo. Si find se está ejecutando como root, cualquier comando pasado al parámetro -exec también se ejecutará como root.
Probemos esta teoría utilizando el parámetro -exec para ejecutar el comando whoami. El comando whoami simplemente imprime el nombre de usuario efectivo del usuario actual. Redirigiremos la salida a un archivo para verificar nuestro contexto de ejecución.
Ejecuta el siguiente comando:
sudo find . -exec whoami \; -quit > /home/labex/project/whoami.txt
Desglosemos este comando. La parte sudo find . ejecuta el comando find como root, comenzando la búsqueda en el directorio actual (.). El segmento -exec whoami \; le dice a find que ejecute el comando whoami, donde \; es necesario para terminar la declaración -exec. Finalmente, la bandera -quit le indica a find que salga inmediatamente después de procesar la primera coincidencia, lo que evita que ejecute whoami varias veces por cada archivo en el directorio.
Ahora, comprueba el contenido del archivo de salida:
cat /home/labex/project/whoami.txt
Deberías ver la siguiente salida:
root
Esto confirma que el comando pasado a -exec se ejecutó con éxito con privilegios de root.
Ejecutar binario con Sudo
En este paso, aprovecharás la vulnerabilidad de -exec para acceder a archivos confidenciales del sistema que normalmente están restringidos al usuario root.
Uno de los archivos más sensibles en un sistema Linux es /etc/shadow. Este archivo contiene los hashes de contraseñas cifrados de todas las cuentas de usuario en el sistema. Los usuarios estándar no tienen permisos de lectura para este archivo. Si un atacante puede leer este archivo, puede intentar descifrar los hashes de las contraseñas sin conexión.
Dado que hemos demostrado que podemos ejecutar comandos arbitrarios como root usando sudo find, podemos usar esta técnica para leer el contenido de /etc/shadow.
Usaremos el comando head dentro de nuestra declaración -exec para leer solo la primera línea del archivo shadow (que normalmente contiene el hash del usuario root) y guardarla en nuestro directorio de proyecto.
Ejecuta el siguiente comando:
sudo find /etc/shadow -exec head -n 1 {} \; -quit > /home/labex/project/shadow_head.txt
En este comando, {} actúa como un marcador de posición que find reemplaza con el nombre del archivo que está procesando actualmente (en este caso, /etc/shadow).
Verifica que extrajiste con éxito la información confidencial leyendo el archivo de salida:
cat /home/labex/project/shadow_head.txt
Deberías ver una salida similar a esta, mostrando la entrada del usuario root del archivo shadow:
root:*:19711:0:99999:7:::
Has logrado eludir los permisos del sistema de archivos abusando de la entrada de sudo mal configurada.
Generar una shell de root
En este paso, realizarás la acción final para lograr el compromiso total del sistema mediante la generación de una shell de root.
Aunque leer archivos confidenciales es peligroso, el objetivo final de la escalada de privilegios es obtener una shell interactiva ejecutándose como root. Esto otorga al atacante acceso sin restricciones a todo el sistema.
Para lograr esto, en lugar de pasar un comando simple como whoami o head al parámetro -exec, podemos pasar la ruta a un ejecutable de shell, como /bin/bash.
En un escenario real, un atacante ejecutaría sudo find . -exec /bin/bash \; -quit para entrar directamente en una terminal de root interactiva. Sin embargo, para los propósitos de este entorno de laboratorio automatizado, entrar en una shell interactiva pausaría la ejecución del laboratorio.
En su lugar, generaremos una shell bash de root en modo no interactivo usando la bandera -c. Esto nos permite pasar un comando directamente a la nueva shell de root, ejecutarlo y guardar la prueba de nuestro compromiso total del sistema. Usaremos el comando id, que proporciona información detallada sobre la identidad del usuario actual y sus pertenencias a grupos.
Ejecuta el siguiente comando para generar una shell de root y registrar tu identidad:
sudo find . -exec /bin/bash -c "id > /home/labex/project/pwned.txt" \; -quit
Finalmente, lee el archivo pwned.txt para verificar tu escalada de privilegios definitiva:
cat /home/labex/project/pwned.txt
La salida debería mostrar claramente que la shell se estaba ejecutando con los IDs de usuario y grupo de root:
uid=0(root) gid=0(root) groups=0(root)
¡Felicidades! Has explotado con éxito un archivo sudoers mal configurado para escalar tus privilegios de un usuario estándar a root.
Resumen
En este laboratorio, exploraste los riesgos de seguridad asociados con archivos sudoers mal configurados en entornos Linux. Comenzaste enumerando los privilegios de sudo de tu cuenta de usuario e identificaste que el binario find podía ejecutarse como root sin contraseña. Al comprender la funcionalidad del parámetro -exec del comando find, pudiste ejecutar comandos arbitrarios con privilegios de root. Demostraste el impacto de esta vulnerabilidad leyendo archivos restringidos del sistema y, finalmente, generando una shell de root para lograr el compromiso total del sistema. Este ejercicio destaca la importancia de adherirse al principio de menor privilegio y auditar cuidadosamente las configuraciones de sudo para evitar la escalada de privilegios no autorizada.
