# 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
```
![](<../../../images/image (220).png>)

#### Informazioni su Frida
```bash
frida
```
![](<../../../images/image (1093).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
```
![](<../../../images/image (1016).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
```
![](<../../../images/image (813).png>)

#### Cerca Classi

Iniziamo a cercare classi all'interno della nostra applicazione.
```bash
android hooking search classes asvid.github.io.fridaapp
```
![](<../../../images/image (507).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
```
![](<../../../images/image (929).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
```
![](<../../../images/image (299).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
```
![](<../../../images/image (1086).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**.

![](<../../../images/image (861).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**:

![](<../../../images/image (883).png>)

Ora, se scrivi qualsiasi cosa nella casella di testo per il codice PIN, vedrai che qualsiasi cosa è valida:

![](<../../../images/image (228).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>
```
![](<../../../images/image (1095).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
```
![](<../../../images/image (286).png>)

In fondo alla lista puoi vedere frida:

![](<../../../images/image (1097).png>)

Controlliamo cosa sta esportando frida:

![](<../../../images/image (298).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}}