mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
229 lines
7.9 KiB
Markdown
229 lines
7.9 KiB
Markdown
# Objection Tutorial
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|
|
|
|
## **Introduzione**
|
|
|
|
**objection - Esplorazione Mobile in Esecuzione**
|
|
|
|
[**Objection**](https://github.com/sensepost/objection) è un toolkit per l'esplorazione mobile in esecuzione, alimentato da [Frida](https://www.frida.re). È stato creato con l'obiettivo di aiutare a valutare le applicazioni mobili e la loro postura di sicurezza senza la necessità di un dispositivo mobile jailbroken o rootato.
|
|
|
|
**Nota:** Questo non è una forma di bypass del jailbreak / root. Utilizzando `objection`, sei comunque limitato da tutte le restrizioni imposte dal sandbox applicabile che stai affrontando.
|
|
|
|
### Riassunto
|
|
|
|
L'**obiettivo** di **objection** è consentire all'utente di chiamare le **azioni principali che offre Frida**. **Altrimenti**, l'utente dovrà creare un **singolo script per ogni applicazione** che desidera testare.
|
|
|
|
## Tutorial
|
|
|
|
Per questo tutorial utilizzerò l'APK che puoi scaricare qui:
|
|
|
|
{{#file}}
|
|
app-release.zip
|
|
{{#endfile}}
|
|
|
|
O dal suo [repository originale](https://github.com/asvid/FridaApp)(scarica app-release.apk)
|
|
|
|
### Installazione
|
|
```bash
|
|
pip3 install objection
|
|
```
|
|
### Connessione
|
|
|
|
Effettua una **connessione ADB regolare** e **avvia** il **server frida** nel dispositivo (e verifica che frida funzioni sia nel client che nel server).
|
|
|
|
Se stai utilizzando un **dispositivo rootato**, è necessario selezionare l'applicazione che desideri testare all'interno dell'opzione _**--gadget**_. in questo caso:
|
|
```bash
|
|
frida-ps -Uai
|
|
objection --gadget asvid.github.io.fridaapp explore
|
|
```
|
|
### Azioni di Base
|
|
|
|
Non tutti i comandi possibili di objections verranno elencati in questo tutorial, solo quelli che ho trovato più utili.
|
|
|
|
#### Ambiente
|
|
|
|
Alcune informazioni interessanti (come password o percorsi) potrebbero essere trovate all'interno dell'ambiente.
|
|
```bash
|
|
env
|
|
```
|
|
.png>)
|
|
|
|
#### Informazioni su Frida
|
|
```bash
|
|
frida
|
|
```
|
|
.png>)
|
|
|
|
#### Caricamento/Scaricamento
|
|
```bash
|
|
file download <remote path> [<local path>]
|
|
file upload <local path> [<remote path>]
|
|
```
|
|
#### Importa lo script frida
|
|
```bash
|
|
import <local path frida-script>
|
|
```
|
|
#### SSLPinning
|
|
```bash
|
|
android sslpinning disable #Attempts to disable SSL Pinning on Android devices.
|
|
```
|
|
#### Rilevamento del root
|
|
```bash
|
|
android root disable #Attempts to disable root detection on Android devices.
|
|
android root simulate #Attempts to simulate a rooted Android environment.
|
|
```
|
|
#### Esegui Comando
|
|
```bash
|
|
android shell_exec whoami
|
|
```
|
|
#### Screenshot
|
|
```bash
|
|
android ui screenshot /tmp/screenshot
|
|
android ui FLAG_SECURE false #This may enable you to take screenshots using the hardware keys
|
|
```
|
|
### Analisi statica resa dinamica
|
|
|
|
In un'applicazione reale dovremmo conoscere tutte le informazioni scoperte in questa parte prima di utilizzare objection grazie all'**analisi statica**. Comunque, in questo modo potresti vedere **qualcosa di nuovo** poiché qui avrai solo un elenco completo di classi, metodi e oggetti esportati.
|
|
|
|
Questo è anche utile se in qualche modo sei **incapace di ottenere del codice sorgente leggibile** dell'app.
|
|
|
|
#### Elenca attività, ricevitori e servizi
|
|
```bash
|
|
android hooking list activities
|
|
```
|
|
.png>)
|
|
```bash
|
|
android hooking list services
|
|
android hooking list receivers
|
|
```
|
|
Frida lancerà un errore se non viene trovata alcuna.
|
|
|
|
#### Ottenere l'attività corrente
|
|
```bash
|
|
android hooking get current_activity
|
|
```
|
|
.png>)
|
|
|
|
#### Cerca Classi
|
|
|
|
Iniziamo a cercare classi all'interno della nostra applicazione.
|
|
```bash
|
|
android hooking search classes asvid.github.io.fridaapp
|
|
```
|
|
.png>)
|
|
|
|
#### Metodi di ricerca di una classe
|
|
|
|
Ora estraiamo i metodi all'interno della classe _MainActivity:_
|
|
```bash
|
|
android hooking search methods asvid.github.io.fridaapp MainActivity
|
|
```
|
|
.png>)
|
|
|
|
#### Elenca i metodi dichiarati di una classe con i loro parametri
|
|
|
|
Scopriamo quali parametri richiedono i metodi della classe:
|
|
```bash
|
|
android hooking list class_methods asvid.github.io.fridaapp.MainActivity
|
|
```
|
|
.png>)
|
|
|
|
#### Elenco delle classi
|
|
|
|
Puoi anche elencare tutte le classi che sono state caricate all'interno dell'applicazione corrente:
|
|
```bash
|
|
android hooking list classes #List all loaded classes, As the target application gets usedmore, this command will return more classes.
|
|
```
|
|
Questo è molto utile se vuoi **agganciare il metodo di una classe e conosci solo il nome della classe**. Puoi usare questa funzione per **cercare quale modulo possiede la classe** e poi agganciare il suo metodo.
|
|
|
|
### Agganciare è facile
|
|
|
|
#### Agganciare (monitorare) un metodo
|
|
|
|
Dal [codice sorgente](https://github.com/asvid/FridaApp/blob/master/app/src/main/java/asvid/github/io/fridaapp/MainActivity.kt) dell'applicazione sappiamo che la **funzione** _**sum()**_ **di** _**MainActivity**_ viene eseguita **ogni secondo**. Proviamo a **estrarre tutte le informazioni possibili** ogni volta che la funzione viene chiamata (argomenti, valore di ritorno e backtrace):
|
|
```bash
|
|
android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --dump-args --dump-backtrace --dump-return
|
|
```
|
|
.png>)
|
|
|
|
#### Hooking (watching) an entire class
|
|
|
|
In realtà trovo tutti i metodi della classe MainActivity davvero interessanti, quindi **colleghiamoli tutti**. Fai attenzione, questo potrebbe **far crashare** un'applicazione.
|
|
```bash
|
|
android hooking watch class asvid.github.io.fridaapp.MainActivity --dump-args --dump-return
|
|
```
|
|
Se giochi con l'applicazione mentre la classe è hookata, vedrai quando **ogni funzione viene chiamata**, i suoi **argomenti** e il **valore di ritorno**.
|
|
|
|
.png>)
|
|
|
|
#### Cambiare il valore di ritorno booleano di una funzione
|
|
|
|
Dal codice sorgente puoi vedere che la funzione _checkPin_ riceve un _String_ come argomento e restituisce un _boolean_. Facciamo in modo che la funzione **restituisca sempre true**:
|
|
|
|
.png>)
|
|
|
|
Ora, se scrivi qualsiasi cosa nella casella di testo per il codice PIN, vedrai che qualsiasi cosa è valida:
|
|
|
|
.png>)
|
|
|
|
### Istanze di classe
|
|
|
|
Cerca e stampa **istanze live di una specifica classe Java**, specificata da un nome di classe completamente qualificato. Ecco il risultato di un tentativo di ottenere un valore stringa per un'obiezione scoperta che tipicamente **contiene valori di proprietà per l'oggetto**.
|
|
```
|
|
android heap print_instances <class>
|
|
```
|
|
.png>)
|
|
|
|
### Keystore/Intents
|
|
|
|
Puoi giocare con il keystore e gli intents usando:
|
|
```bash
|
|
android keystore list
|
|
android intents launch_activity
|
|
android intent launch_service
|
|
```
|
|
### Memoria
|
|
|
|
#### Dump
|
|
```bash
|
|
memory dump all <local destination> #Dump all memory
|
|
memory dump from_base <base_address> <size_to_dump> <local_destination> #Dump a part
|
|
```
|
|
#### Elenco
|
|
```bash
|
|
memory list modules
|
|
```
|
|
.png>)
|
|
|
|
In fondo alla lista puoi vedere frida:
|
|
|
|
.png>)
|
|
|
|
Controlliamo cosa sta esportando frida:
|
|
|
|
.png>)
|
|
|
|
#### Cerca/Scrivi
|
|
|
|
Puoi anche cercare e scrivere nella memoria con objection:
|
|
```bash
|
|
memory search "<pattern eg: 41 41 41 ?? 41>" (--string) (--offsets-only)
|
|
memory write "<address>" "<pattern eg: 41 41 41 41>" (--string)
|
|
```
|
|
### SQLite
|
|
|
|
Puoi usare il comando `sqlite` per interagire con i database sqlite.
|
|
|
|
### Exit
|
|
```bash
|
|
exit
|
|
```
|
|
## Cosa mi manca in Objection
|
|
|
|
- I metodi di hooking a volte fanno crashare l'applicazione (questo è dovuto anche a Frida).
|
|
- Non puoi usare le istanze delle classi per chiamare le funzioni dell'istanza. E non puoi creare nuove istanze delle classi e usarle per chiamare funzioni.
|
|
- Non c'è una scorciatoia (come quella per sslpinnin) per hookare tutti i metodi crittografici comuni utilizzati dall'applicazione per vedere testo cifrato, testo in chiaro, chiavi, IV e algoritmi utilizzati.
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|