Der Nervenkitzel, eine komplexe digitale Festung zu durchbrechen, ist für viele IT-Sicherheitsexperten und Enthusiasten eine treibende Kraft. Plattformen wie Hack The Box (HTB) bieten eine sichere Umgebung, um diese Fähigkeiten zu schärfen und sich an realistischen Herausforderungen zu messen. Heute nehmen wir uns einer klassischen HTB-Maschine an: **GREENHORN**. Diese Box ist nicht nur ein Test für Ihre grundlegenden Penetrationstests-Fähigkeiten, sondern taucht auch tief in die oft übersehene Kunst des **Reverse PHP** ein. Wenn Sie schon immer wissen wollten, wie Hacker hinter verschleierte PHP-Skripte blicken und Schwachstellen aufdecken, sind Sie hier genau richtig. Begleiten Sie uns auf dieser Reise, während wir Greenhorn knacken und die Geheimnisse seiner PHP-Basis lüften.
### Was ist HTB: GREENHORN und warum Reverse PHP?
**Hack The Box (HTB)** ist eine führende Online-Plattform, die Hacking-Herausforderungen in Form von simulierten Schwachstellen in verschiedenen Systemen anbietet. Von Web-Anwendungen über Netzwerk-Sicherheitslücken bis hin zu Binäranalyse und Forensik – HTB deckt ein breites Spektrum ab. Jede „Box” ist eine virtuelle Maschine mit spezifischen Schwachstellen, die es zu finden und auszunutzen gilt, um Zugriff zu erlangen und die „Flags” (Benutzer- und Root-Dateien) zu finden.
**GREENHORN** ist eine der Einstiegs- bis Mittelklasse-Maschinen auf HTB. Sie ist bekannt für ihre Web-Komponente, die stark auf PHP basiert. Der besondere Reiz und die primäre Herausforderung von Greenhorn liegen in der Notwendigkeit, **obfuskierten oder verschlüsselten PHP-Code zu reverse-engineeren**. In der realen Welt wird PHP-Code aus verschiedenen Gründen obfuskiert: zum Schutz geistigen Eigentums, zur Erschwerung der Analyse durch Angreifer oder manchmal auch, um Malware zu verschleiern. Für Penetrationstester ist die Fähigkeit, diesen Code zu verstehen, absolut entscheidend, um verborgene Schwachstellen aufzudecken.
Unsere Reise beginnt mit der obligatorischen Informationsbeschaffung.
### Phase 1: Die Initial-Rekonnaissance – Licht ins Dunkel bringen
Jede erfolgreiche Hacking-Operation beginnt mit einer gründlichen Aufklärung, der **Rekonnaissance**. Unser Ziel ist es, so viele Informationen wie möglich über das Zielsystem zu sammeln, ohne dabei verdächtig zu werden.
Zuerst verwenden wir **Nmap**, das Schweizer Taschenmesser für die Netzwerkerkundung. Ein grundlegender Scan gibt uns einen Überblick über offene Ports und Dienste:
„`bash
nmap -sC -sV
„`
Der Nmap-Scan enthüllt typischerweise offene Ports wie 22 (SSH) und 80 (HTTP). Der Port 80, der auf einen **Apache HTTP Server** (oft mit PHP-Unterstützung) verweist, ist hier unser Hauptaugenmerk. Dies bestätigt unsere Annahme, dass die Herausforderung eine Web-Komponente hat.
Als Nächstes navigieren wir im Browser zur IP-Adresse der Maschine. Wir sehen eine Standard-Webseite, vielleicht mit ein paar grundlegenden Informationen oder einer Anmeldeseite. Der Blick in den Quelltext der Seite (Rechtsklick > Seitenquelltext anzeigen) ist immer ein guter erster Schritt. Manchmal finden sich hier Kommentare, versteckte Links oder sogar interessante JavaScript-Dateien.
Da es sich um eine Web-Anwendung handelt, ist auch ein Verzeichnis-Bruteforce mit Tools wie **DirBuster**, **Gobuster** oder **ffuf** unerlässlich, um versteckte Verzeichnisse oder Dateien aufzudecken.
„`bash
gobuster dir -u http://
„`
Dieser Schritt ist oft der Schlüssel. Bei Greenhorn führt die Verzeichnisauflistung zur Entdeckung einer sehr wichtigen Datei, beispielsweise `source.php` oder einer ähnlichen, die auf eine Code-Basis hindeutet. Das Auffinden einer solchen Datei ist ein Glücksfall, da uns der Quellcode, auch wenn obfuskiert, einen direkten Einblick in die Logik der Anwendung gibt.
### Phase 2: Die Kunst des Reverse PHP – Code-Analyse Schritt für Schritt
Hier beginnt der Kern der Greenhorn-Herausforderung: Das Reverse Engineering des PHP-Codes. Die `source.php`-Datei wird wahrscheinlich nicht im Klartext vorliegen. Stattdessen werden wir auf stark obfuskierten Code stoßen, der möglicherweise Funktionen wie `eval()`, `base64_decode()`, `gzinflate()` und andere exotische Zeichenkettenmanipulationen verwendet.
**Verständnis der Obfuskation:**
PHP-Obfuskation kann viele Formen annehmen. Die häufigsten Methoden sind:
1. **Base64-Kodierung:** Die Daten werden einfach in Base64 umgewandelt. Leicht zu dekodieren.
2. **Kombinationen von Kodierungen:** Oft werden mehrere Kodierungs- oder Komprimierungsschritte hintereinander angewendet (z.B. `base64_decode(gzinflate(base64_decode(…)))`).
3. **Zeichenkettenmanipulationen:** Zeichenketten können umgedreht, in ihre ASCII-Werte zerlegt und wieder zusammengesetzt werden.
4. **Benutzerdefinierte Funktionen:** Manche Obfuskatoren nutzen eigene, oft komplexe Algorithmen zur Kodierung, die erst analysiert und dann umgekehrt werden müssen.
5. **`eval()`-Nutzung:** Der entscheidende Punkt ist oft die Funktion `eval()`. Sie nimmt eine Zeichenkette und führt sie als PHP-Code aus. Dies ist sowohl die Methode der Obfuskation als auch unser Werkzeug, um den Code schrittweise zu de-obfuskieren.
**Der De-Obfuskations-Prozess bei Greenhorn:**
Nehmen wir an, wir finden eine Zeile, die so aussieht (vereinfachtes Beispiel):
`eval(base64_decode(‘PD9waHAgZWNobyAiSGVsbG8gV29ybGQiOyA/Pg==’));`
Um den Inhalt von `base64_decode()` zu sehen, können wir einfach einen kleinen PHP-Skript auf unserem lokalen Rechner erstellen oder eine PHP-Shell interaktiv nutzen:
„`php
„`
Dies würde uns den ersten entschlüsselten Code liefern. Bei Greenhorn ist der Code jedoch komplexer. Er kann wie eine Kette von Verschleierungen aussehen, zum Beispiel:
„`php
„`
Hier müssen wir den `base64_decode`-Teil isolieren, das Ergebnis in `gzinflate` packen und das Ergebnis wiederum in `eval()` übergeben. Der Trick besteht darin, die äußere `eval()`-Funktion zu entfernen und stattdessen den entschlüsselten Code einfach auszugeben (`echo`).
Ein iterativer Ansatz ist hier entscheidend:
1. Kopieren Sie den obfuskierten Code.
2. Identifizieren Sie die äußere Verschleierungsfunktion (z.B. `base64_decode`, `gzinflate`).
3. Ersetzen Sie `eval()` durch `echo` (oder `file_put_contents(‘decoded.php’, …)`).
4. Führen Sie den PHP-Code aus (lokal oder online PHP-Interpreter).
5. Analysieren Sie die Ausgabe. Ist sie immer noch verschleiert? Wenn ja, wiederholen Sie die Schritte 2-4 mit der neuen Ausgabe.
Bei Greenhorn könnte die Obfuskation eine benutzerdefinierte Funktion `decode_stuff()` beinhalten, die eine interne Zuordnungstabelle oder einen Algorithmus verwendet. In diesem Fall müssen wir die Logik dieser `decode_stuff()`-Funktion verstehen und sie dann verwenden, um den Rest des Codes zu entschlüsseln. Dies erfordert oft einen genauen Blick auf die Funktionsdefinition selbst, die meist auch obfuskiert ist, aber letztendlich entschlüsselt werden kann.
Nachdem wir den gesamten Code de-obfuskiert haben, stehen wir vor dem eigentlichen PHP-Code, der die Anwendungslogik enthält. Dies ist unser „Aha!”-Moment.
### Phase 3: Schwachstellenanalyse – Das Nadelöhr finden
Mit dem entschlüsselten Code vor uns können wir nun die Logik der Anwendung analysieren und nach Schwachstellen suchen. Bei Web-Anwendungen sind die häufigsten Ziele:
* **Command Injection:** Wenn Benutzereingaben direkt in Systembefehle (`system()`, `exec()`, `shell_exec()`, `passthru()`) ohne ausreichende Sanitization eingebettet werden.
* **SQL Injection:** Unsichere Datenbankabfragen.
* **Local/Remote File Inclusion (LFI/RFI):** Wenn Dateien basierend auf Benutzereingaben eingebunden werden (`include()`, `require()`).
* **Cross-Site Scripting (XSS):** Wenn Benutzereingaben ungefiltert im HTML-Ausgabe landen.
* **Insecure Deserialization:** Wenn serialisierte Daten unsicher behandelt werden.
Für Greenhorn ist die Wahrscheinlichkeit hoch, dass wir auf eine **Command Injection**-Schwachstelle stoßen. Der de-obfuskierte Code offenbart oft eine Funktion, die Benutzerparameter nimmt, diese möglicherweise ein wenig bereinigt (oder eben nicht genug) und dann in einem Shell-Befehl ausführt. Suchen Sie nach Zeilen, die `system(`, `exec(`, `shell_exec(`, `passthru(` enthalten und prüfen Sie, wie die übergebenen Parameter behandelt werden.
Nehmen wir an, der entschlüsselte Code sieht ungefähr so aus (vereinfacht):
„`php
„`
In diesem Fall würde uns die `cmd`-GET-Parameter-Variable die Ausführung beliebiger Befehle ermöglichen. Das `&&` ermöglicht die Verkettung von Befehlen.
### Phase 4: Exploitation – Der erste Zugang (User Flag)
Nachdem wir die Schwachstelle identifiziert haben (z.B. Command Injection), können wir nun einen **Payload** konstruieren, um Code auf dem Server auszuführen.
Mit der oben genannten Schwachstelle könnten wir versuchen, grundlegende Befehle auszuführen, um die RCE (Remote Code Execution) zu bestätigen:
`http://
Wenn dies erfolgreich ist, sollten wir die Ausgabe des `id`-Befehls sehen, der uns die Benutzer-ID des ausführenden Prozesses (oft `www-data`) anzeigt.
Der nächste Schritt ist die Beschaffung der Benutzer-Flag. Diese befindet sich oft im Home-Verzeichnis des Benutzers, unter dem der Webserver läuft oder einem dedizierten `user` Verzeichnis. Ein häufiger Pfad ist `/home/
Wir können versuchen, den Inhalt der Datei auszulesen:
`http://
Sobald wir die `user.txt` erhalten haben, ist die erste Phase abgeschlossen! Jetzt beginnt die Privilegieneskalation.
### Phase 5: Privilegieneskalation – Zum Root-Konto (Root Flag)
Die Erlangung des Benutzerzugriffs ist nur die halbe Miete. Um die vollständige Kontrolle über die Maschine zu erlangen und die Root-Flag zu erhalten, müssen wir unsere Berechtigungen auf das **Root-Konto** erweitern. Dies ist der Teil des Angriffs, der oft die größte Kreativität erfordert.
Typische Schritte zur Privilegieneskalation umfassen:
1. **System-Enumeration:** Sammeln Sie so viele Informationen wie möglich über das kompromittierte System. Tools wie `linPEAS.sh` sind hier Gold wert, aber ein manueller Ansatz mit Befehlen wie `uname -a`, `ls -la /`, `find / -perm -4000 2>/dev/null` (für SUID-Binaries), `sudo -l`, `crontab -l` ist ebenfalls wichtig.
2. **Suchen nach SUID-Binaries:** Programme, die mit Root-Rechten ausgeführt werden, auch wenn sie von einem normalen Benutzer aufgerufen werden. Eine Fehlkonfiguration hier ist eine häufige Eskalationsroute (z.B. `find / -type f -perm -04000 -ls 2>/dev/null`).
3. **Cron Jobs:** Überprüfen Sie, ob es geplante Aufgaben gibt, die mit Root-Rechten ausgeführt werden und von uns manipuliert werden könnten.
4. **Dateiberechtigungen:** Gibt es schreibbare Konfigurationsdateien, die Root-Prozesse betreffen?
5. **Kernel-Exploits:** Manchmal ist der Kernel veraltet und weist bekannte Schwachstellen auf.
6. **Passwörter in Konfigurationsdateien:** Suchen Sie nach Passwörtern in Datenbank-Konfigurationsdateien, Skripten oder anderen Dateien, die Sie lesen können.
7. **`sudo`-Konfiguration:** Der Befehl `sudo -l` zeigt an, welche Befehle der aktuelle Benutzer ohne Passwort als Root ausführen darf. Dies ist oft ein direkter Weg zu Root.
Bei Greenhorn könnte die Eskalation relativ einfach sein, sobald man die RCE hat. Möglicherweise gibt es eine schwach konfigurierte SUID-Binärdatei oder ein sudo-Privileg, das es dem `www-data`-Benutzer erlaubt, einen bestimmten Befehl als Root auszuführen.
Nehmen wir an, `sudo -l` zeigt an, dass `www-data` `/usr/bin/python3 /opt/script.py` als Root ausführen darf und wir dieses Skript schreiben können. Dann könnten wir unser eigenes Python-Skript dort ablegen, um eine Root-Shell zu erhalten.
`sudo /usr/bin/python3 /opt/script.py`
Sobald Sie Root-Zugriff haben, navigieren Sie zum Root-Verzeichnis (`/root/`) und lesen Sie die **root.txt**-Datei aus. Herzlichen Glückwunsch! Sie haben Greenhorn vollständig kompromittiert.
### Fazit: Was wir von HTB: GREENHORN gelernt haben
Die Herausforderung von **HTB: GREENHORN** ist eine ausgezeichnete Lektion in mehreren Bereichen der Cybersicherheit:
* **Gründliche Rekonnaissance:** Der erste Schritt ist immer der wichtigste. Die Entdeckung von `source.php` war entscheidend.
* **Die Notwendigkeit des Reverse Engineering:** In der realen Welt sind obfuskierte Binärdateien und Skripte keine Seltenheit. Die Fähigkeit, sie zu entschlüsseln, ist ein unverzichtbares Werkzeug für jeden Penetrationstester.
* **PHP-Sicherheitslücken:** Greenhorn betont die Gefahren unsicherer Benutzereingaben, insbesondere in Verbindung mit Funktionen zur Befehlsausführung. Entwickler müssen stets eine strenge **Eingabevalidierung** und -bereinigung durchführen und Funktionen wie `eval()` oder `shell_exec()` mit äußerster Vorsicht behandeln.
* **Iteratives Problemlösen:** Das Entschlüsseln des PHP-Codes und das Auffinden der Schwachstelle erforderten einen schrittweisen, methodischen Ansatz.
* **Die Bedeutung der Privilegieneskalation:** Der Angriff ist erst abgeschlossen, wenn Root-Zugriff erlangt wurde. Dies erfordert oft tiefergehendes Systemwissen.
Greenhorn ist ein hervorragendes Beispiel dafür, wie scheinbar komplexe Probleme durch systematisches Vorgehen und die Anwendung spezifischer Kenntnisse gelöst werden können. Es lehrt uns, dass oft nicht die Technologie selbst das Problem ist, sondern die Art und Weise, wie sie implementiert wird. Die Erfahrung, eine solche Maschine zu knacken, ist nicht nur befriedigend, sondern baut auch ein starkes Fundament für zukünftige, komplexere Herausforderungen. Nehmen Sie die Herausforderung an, tauchen Sie tief in den Code ein und lassen Sie sich vom Prozess des Entschlüsselns und Eroberns mitreißen!