<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* 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)!
* **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 einreichen.
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 `<` und `>`, 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 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" > ]>`
[**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)
Lassen Sie uns versuchen, die Datei `/etc/passwd` auf verschiedene Arten zu lesen. Für Windows könnten Sie versuchen, folgendes zu lesen: `C:\windows\system32\drivers\etc\hosts`
In Anwendungen, die auf **Java** basieren, 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):
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 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:
**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://**\_ 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)**.**
* 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.
* Die `%exfiltrate`-Entity wird dann verwendet, um eine HTTP-Anfrage an die angegebene URL mit den Inhalts der Datei 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`.
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 Ausschleusung der Datei `/etc/hostname` auf den Server des Angreifers.
**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 mit dem Namen `file` wird definiert, die den Inhalt der Datei `/etc/passwd` enthält.
2. Eine XML-Parameterentität mit dem Namen `eval` wird definiert, die eine dynamische Deklaration für eine weitere XML-Parameterentität mit dem Namen `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.
_**Bitte beachten Sie, dass externe DTD es uns erlauben, eine Entität innerhalb der zweiten (****`eval`****) einzuschließen, was jedoch im internen DTD verboten ist. Daher können Sie keinen Fehler erzwingen, ohne ein externes DTD zu verwenden (normalerweise).**_
Eine Schlupfloch in der XML-Sprachspezifikation kann dazu führen, dass **sensible Daten durch Fehlermeldungen offengelegt werden, wenn das 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 einem externen DTD deklariert wurde, innerhalb eines 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 ein Hybrid-DTD wie folgt einreicht:
* 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 erfolgt für die 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 Fehlermeldung, die vom Exploit angestrebt wird.
**Beispiel aus der realen Welt:** Systeme, die die GNOME-Desktopumgebung verwenden, haben oft eine DTD unter `/usr/share/yelp/dtd/docbookx.dtd`, die eine Entität namens `ISOamso` enthält.
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 indem Sie eine Liste von **Standard-DTDs** in Systemen **abrufen** und **überprüfen**, ob eine davon existiert:
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.
Für eine ausführlichere Erklärung dieses Angriffs, **überprüfen Sie den zweiten Abschnitt** [**diesen 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 notwendig, 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 wieder zusammengefügt 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.
Das **jar**-Protokoll ist ausschließlich in **Java-Anwendungen** verfügbar. 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.
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).
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 genutzt werden, einschließlich eines Python-Servers (`slow_http_server.py`) und eines Java-Servers (`slowserver.jar`).
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.).
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 innerhalb eines beliebigen Datenelements des XML-Dokuments ermöglicht. 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:
Dateien, die von Benutzern in bestimmte Anwendungen hochgeladen und dann auf dem Server verarbeitet werden, können Schwachstellen bei 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 den Server somit an XXE (XML External Entity)-Schwachstellen zu exponieren.
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.
**Beachten Sie, dass die erste Zeile der gelesenen Datei oder des Ergebnisses der Ausführung INNERHALB des erstellten Bildes erscheint. Sie müssen also auf das Bild zugreifen können, das SVG erstellt hat.**
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:
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:
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)) Transformation in UTF-7 verwenden.
Wenn die Webseite PHP verwendet, können Sie anstelle von `file:/`**PHP-Wrapper**`php://filter/convert.base64-encode/resource=` verwenden, um auf **interne Dateien zuzugreifen**.
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 folgenden Beispiel: \[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)).
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.
{"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."}
Diese Methode zeigt, dass der User-Agent die Verwendung von Java 1.8 angibt. Eine bekannte Einschränkung dieser Java-Version besteht in der Unfähigkeit, 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:
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:
Diese Modifikation führt zur erfolgreichen Exfiltration des Dateiinhalts, wie es im Fehlerausgabewert, der über HTTP gesendet wird, reflektiert wird. 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 zu extrahieren.
Ein XML External Entity (XXE) Angriff kann verwendet werden, um Dateien auf dem Server zu lesen. Der Angreifer kann eine speziell präparierte XML-Datei hochladen, die auf vertrauliche Dateien auf dem Server verweist. Wenn die Anwendung anfällig ist, kann der Angreifer den Inhalt dieser Dateien lesen und möglicherweise sensible Informationen preisgeben.
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 die Ausführung von Code auf dem Server erlangen.
<summary><strong>Erlernen Sie AWS-Hacking von Grund auf mit</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* 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)!
* **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.
