mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
231 lines
8.0 KiB
Markdown
231 lines
8.0 KiB
Markdown
# Objection Tutorial
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|
|
|
|
|
|
|
|
## **Introducción**
|
|
|
|
**objection - Exploración Móvil en Tiempo de Ejecución**
|
|
|
|
[**Objection**](https://github.com/sensepost/objection) es un kit de herramientas de exploración móvil en tiempo de ejecución, impulsado por [Frida](https://www.frida.re). Fue creado con el objetivo de ayudar a evaluar aplicaciones móviles y su postura de seguridad sin la necesidad de un dispositivo móvil con jailbreak o root.
|
|
|
|
**Nota:** Esto no es alguna forma de bypass de jailbreak / root. Al usar `objection`, todavía estás limitado por todas las restricciones impuestas por el sandbox aplicable al que te enfrentas.
|
|
|
|
### Resumen
|
|
|
|
El **objetivo** de **objection** es permitir al usuario llamar a las **acciones principales que ofrece Frida**. **De lo contrario**, el usuario necesitará crear un **script único para cada aplicación** que desee probar.
|
|
|
|
## Tutorial
|
|
|
|
Para este tutorial voy a usar el APK que puedes descargar aquí:
|
|
|
|
{% file src="../../../images/app-release.zip" %}
|
|
|
|
O desde su [repositorio original](https://github.com/asvid/FridaApp)(descargar app-release.apk)
|
|
|
|
### Instalación
|
|
```bash
|
|
pip3 install objection
|
|
```
|
|
### Conexión
|
|
|
|
Haz una **conexión ADB regular** y **inicia** el **servidor frida** en el dispositivo (y verifica que frida esté funcionando tanto en el cliente como en el servidor).
|
|
|
|
Si estás utilizando un **dispositivo rooteado**, es necesario seleccionar la aplicación que deseas probar dentro de la opción _**--gadget**_. en este caso:
|
|
```bash
|
|
frida-ps -Uai
|
|
objection --gadget asvid.github.io.fridaapp explore
|
|
```
|
|
### Acciones Básicas
|
|
|
|
No se enumerarán todos los comandos posibles de objections en este tutorial, solo los que he encontrado más útiles.
|
|
|
|
#### Entorno
|
|
|
|
Se puede encontrar información interesante (como contraseñas o rutas) dentro del entorno.
|
|
```bash
|
|
env
|
|
```
|
|
.png>)
|
|
|
|
#### Información de Frida
|
|
```bash
|
|
frida
|
|
```
|
|
.png>)
|
|
|
|
#### Cargar/Descargar
|
|
```bash
|
|
file download <remote path> [<local path>]
|
|
file upload <local path> [<remote path>]
|
|
```
|
|
#### Importar script de frida
|
|
```bash
|
|
import <local path frida-script>
|
|
```
|
|
#### SSLPinning
|
|
```bash
|
|
android sslpinning disable #Attempts to disable SSL Pinning on Android devices.
|
|
```
|
|
#### Detección de root
|
|
```bash
|
|
android root disable #Attempts to disable root detection on Android devices.
|
|
android root simulate #Attempts to simulate a rooted Android environment.
|
|
```
|
|
#### Comando Exec
|
|
```bash
|
|
android shell_exec whoami
|
|
```
|
|
#### Capturas de pantalla
|
|
```bash
|
|
android ui screenshot /tmp/screenshot
|
|
android ui FLAG_SECURE false #This may enable you to take screenshots using the hardware keys
|
|
```
|
|
### Análisis estático hecho dinámico
|
|
|
|
En una aplicación real, deberíamos conocer toda la información descubierta en esta parte antes de usar objection gracias al **análisis estático**. De todos modos, de esta manera tal vez puedas ver **algo nuevo**, ya que aquí solo tendrás una lista completa de clases, métodos y objetos exportados.
|
|
|
|
Esto también es útil si de alguna manera **no puedes obtener un código fuente legible** de la aplicación.
|
|
|
|
#### Listar actividades, receptores y servicios
|
|
```bash
|
|
android hooking list activities
|
|
```
|
|
.png>)
|
|
```bash
|
|
android hooking list services
|
|
android hooking list receivers
|
|
```
|
|
Frida lanzará un error si no se encuentra ninguno
|
|
|
|
#### Obteniendo la actividad actual
|
|
```bash
|
|
android hooking get current_activity
|
|
```
|
|
.png>)
|
|
|
|
#### Buscar Clases
|
|
|
|
Comencemos a buscar clases dentro de nuestra aplicación.
|
|
```bash
|
|
android hooking search classes asvid.github.io.fridaapp
|
|
```
|
|
.png>)
|
|
|
|
#### Métodos de búsqueda de una clase
|
|
|
|
Ahora extraigamos los métodos dentro de la clase _MainActivity:_
|
|
```bash
|
|
android hooking search methods asvid.github.io.fridaapp MainActivity
|
|
```
|
|
.png>)
|
|
|
|
#### Lista de métodos declarados de una clase con sus parámetros
|
|
|
|
Vamos a averiguar qué parámetros necesitan los métodos de la clase:
|
|
```bash
|
|
android hooking list class_methods asvid.github.io.fridaapp.MainActivity
|
|
```
|
|
.png>)
|
|
|
|
#### Listar clases
|
|
|
|
También podrías listar todas las clases que se cargaron dentro de la aplicación actual:
|
|
```bash
|
|
android hooking list classes #List all loaded classes, As the target application gets usedmore, this command will return more classes.
|
|
```
|
|
Esto es muy útil si quieres **enganchar el método de una clase y solo conoces el nombre de la clase**. Podrías usar esta función para **buscar qué módulo posee la clase** y luego enganchar su método.
|
|
|
|
### Enganchar es fácil
|
|
|
|
#### Enganchar (observar) un método
|
|
|
|
Del [código fuente](https://github.com/asvid/FridaApp/blob/master/app/src/main/java/asvid/github/io/fridaapp/MainActivity.kt) de la aplicación sabemos que la **función** _**sum()**_ **de** _**MainActivity**_ se está ejecutando **cada segundo**. Intentemos **extraer toda la información posible** cada vez que se llama a la función (argumentos, valor de retorno y traza de llamada):
|
|
```bash
|
|
android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --dump-args --dump-backtrace --dump-return
|
|
```
|
|
.png>)
|
|
|
|
#### Hooking (observando) una clase entera
|
|
|
|
En realidad, encuentro todos los métodos de la clase MainActivity realmente interesantes, así que **los engancharé todos**. Ten cuidado, esto podría **hacer que la aplicación se bloquee**.
|
|
```bash
|
|
android hooking watch class asvid.github.io.fridaapp.MainActivity --dump-args --dump-return
|
|
```
|
|
Si juegas con la aplicación mientras la clase está enganchada, verás cuando **cada función es llamada**, sus **argumentos** y el **valor de retorno**.
|
|
|
|
.png>)
|
|
|
|
#### Cambiando el valor de retorno booleano de una función
|
|
|
|
Del código fuente puedes ver que la función _checkPin_ recibe un _String_ como argumento y devuelve un _boolean_. Hagamos que la función **siempre devuelva true**:
|
|
|
|
.png>)
|
|
|
|
Ahora, si escribes cualquier cosa en el cuadro de texto para el código PIN, verás que cualquier cosa es válida:
|
|
|
|
.png>)
|
|
|
|
### Instancias de clase
|
|
|
|
Busca e imprime **instancias activas de una clase Java específica**, especificada por un nombre de clase completamente calificado. El resultado es un intento de obtener un valor de cadena para una objeción descubierta que típicamente **contendría valores de propiedad para el objeto**.
|
|
```
|
|
android heap print_instances <class>
|
|
```
|
|
.png>)
|
|
|
|
### Keystore/Intents
|
|
|
|
Puedes jugar con el keystore y los intents usando:
|
|
```bash
|
|
android keystore list
|
|
android intents launch_activity
|
|
android intent launch_service
|
|
```
|
|
### Memoria
|
|
|
|
#### Volcado
|
|
```bash
|
|
memory dump all <local destination> #Dump all memory
|
|
memory dump from_base <base_address> <size_to_dump> <local_destination> #Dump a part
|
|
```
|
|
#### Lista
|
|
```bash
|
|
memory list modules
|
|
```
|
|
.png>)
|
|
|
|
En la parte inferior de la lista puedes ver frida:
|
|
|
|
.png>)
|
|
|
|
Verifiquemos qué está exportando frida:
|
|
|
|
.png>)
|
|
|
|
#### Buscar/Escribir
|
|
|
|
También puedes buscar y escribir dentro de la 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
|
|
|
|
Puedes usar el comando `sqlite` para interactuar con bases de datos sqlite.
|
|
|
|
### Exit
|
|
```bash
|
|
exit
|
|
```
|
|
## Lo que me falta en Objection
|
|
|
|
- Los métodos de hooking a veces hacen que la aplicación se bloquee (esto también se debe a Frida).
|
|
- No puedes usar las instancias de las clases para llamar a las funciones de la instancia. Y no puedes crear nuevas instancias de clases y usarlas para llamar a funciones.
|
|
- No hay un atajo (como el de sslpinnin) para enganchar todos los métodos criptográficos comunes que utiliza la aplicación para ver texto cifrado, texto plano, claves, IVs y algoritmos utilizados.
|
|
|
|
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|