mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['', 'src/mobile-pentesting/android-app-pentesting/avd-androi
This commit is contained in:
Translator
parent
942ef8913d
commit
3cbd2c3e5a
@ -1,10 +1,10 @@
|
||||
# Pentesting de aplicaciones Android
|
||||
# Aplicaciones Android Pentesting
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Fundamentos de aplicaciones Android
|
||||
## Fundamentos de Aplicaciones Android
|
||||
|
||||
Es altamente recomendable comenzar leyendo esta página para conocer las **partes más importantes relacionadas con la seguridad de Android y los componentes más peligrosos en una aplicación Android**:
|
||||
Se recomienda encarecidamente empezar leyendo esta página para conocer las **partes más importantes relacionadas con la seguridad de Android y los componentes más peligrosos en una aplicación Android**:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -13,15 +13,15 @@ android-applications-basics.md
|
||||
|
||||
## ADB (Android Debug Bridge)
|
||||
|
||||
Esta es la herramienta principal que necesitas para conectar con un dispositivo android (emulado o físico).\
|
||||
**ADB** permite controlar dispositivos ya sea por **USB** o **Network** desde un ordenador. Esta utilidad habilita la **copia** de archivos en ambas direcciones, la **instalación** y **desinstalación** de apps, la **ejecución** de comandos de shell, la **copia de seguridad** de datos, la **lectura** de logs, entre otras funciones.
|
||||
Esta es la herramienta principal que necesitas para conectar un dispositivo Android (emulado o físico).\
|
||||
**ADB** permite controlar dispositivos ya sea por **USB** o por **red** desde un ordenador. Esta utilidad permite el **copiado** de archivos en ambas direcciones, la **instalación** y **desinstalación** de apps, la **ejecución** de comandos shell, la **copia de seguridad** de datos, la **lectura** de logs, entre otras funciones.
|
||||
|
||||
Echa un vistazo a la siguiente lista de [**ADB Commands**](adb-commands.md) para aprender cómo usar adb.
|
||||
Consulta la siguiente lista de [**ADB Commands**](adb-commands.md) para aprender a usar adb.
|
||||
|
||||
## Smali
|
||||
|
||||
A veces es interesante **modificar el código de la aplicación** para acceder a **información oculta** (quizás contraseñas u otros secretos bien ofuscados). Entonces, puede ser interesante decompilar el apk, modificar el código y recompilarlo.\
|
||||
[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Esto puede ser muy útil como una **alternativa para varias pruebas durante el análisis dinámico** que se van a presentar. Por tanto, **ten siempre en cuenta esta posibilidad**.
|
||||
A veces es interesante **modificar el código de la aplicación** para acceder a **información oculta** (tal vez contraseñas bien ofuscadas o flags). Entonces, podría ser útil descompilar el apk, modificar el código y recompilarlo.\
|
||||
[**En este tutorial** puedes **aprender cómo descompilar un APK, modificar código Smali y recompilar el APK** con la nueva funcionalidad](smali-changes.md). Esto puede ser muy útil como una **alternativa para varias pruebas durante el análisis dinámico** que se van a presentar. Por tanto, **ten siempre presente esta posibilidad**.
|
||||
|
||||
## Otros trucos interesantes
|
||||
|
||||
@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
|
||||
# after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
|
||||
java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
```
|
||||
## Case Studies & Vulnerabilities
|
||||
## Estudios de caso y Vulnerabilidades
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -63,12 +63,12 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
|
||||
## Análisis Estático
|
||||
|
||||
First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\
|
||||
Please, [**read here to find information about different available decompilers**](apk-decompilers.md).
|
||||
Primero, para analizar un APK deberías **revisar el código Java** usando un decompiler.\
|
||||
Por favor, [**lee aquí para encontrar información sobre los diferentes decompilers disponibles**](apk-decompilers.md).
|
||||
|
||||
### Buscando información interesante
|
||||
|
||||
Con solo examinar las **strings** del APK puedes buscar **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** y cualquier cosa interesante... busca incluso **backdoors** de ejecución de código o backdoors de autenticación (credenciales de admin hardcoded en la app).
|
||||
Con solo revisar las **strings** del APK puedes buscar **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API** keys, **encryption**, **bluetooth UUIDs**, **tokens** y cualquier cosa interesante... busca incluso **backdoors** de ejecución de código o backdoors de autenticación (credenciales de admin hardcoded en la app).
|
||||
|
||||
**Firebase**
|
||||
|
||||
@ -76,26 +76,26 @@ Presta especial atención a las **Firebase URLs** y verifica si está mal config
|
||||
|
||||
### Comprensión básica de la aplicación - Manifest.xml, strings.xml
|
||||
|
||||
La **examinación de los archivos _Manifest.xml_ y **_strings.xml_** de una aplicación puede revelar vulnerabilidades de seguridad potenciales**. Estos archivos pueden accederse usando decompilers o renombrando la extensión del archivo APK a .zip y luego descomprimiéndolo.
|
||||
El **examen del _Manifest.xml_ y los archivos _strings.xml_ de una aplicación puede revelar vulnerabilidades de seguridad potenciales**. Estos archivos pueden accederse usando decompilers o renombrando el archivo APK a .zip y descomprimiéndolo.
|
||||
|
||||
**Vulnerabilidades** identificables desde el **Manifest.xml** incluyen:
|
||||
Las **vulnerabilidades** identificadas a partir del **Manifest.xml** incluyen:
|
||||
|
||||
- **Debuggable Applications**: Las aplicaciones marcadas como debuggable (`debuggable="true"`) en el _Manifest.xml_ representan un riesgo ya que permiten conexiones que pueden conducir a explotación. Para entender mejor cómo explotar aplicaciones debuggable, consulta un tutorial sobre cómo encontrar y explotar aplicaciones debuggable en un dispositivo.
|
||||
- **Backup Settings**: El atributo `android:allowBackup="false"` debería establecerse explícitamente para aplicaciones que manejan información sensible para prevenir backups no autorizados vía adb, especialmente cuando usb debugging está habilitado.
|
||||
- **Aplicaciones depurables**: Las aplicaciones marcadas como debuggable (`debuggable="true"`) en el _Manifest.xml_ representan un riesgo ya que permiten conexiones que pueden llevar a la explotación. Para entender mejor cómo explotar aplicaciones debuggable, consulta un tutorial sobre cómo encontrarlas y explotarlas en un dispositivo.
|
||||
- **Ajustes de backup**: El atributo `android:allowBackup="false"` debería establecerse explícitamente para aplicaciones que manejan información sensible para evitar backups no autorizados vía adb, especialmente cuando usb debugging está habilitado.
|
||||
- **Network Security**: Las configuraciones de seguridad de red personalizadas (`android:networkSecurityConfig="@xml/network_security_config"`) en _res/xml/_ pueden especificar detalles de seguridad como certificate pins y ajustes de tráfico HTTP. Un ejemplo es permitir tráfico HTTP para dominios específicos.
|
||||
- **Exported Activities and Services**: Identificar actividades y servicios exportados en el manifiesto puede resaltar componentes que podrían ser mal utilizados. Un análisis más profundo durante pruebas dinámicas puede revelar cómo explotar estos componentes.
|
||||
- **Content Providers and FileProviders**: Los content providers expuestos podrían permitir acceso o modificación no autorizada de datos. La configuración de FileProviders también debe ser escrutada.
|
||||
- **Broadcast Receivers and URL Schemes**: Estos componentes podrían aprovecharse para explotación, con atención especial a cómo se gestionan los URL schemes por posibles vulnerabilidades de entrada.
|
||||
- **SDK Versions**: Los atributos `minSdkVersion`, `targetSDKVersion`, y `maxSdkVersion` indican las versiones de Android soportadas, lo que resalta la importancia de no soportar versiones antiguas y vulnerables de Android por razones de seguridad.
|
||||
- **Actividades y Services exportados**: Identificar activities y services exportados en el manifest puede destacar componentes que podrían ser mal utilizados. Un análisis adicional durante pruebas dinámicas puede revelar cómo explotar estos componentes.
|
||||
- **Content Providers y FileProviders**: Los content providers expuestos podrían permitir acceso o modificación no autorizada de datos. La configuración de FileProviders también debe ser examinada.
|
||||
- **Broadcast Receivers y URL Schemes**: Estos componentes podrían aprovecharse para explotación, prestando especial atención a cómo se gestionan los URL schemes para vulnerabilidades de entrada.
|
||||
- **Versiones de SDK**: Los atributos `minSdkVersion`, `targetSDKVersion` y `maxSdkVersion` indican las versiones de Android soportadas, lo que subraya la importancia de no soportar versiones antiguas y vulnerables de Android por razones de seguridad.
|
||||
|
||||
Desde el archivo **strings.xml**, se puede descubrir información sensible como API keys, esquemas personalizados y otras notas del desarrollador, lo que subraya la necesidad de revisar cuidadosamente estos recursos.
|
||||
Desde el archivo **strings.xml**, se pueden descubrir datos sensibles como API keys, esquemas personalizados y otras notas del desarrollador, lo que enfatiza la necesidad de revisar cuidadosamente estos recursos.
|
||||
|
||||
### Tapjacking
|
||||
|
||||
**Tapjacking** es un ataque donde una **malicious** **application** se lanza y **se posiciona encima de una victim application**. Una vez que oculta visiblemente la app víctima, su interfaz de usuario está diseñada de tal manera que engaña al usuario para que interactúe con ella, mientras pasa la interacción a la app víctima.\
|
||||
En efecto, está **cegando al usuario para que no sepa que en realidad está realizando acciones en la victim app**.
|
||||
**Tapjacking** es un ataque donde una **aplicación maliciosa** se lanza y **se posiciona encima de una aplicación víctima**. Una vez que oscurece visiblemente la app víctima, su interfaz está diseñada de forma que engaña al usuario para que interactúe con ella, mientras pasa la interacción a la app víctima.\
|
||||
En efecto, está **cegando al usuario para que no sepa que en realidad está realizando acciones en la app víctima**.
|
||||
|
||||
Find more information in:
|
||||
Encuentra más información en:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -104,9 +104,9 @@ tapjacking.md
|
||||
|
||||
### Task Hijacking
|
||||
|
||||
An **activity** with the **`launchMode`** set to **`singleTask` without any `taskAffinity`** defined is vulnerable to task Hijacking. This means, that an **application** can be installed and if launched before the real application it could **hijack the task of the real application** (so the user will be interacting with the **malicious application thinking he is using the real one**).
|
||||
Una **activity** con el **`launchMode`** establecido en **`singleTask` sin ningún `taskAffinity`** definido es vulnerable a task Hijacking. Esto significa que una **aplicación** puede ser instalada y, si se lanza antes que la aplicación real, podría **secuestrar la tarea de la aplicación real** (por lo que el usuario estará interactuando con la **aplicación maliciosa pensando que está usando la real**).
|
||||
|
||||
More info in:
|
||||
Más info en:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -117,33 +117,33 @@ android-task-hijacking.md
|
||||
|
||||
**Internal Storage**
|
||||
|
||||
En Android, los archivos **almacenados** en **internal** storage están **diseñados** para ser **accesibles** exclusivamente por la **app** que los **creó**. Esta medida de seguridad es **impuesta** por el sistema operativo Android y suele ser adecuada para las necesidades de seguridad de la mayoría de las aplicaciones. Sin embargo, los desarrolladores a veces utilizan modos como `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` para **permitir** que los archivos sean **compartidos** entre distintas aplicaciones. Aun así, estos modos **no restringen el acceso** a esos archivos por otras aplicaciones, incluidas posibles aplicaciones maliciosas.
|
||||
En Android, los archivos **almacenados** en el **internal storage** están **diseñados** para ser **accesibles** exclusivamente por la **app** que los **creó**. Esta medida de seguridad es **impuesta** por el sistema operativo Android y generalmente es adecuada para las necesidades de seguridad de la mayoría de las aplicaciones. Sin embargo, los desarrolladores a veces utilizan modos como `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` para **permitir** que los archivos sean **compartidos** entre diferentes aplicaciones. Aun así, estos modos **no restringen el acceso** a estos archivos por parte de otras aplicaciones, incluidas las potencialmente maliciosas.
|
||||
|
||||
1. **Static Analysis:**
|
||||
- **Asegúrate** de que el uso de `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` sea **cuidadosamente escrutado**. Estos modos **pueden exponer** archivos a **accesos no intencionados o no autorizados**.
|
||||
2. **Dynamic Analysis:**
|
||||
- **Verifica** los **permisos** establecidos en archivos creados por la app. Específicamente, **comprueba** si alguno de los archivos está **establecido como legible o escribible por todo el mundo**. Esto puede implicar un riesgo de seguridad significativo, ya que permitiría que **cualquier aplicación** instalada en el dispositivo, independientemente de su origen o intención, **lea o modifique** esos archivos.
|
||||
1. **Análisis Estático:**
|
||||
- **Comprueba** que el uso de `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` sea **minuciosamente revisado**. Estos modos **pueden exponer** archivos a **accesos no intencionados o no autorizados**.
|
||||
2. **Análisis Dinámico:**
|
||||
- **Verifica** los **permisos** establecidos en los archivos creados por la app. Específicamente, **revisa** si algún archivo está **configurado como readable o writable worldwide**. Esto puede suponer un riesgo de seguridad significativo, ya que permitiría a **cualquier aplicación** instalada en el dispositivo, independientemente de su origen o intención, **leer o modificar** dichos archivos.
|
||||
|
||||
**External Storage**
|
||||
|
||||
Al tratar con archivos en **external storage**, como tarjetas SD, deben tomarse ciertas precauciones:
|
||||
Al tratar con archivos en **external storage**, como SD Cards, se deben tomar ciertas precauciones:
|
||||
|
||||
1. **Accesibilidad**:
|
||||
- Los archivos en external storage son **globalmente legibles y escribibles**. Esto significa que cualquier aplicación o usuario puede acceder a esos archivos.
|
||||
- Los archivos en external storage son **globalmente legibles y escribibles**. Esto significa que cualquier aplicación o usuario puede acceder a estos archivos.
|
||||
2. **Preocupaciones de seguridad**:
|
||||
- Dada la facilidad de acceso, se recomienda **no almacenar información sensible** en external storage.
|
||||
- El external storage puede ser removido o accedido por cualquier aplicación, lo que lo hace menos seguro.
|
||||
- El external storage puede ser retirado o accedido por cualquier aplicación, haciéndolo menos seguro.
|
||||
3. **Manejo de datos desde external storage**:
|
||||
- Siempre **realiza validación de entrada** sobre los datos recuperados desde external storage. Esto es crucial porque los datos provienen de una fuente no confiable.
|
||||
- No se recomienda almacenar ejecutables o archivos de clase en external storage para carga dinámica.
|
||||
- Si tu aplicación debe recuperar archivos ejecutables desde external storage, asegúrate de que dichos archivos estén **firmados y verificados criptográficamente** antes de cargarlos dinámicamente. Este paso es vital para mantener la integridad de seguridad de tu aplicación.
|
||||
- Siempre **realiza validación de entrada** en los datos recuperados desde external storage. Esto es crucial porque los datos provienen de una fuente no confiable.
|
||||
- Desaconsejado almacenar ejecutables o archivos de clase en external storage para carga dinámica.
|
||||
- Si tu aplicación debe recuperar archivos ejecutables desde external storage, asegúrate de que estos archivos estén **firmados y verificados criptográficamente** antes de cargarlos dinámicamente. Este paso es vital para mantener la integridad de seguridad de tu aplicación.
|
||||
|
||||
External storage puede ser **accedido** en `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
|
||||
|
||||
> [!TIP]
|
||||
> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files.
|
||||
> A partir de Android 4.4 (**API 17**), la SD card tiene una estructura de directorios que **limita el acceso de una app al directorio que es específicamente para esa app**. Esto evita que aplicaciones maliciosas obtengan acceso de lectura o escritura a los archivos de otra app.
|
||||
|
||||
**Sensitive data stored in clear-text**
|
||||
**Datos sensibles almacenados en texto claro**
|
||||
|
||||
- **Shared preferences**: Android permite a cada aplicación guardar fácilmente archivos xml en la ruta `/data/data/<packagename>/shared_prefs/` y a veces es posible encontrar información sensible en clear-text en esa carpeta.
|
||||
- **Databases**: Android permite a cada aplicación guardar fácilmente bases de datos sqlite en la ruta `/data/data/<packagename>/databases/` y a veces es posible encontrar información sensible en clear-text en esa carpeta.
|
||||
@ -152,34 +152,34 @@ External storage puede ser **accedido** en `/storage/emulated/0` , `/sdcard` , `
|
||||
|
||||
**Accept All Certificates**
|
||||
|
||||
For some reason sometimes developers accept all the certificates even if for example the hostname does not match with lines of code like the following one:
|
||||
Por alguna razón, a veces los desarrolladores aceptan todos los certificados incluso si, por ejemplo, el hostname no coincide con líneas de código como la siguiente:
|
||||
```java
|
||||
SSLSocketFactory sf = new cc(trustStore);
|
||||
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
Una buena manera de probar esto es intentar capturar el tráfico usando algún proxy como Burp sin autorizar Burp CA dentro del dispositivo. También, puedes generar con Burp un certificado para un hostname distinto y usarlo.
|
||||
Una buena forma de probar esto es intentar capturar el tráfico usando algún proxy como Burp sin autorizar Burp CA dentro del dispositivo. También puedes generar con Burp un certificado para un hostname diferente y usarlo.
|
||||
|
||||
### Criptografía rota
|
||||
### Criptografía débil
|
||||
|
||||
**Procesos deficientes de gestión de claves**
|
||||
|
||||
Algunos desarrolladores guardan datos sensibles en el almacenamiento local y los cifran con una clave hardcodeada/predictible en el código. Esto no debería hacerse, ya que algún reversing podría permitir a los atacantes extraer la información confidencial.
|
||||
Algunos desarrolladores guardan datos sensibles en el almacenamiento local y los encriptan con una clave hardcodeada/predictible en el código. Esto no debería hacerse ya que algo de ingeniería inversa podría permitir a los atacantes extraer la información confidencial.
|
||||
|
||||
**Uso de algoritmos inseguros y/o obsoletos**
|
||||
|
||||
Los desarrolladores no deberían usar **algoritmos obsoletos** para realizar comprobaciones de **autorización**, **almacenar** o **enviar** datos. Algunos de estos algoritmos son: RC4, MD4, MD5, SHA1... Si se usan **hashes** para almacenar contraseñas, por ejemplo, se deben usar hashes **resistentes** a fuerza bruta con salt.
|
||||
Los desarrolladores no deberían usar **algoritmos obsoletos** para realizar comprobaciones de **autorización**, **almacenar** o **enviar** datos. Algunos de estos algoritmos son: RC4, MD4, MD5, SHA1... Si se usan **hashes** para almacenar contraseñas, por ejemplo, deberían usarse hashes resistentes a fuerza bruta junto con salt.
|
||||
|
||||
### Otras comprobaciones
|
||||
|
||||
- Se recomienda **ofuscar el APK** para dificultar el trabajo de reversing a los atacantes.
|
||||
- Se recomienda **ofuscar el APK** para dificultar el trabajo de ingeniería inversa a los atacantes.
|
||||
- Si la app es sensible (como apps bancarias), debería realizar sus **propias comprobaciones para ver si el móvil está rooteado** y actuar en consecuencia.
|
||||
- Si la app es sensible (como apps bancarias), debería verificar si se está usando un **emulador**.
|
||||
- Si la app es sensible (como apps bancarias), debería comprobar si se está usando un **emulador**.
|
||||
- Si la app es sensible (como apps bancarias), debería **comprobar su propia integridad antes de ejecutarse** para verificar si fue modificada.
|
||||
- Usa [**APKiD**](https://github.com/rednaga/APKiD) para comprobar qué compiler/packer/obfuscator se usó para construir el APK
|
||||
|
||||
### Aplicación React Native
|
||||
|
||||
Read the following page to learn how to easily access javascript code of React applications:
|
||||
Lee la siguiente página para aprender cómo acceder fácilmente al código javascript de aplicaciones React:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -188,26 +188,26 @@ react-native-application.md
|
||||
|
||||
### Aplicaciones Xamarin
|
||||
|
||||
Read the following page to learn how to easily access C# code of a xamarin applications:
|
||||
Lee la siguiente página para aprender cómo acceder fácilmente al código C# de una aplicación Xamarin:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../xamarin-apps.md
|
||||
{{#endref}}
|
||||
|
||||
### Superpacked Applications
|
||||
### Aplicaciones Superpacked
|
||||
|
||||
According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.**
|
||||
Según este [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked es un algoritmo Meta que comprime el contenido de una aplicación en un único archivo. El blog habla sobre la posibilidad de crear una app que descomprima este tipo de apps... y una forma más rápida que implica **ejecutar la aplicación y recopilar los archivos descomprimidos desde el sistema de archivos.**
|
||||
|
||||
### Automated Static Code Analysis
|
||||
### Análisis estático automatizado de código
|
||||
|
||||
La herramienta [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** escaneando el **código** de la aplicación. Esta herramienta contiene una serie de **fuentes conocidas** (que indican a la herramienta los **lugares** donde la **entrada** está **controlada por el usuario**), **sinks** (que indican a la herramienta **lugares peligrosos** donde la entrada maliciosa del usuario podría causar daños) y **reglas**. Estas reglas indican la **combinación** de **fuentes-sinks** que señalan una vulnerabilidad.
|
||||
La herramienta [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** escaneando el **código** de la aplicación. Esta herramienta contiene una serie de **known sources** (que indican a la herramienta los **lugares** donde la **entrada** es **controlada por el usuario**), **sinks** (que indican a la herramienta **lugares peligrosos** donde la entrada maliciosa podría causar daños) y **rules**. Estas reglas indican la **combinación** de **sources-sinks** que señala una vulnerabilidad.
|
||||
|
||||
Con este conocimiento, **mariana-trench revisará el código y encontrará posibles vulnerabilidades en él**.
|
||||
|
||||
### Secrets leaked
|
||||
|
||||
Una aplicación puede contener secretos (API keys, contraseñas, URLs ocultas, subdominios...) dentro de ella que podrías llegar a descubrir. Podrías usar una herramienta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
Una aplicación puede contener secrets (API keys, passwords, hidden urls, subdomains...) dentro de ella que podrías ser capaz de descubrir. Puedes usar una herramienta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
|
||||
### Bypass Biometric Authentication
|
||||
|
||||
@ -218,12 +218,12 @@ bypass-biometric-authentication-android.md
|
||||
|
||||
### Otras funciones interesantes
|
||||
|
||||
- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()`
|
||||
- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage`
|
||||
- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load`
|
||||
- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md)
|
||||
- **Ejecución de código**: `Runtime.exec(), ProcessBuilder(), native code:system()`
|
||||
- **Enviar SMS**: `sendTextMessage, sendMultipartTestMessage`
|
||||
- **Funciones nativas** declaradas como `native`: `public native, System.loadLibrary, System.load`
|
||||
- [Lee esto para aprender **cómo hacer ingeniería inversa de funciones nativas**](reversing-native-libraries.md)
|
||||
|
||||
### **Other tricks**
|
||||
### **Otros trucos**
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -236,11 +236,11 @@ content-protocol.md
|
||||
|
||||
## Análisis dinámico
|
||||
|
||||
> First of all, you need an environment where you can install the application and all the environment (Burp CA cert, Drozer and Frida mainly). Therefore, a rooted device (emulated or not) is extremely recommended.
|
||||
> Primero que nada, necesitas un entorno donde puedas instalar la aplicación y todo el entorno (Burp CA cert, Drozer y Frida principalmente). Por lo tanto, se recomienda encarecidamente un dispositivo rooteado (emulado o no).
|
||||
|
||||
### Análisis dinámico en línea
|
||||
### Análisis dinámico online
|
||||
|
||||
Puedes crear una **cuenta gratuita** en: [https://appetize.io/](https://appetize.io). Esta plataforma permite **subir** y **ejecutar** APKs, por lo que es útil para ver cómo se comporta un apk.
|
||||
Puedes crear una **cuenta gratuita** en: [https://appetize.io/](https://appetize.io/). Esta plataforma te permite **subir** y **ejecutar** APKs, por lo que es útil para ver cómo se comporta un apk.
|
||||
|
||||
Incluso puedes **ver los logs de tu aplicación** en la web y conectarte mediante **adb**.
|
||||
|
||||
@ -250,9 +250,9 @@ Gracias a la conexión ADB puedes usar **Drozer** y **Frida** dentro de los emul
|
||||
|
||||
### Análisis dinámico local
|
||||
|
||||
#### Uso de un emulador
|
||||
#### Usando un emulador
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Puedes crear dispositivos **x86** y **arm**, y según [**esto** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**las últimas versiones x86** **soportan bibliotecas ARM** sin necesitar un emulador ARM lento).
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Puedes crear dispositivos **x86** y **arm**, y según [**esta** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**las últimas** versiones **x86** **soportan librerías ARM** sin necesitar un emulador ARM lento).
|
||||
- Aprende a configurarlo en esta página:
|
||||
|
||||
|
||||
@ -260,59 +260,67 @@ Gracias a la conexión ADB puedes usar **Drozer** y **Frida** dentro de los emul
|
||||
avd-android-virtual-device.md
|
||||
{{#endref}}
|
||||
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(**Versión gratuita:** Personal Edition, necesitas crear una cuenta. _Se recomienda **descargar** la versión **CON**_ _**VirtualBox** para evitar posibles errores._)
|
||||
- [**Nox**](https://es.bignox.com) (Gratis, pero no soporta Frida o Drozer).
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versión gratuita:** Personal Edition, necesitas crear una cuenta. _Se recomienda **descargar** la versión **CON**_ _**VirtualBox** para evitar errores potenciales._)
|
||||
- [**Nox**](https://es.bignox.com) (Gratis, pero no soporta Frida ni Drozer).
|
||||
|
||||
> [!TIP]
|
||||
> Cuando crees un nuevo emulador en cualquier plataforma recuerda que cuanto más grande sea la pantalla, más lento será el emulador. Así que selecciona pantallas pequeñas si es posible.
|
||||
> Al crear un nuevo emulador en cualquier plataforma recuerda que cuanto mayor sea la pantalla, más lento funcionará el emulador. Así que selecciona pantallas pequeñas si es posible.
|
||||
|
||||
Para **instalar google services** (como AppStore) en Genymotion necesitas hacer clic en el botón marcado en rojo de la siguiente imagen:
|
||||
|
||||
.png>)
|
||||
|
||||
Además, fíjate que en la **configuración de la VM Android en Genymotion** puedes seleccionar **Bridge Network mode** (esto será útil si vas a conectarte a la VM Android desde una VM diferente con las herramientas).
|
||||
Además, ten en cuenta que en la **configuración de la VM Android en Genymotion** puedes seleccionar **Bridge Network mode** (esto será útil si te vas a conectar a la VM Android desde otra VM con las herramientas).
|
||||
|
||||
#### Usa un dispositivo físico
|
||||
#### Usar un dispositivo físico
|
||||
|
||||
Necesitas activar las opciones de **debugging** y sería ideal si puedes **rootearlo**:
|
||||
Necesitas activar las opciones de **depuración** y sería ideal si puedes **rootearlo**:
|
||||
|
||||
1. **Settings**.
|
||||
2. (FromAndroid 8.0) Select **System**.
|
||||
3. Select **About phone**.
|
||||
4. Press **Build number** 7 times.
|
||||
5. Go back and you will find the **Developer options**.
|
||||
1. **Configuración**.
|
||||
2. (Desde Android 8.0) Selecciona **Sistema**.
|
||||
3. Selecciona **Acerca del teléfono**.
|
||||
4. Pulsa **Número de compilación** 7 veces.
|
||||
5. Vuelve atrás y encontrarás las **Opciones de desarrollador**.
|
||||
|
||||
> Once you have installed the application, the first thing you should do is to try it and investigate what does it do, how does it work and get comfortable with it.\
|
||||
> I will suggest to **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, so we will be able to **learn how the application works** while MobSF **captures** a lot of **interesting** **data** you can review later on.
|
||||
> Una vez que hayas instalado la aplicación, lo primero que deberías hacer es probarla e investigar qué hace, cómo funciona y familiarizarte con ella.\
|
||||
> Te sugeriría **realizar este análisis dinámico inicial usando MobSF dynamic analysis + pidcat**, de modo que podamos **aprender cómo funciona la aplicación** mientras MobSF **captura** muchos **datos interesantes** que podrás revisar más tarde.
|
||||
|
||||
### Unintended Data Leakage
|
||||
Magisk/Zygisk quick notes (recomendado en dispositivos Pixel)
|
||||
- Parchea boot.img con la app Magisk y flashea vía fastboot para obtener root sin tocar el sistema
|
||||
- Habilita Zygisk + DenyList para ocultar el root; considera LSPosed/Shamiko cuando se requiera ocultamiento más fuerte
|
||||
- Mantén el boot.img original para recuperarte de actualizaciones OTA; vuelve a parchear después de cada OTA
|
||||
- Para mirroring de pantalla, usa scrcpy en el host
|
||||
|
||||
**Logging**
|
||||
|
||||
Los desarrolladores deben tener cuidado al exponer información de **debugging** públicamente, ya que puede conducir a data leaks sensibles. Se recomiendan las herramientas [**pidcat**](https://github.com/JakeWharton/pidcat) y `adb logcat` para monitorizar los logs de la aplicación e identificar y proteger información sensible. **Pidcat** se prefiere por su facilidad de uso y legibilidad.
|
||||
|
||||
### Filtración de datos no intencional
|
||||
|
||||
**Registro (Logging)**
|
||||
|
||||
Los desarrolladores deben tener cuidado de no exponer información de **depuración** públicamente, ya que puede conducir a filtraciones de datos sensibles. Se recomiendan las herramientas [**pidcat**](https://github.com/JakeWharton/pidcat) y `adb logcat` para monitorizar los logs de la aplicación e identificar y proteger información sensible. **Pidcat** se prefiere por su facilidad de uso y legibilidad.
|
||||
|
||||
> [!WARNING]
|
||||
> Ten en cuenta que desde **versiones posteriores a Android 4.0**, **las aplicaciones solo pueden acceder a sus propios logs**. Por lo tanto, las aplicaciones no pueden acceder a los logs de otras apps.\
|
||||
> De todos modos, sigue siendo recomendable **no registrar información sensible**.
|
||||
> Ten en cuenta que desde **versiones posteriores a Android 4.0**, **las aplicaciones sólo pueden acceder a sus propios logs**. Por lo tanto, las aplicaciones no pueden acceder a los logs de otras apps.\
|
||||
> De todos modos, se recomienda **no registrar información sensible**.
|
||||
|
||||
**Caché del portapapeles (Copy/Paste Buffer Caching)**
|
||||
|
||||
El framework basado en **clipboard** de Android permite la funcionalidad de copiar-pegar en las apps, pero entraña un riesgo ya que **otras aplicaciones** pueden **acceder** al portapapeles, exponiendo potencialmente datos sensibles. Es crucial **deshabilitar las funciones de copiar/pegar** en secciones sensibles de una aplicación, como los datos de tarjetas de crédito, para prevenir data leaks.
|
||||
El framework de Android basado en **portapapeles** permite la funcionalidad copiar/pegar en las apps, pero supone un riesgo ya que **otras aplicaciones** pueden **acceder** al portapapeles, exponiendo potencialmente datos sensibles. Es crucial **deshabilitar las funciones de copiar/pegar** para secciones sensibles de una aplicación, como los datos de tarjetas de crédito, para evitar filtraciones.
|
||||
|
||||
**Crash Logs**
|
||||
|
||||
Si una aplicación **crashea** y **guarda logs**, estos logs pueden ayudar a los atacantes, especialmente cuando la aplicación no puede ser reverse-engineered. Para mitigar este riesgo, evita loggear en crashs, y si los logs deben transmitirse por la red, asegúrate de enviarlos vía un canal SSL para seguridad.
|
||||
Si una aplicación **se bloquea** y **guarda logs**, estos registros pueden ayudar a los atacantes, particularmente cuando la aplicación no puede ser sometida a ingeniería inversa. Para mitigar este riesgo, evita registrar información en los bloqueos y, si los logs deben transmitirse por la red, asegúrate de enviarlos a través de un canal SSL para seguridad.
|
||||
|
||||
Como pentester, **intenta echar un vistazo a estos logs**.
|
||||
Como pentester, **intenta revisar estos logs**.
|
||||
|
||||
**Analytics Data Sent To 3rd Parties**
|
||||
**Datos de analítica enviados a terceros**
|
||||
|
||||
Las aplicaciones frecuentemente integran servicios como Google Adsense, lo que puede involuntariamente provocar data leaks debido a una implementación incorrecta por parte de los desarrolladores. Para identificar fugas potenciales de datos, es aconsejable **interceptar el tráfico de la aplicación** y comprobar si se está enviando información sensible a servicios de terceros.
|
||||
Las aplicaciones suelen integrar servicios como Google Adsense, que pueden filtrar información sensible de forma inadvertida debido a una implementación incorrecta por parte de los desarrolladores. Para identificar posibles filtraciones de datos, es aconsejable interceptar el tráfico de la aplicación y comprobar si se está enviando información sensible a servicios de terceros.
|
||||
|
||||
### Bases de datos SQLite
|
||||
### SQLite DBs
|
||||
|
||||
La mayoría de las aplicaciones usan **bases de datos SQLite internas** para guardar información. Durante el pentest revisa las **bases de datos** creadas, los nombres de **tablas** y **columnas** y todos los **datos** guardados porque podrías encontrar **información sensible** (lo que sería una vulnerabilidad).\
|
||||
Las bases de datos deberían ubicarse en `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
|
||||
La mayoría de las aplicaciones usarán **bases de datos SQLite internas** para guardar información. Durante el pentest revisa las **bases de datos** creadas, los nombres de **tablas** y **columnas** y todos los **datos** guardados porque podrías encontrar **información sensible** (lo que sería una vulnerabilidad).\
|
||||
Las bases de datos deberían encontrarse en `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
|
||||
|
||||
Si la base de datos guarda información confidencial y está **encriptada** pero puedes **encontrar** la **contraseña** dentro de la aplicación, sigue siendo una **vulnerabilidad**.
|
||||
|
||||
@ -320,19 +328,19 @@ Enumera las tablas usando `.tables` y enumera las columnas de las tablas con `.s
|
||||
|
||||
### Drozer (Exploit Activities, Content Providers and Services)
|
||||
|
||||
From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** te permite **asumir el rol de una app Android** e interactuar con otras apps. Puede hacer **cualquier cosa que una aplicación instalada pueda hacer**, como hacer uso del mecanismo de Inter-Process Communication (IPC) de Android e interactuar con el sistema operativo subyacente.\
|
||||
Drozer es una herramienta útil para **explotar activities exportadas, servicios exportados y Content Providers** como aprenderás en las siguientes secciones.
|
||||
From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** te permite **asumir el rol de una app Android** e interactuar con otras apps. Puede hacer **todo lo que una aplicación instalada puede hacer**, como utilizar el mecanismo de Inter-Process Communication (IPC) de Android e interactuar con el sistema operativo subyacente. .\
|
||||
Drozer es una herramienta útil para **explotar exported activities, exported services y Content Providers** como aprenderás en las siguientes secciones.
|
||||
|
||||
### Explotando Activities exportadas
|
||||
### Exploitation de Activities exportadas
|
||||
|
||||
[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
|
||||
También recuerda que el código de una activity empieza en el método **`onCreate`**.
|
||||
[**Lee esto si quieres repasar qué es una Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
|
||||
También recuerda que el código de una Activity comienza en el método `onCreate`.
|
||||
|
||||
**Authorisation bypass**
|
||||
**Bypass de autorización**
|
||||
|
||||
Cuando una Activity está exportada puedes invocar su pantalla desde una app externa. Por lo tanto, si una activity con **información sensible** está **exportada** podrías **burlar** los mecanismos de **autenticación** para acceder a ella.
|
||||
Cuando una Activity está exportada puedes invocar su pantalla desde una app externa. Por lo tanto, si una activity con **información sensible** está **exportada** podrías **eludir** los mecanismos de **autenticación** para acceder a ella.
|
||||
|
||||
[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
|
||||
[**Aprende cómo explotar exported activities con Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
También puedes iniciar una activity exportada desde adb:
|
||||
|
||||
@ -341,106 +349,108 @@ También puedes iniciar una activity exportada desde adb:
|
||||
```bash
|
||||
adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
```
|
||||
**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21).
|
||||
**NOTA**: MobSF detectará como malicioso el uso de _**singleTask/singleInstance**_ como `android:launchMode` en una activity, pero debido a [esto](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente esto solo es peligroso en versiones antiguas (API versions < 21).
|
||||
|
||||
> [!TIP]
|
||||
> Ten en cuenta que un authorisation bypass no siempre es una vulnerabilidad; dependerá de cómo funcione el bypass y qué información se exponga.
|
||||
|
||||
**Sensitive information leakage**
|
||||
**Filtración de información sensible**
|
||||
|
||||
**Activities can also return results**. Si logras encontrar una activity exportada y sin protección que llame al método **`setResult`** y **devuelva información sensible**, se produce una sensitive information leakage.
|
||||
**Activities can also return results**. Si logras encontrar una activity exportada y sin protección que llame al método **`setResult`** y **devuelva información sensible**, existe una filtración de información sensible.
|
||||
|
||||
#### Tapjacking
|
||||
|
||||
Si Tapjacking no está prevenido, podrías abusar de la activity exportada para hacer que el **usuario realice acciones inesperadas**. Para más info sobre [**what is Tapjacking follow the link**](#tapjacking).
|
||||
Si el tapjacking no se previene, podrías abusar de la activity exportada para hacer que el **usuario realice acciones inesperadas**. Para más info sobre [**qué es Tapjacking sigue el enlace**](#tapjacking).
|
||||
|
||||
### Exploiting Content Providers - Accessing and manipulating sensitive information
|
||||
### Exploiting Content Providers - Accediendo y manipulando información sensible
|
||||
|
||||
[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)
|
||||
Content providers are basically used to **share data**. Si una app tiene content providers disponibles, podrías ser capaz de **extraer datos sensibles** de ellos. También es interesante probar posibles **SQL injections** y **Path Traversals** ya que podrían ser vulnerables.
|
||||
[**Lee esto si quieres repasar qué es un Content Provider.**](android-applications-basics.md#content-provider)\
|
||||
Los Content Providers se usan básicamente para **compartir datos**. Si una app tiene Content Providers disponibles, podrías **extraer datos sensibles** de ellos. También es interesante probar posibles **SQL injections** y **Path Traversals**, ya que podrían ser vulnerables.
|
||||
|
||||
[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
[**Aprende a explotar Content Providers con Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
|
||||
### **Exploiting Services**
|
||||
|
||||
[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)
|
||||
[**Lee esto si quieres repasar qué es un Service.**](android-applications-basics.md#services)\
|
||||
Recuerda que las acciones de un Service comienzan en el método `onStartCommand`.
|
||||
|
||||
Un Service es básicamente algo que **puede recibir datos**, **procesarlos** y **devolver** (o no) una respuesta. Entonces, si una aplicación exporta servicios deberías **revisar** el **código** para entender qué hace y **probarlo** **dinámicamente** para extraer información confidencial, eludir medidas de autenticación...
|
||||
[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services)
|
||||
Un Service es básicamente algo que **puede recibir datos**, **procesarlos** y **devolver** (o no) una respuesta. Entonces, si una aplicación exporta algunos services deberías **revisar** el **código** para entender qué hace y **probarlo** **dinámicamente** para extraer info confidencial, bypassing authentication measures...\
|
||||
[**Aprende a explotar Services con Drozer.**](drozer-tutorial/index.html#services)
|
||||
|
||||
### **Exploiting Broadcast Receivers**
|
||||
|
||||
[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)
|
||||
[**Lee esto si quieres repasar qué es un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
|
||||
Recuerda que las acciones de un Broadcast Receiver comienzan en el método `onReceive`.
|
||||
|
||||
Un broadcast receiver esperará un tipo de mensaje. Dependiendo de cómo el receiver maneje el mensaje, podría ser vulnerable.
|
||||
[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers)
|
||||
Un broadcast receiver estará esperando un tipo de mensaje. Dependiendo de cómo el receiver maneje el mensaje, podría ser vulnerable.\
|
||||
[**Aprende a explotar Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers)
|
||||
|
||||
### **Exploiting Schemes / Deep links**
|
||||
|
||||
Puedes buscar deep links manualmente, usando herramientas como MobSF o scripts como [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).
|
||||
Puedes buscar deep links manualmente, usando herramientas como MobSF o scripts como [este](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
|
||||
Puedes **abrir** un **scheme** declarado usando **adb** o un **browser**:
|
||||
```bash
|
||||
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
|
||||
```
|
||||
_Nota que puedes **omitir el nombre del paquete** y el móvil llamará automáticamente a la app que debería abrir ese enlace._
|
||||
_Ten en cuenta que puedes **omitir el nombre del paquete** y el dispositivo móvil llamará automáticamente a la app que debe abrir ese enlace._
|
||||
```html
|
||||
<!-- Browser regular link -->
|
||||
<a href="scheme://hostname/path?param=value">Click me</a>
|
||||
<!-- fallback in your url you could try the intent url -->
|
||||
<a href="intent://hostname#Intent;scheme=scheme;package=your.package.name;S.browser_fallback_url=http%3A%2F%2Fwww.example.com;end">with alternative</a>
|
||||
```
|
||||
**Código ejecutado**
|
||||
**Code executed**
|
||||
|
||||
Para encontrar el **código que se ejecutará en la App**, ve a la activity llamada por el deeplink y busca la función **`onNewIntent`**.
|
||||
In order to find the **código que se ejecutará en la App**, go to the activity called by the deeplink and search the function **`onNewIntent`**.
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
**Información sensible**
|
||||
**Informacion sensible**
|
||||
|
||||
Cada vez que encuentres un deep link verifica que **no esté recibiendo datos sensibles (como contraseñas) vía parámetros de URL**, porque cualquier otra aplicación podría **suplantar el deep link y robar esos datos!**
|
||||
Every time you find a deep link check that i**no esté recibiendo datos sensibles (como contraseñas) vía URL parameters**, because any other application could **impersonate the deep link and steal that data!**
|
||||
|
||||
**Parámetros en el path**
|
||||
|
||||
También **debes comprobar si algún deep link está usando un parámetro dentro del path** de la URL como: `https://api.example.com/v1/users/{username}`, en ese caso puedes forzar un path traversal accediendo a algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
|
||||
Ten en cuenta que si encuentras los endpoints correctos dentro de la aplicación podrías causar un **Open Redirect** (si parte del path se usa como nombre de dominio), **account takeover** (si puedes modificar detalles de usuarios sin token CSRF y el endpoint vulnerable usó el método correcto) y cualquier otra vuln. Más [info sobre esto aquí](http://dphoeniixx.com/2020/12/13-2/).
|
||||
You **must check also if any deep link is using a parameter inside the path** of the URL like: `https://api.example.com/v1/users/{username}` , in that case you can force a path traversal accessing something like: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
|
||||
Note that if you find the correct endpoints inside the application you may be able to cause a **Open Redirect** (if part of the path is used as domain name), **account takeover** (if you can modify users details without CSRF token and the vuln endpoint used the correct method) and any other vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**More examples**
|
||||
|
||||
An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
|
||||
|
||||
### Inspección de la capa de transporte y fallos de verificación
|
||||
### Transport Layer Inspection and Verification Failures
|
||||
|
||||
- **Los certificados no siempre son verificados correctamente** por las aplicaciones Android. Es común que estas aplicaciones omitan advertencias y acepten certificados self-signed o, en algunos casos, vuelvan a usar conexiones HTTP.
|
||||
- **Las negociaciones durante el handshake SSL/TLS a veces son débiles**, empleando suites de cifrado inseguras. Esta vulnerabilidad hace la conexión susceptible a ataques MITM, permitiendo a un atacante descifrar los datos.
|
||||
- **La filtración de información privada** es un riesgo cuando las aplicaciones se autentican usando canales seguros pero luego comunican otras transacciones por canales no seguros. Este enfoque no protege datos sensibles, como cookies de sesión o detalles de usuario, frente a la intercepción por actores maliciosos.
|
||||
- **Los certificados no siempre se inspeccionan correctamente** por las aplicaciones Android. Es común que estas aplicaciones pasen por alto las advertencias y acepten self-signed certificates o, en algunos casos, vuelvan a usar conexiones HTTP.
|
||||
- **Las negociaciones durante el handshake SSL/TLS a veces son débiles**, empleando suites de cifrado inseguras. Esta vulnerabilidad hace la conexión susceptible a ataques man-in-the-middle (MITM), permitiendo a los atacantes descifrar los datos.
|
||||
- **Filtración de información privada** es un riesgo cuando las aplicaciones se autentican usando canales seguros pero luego se comunican por canales no seguros para otras transacciones. Este enfoque no protege datos sensibles, como cookies de sesión o detalles del usuario, de la interceptación por entidades maliciosas.
|
||||
|
||||
#### Verificación de certificados
|
||||
#### Certificate Verification
|
||||
|
||||
Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe verificarse para mejorar la seguridad. Esto es crucial porque configuraciones TLS inseguras y la transmisión de datos sensibles por canales no cifrados pueden suponer riesgos significativos. Para pasos detallados sobre cómo verificar certificados de servidor y mitigar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) ofrece una guía completa.
|
||||
Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe verificarse para mejorar la seguridad. Esto es crucial porque las configuraciones TLS inseguras y la transmisión de datos sensibles por canales no cifrados pueden suponer riesgos significativos. For detailed steps on verifying server certificates and addressing vulnerabilities, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) provides comprehensive guidance.
|
||||
|
||||
#### SSL Pinning
|
||||
|
||||
SSL Pinning es una medida de seguridad donde la aplicación verifica el certificado del servidor frente a una copia conocida almacenada dentro de la propia aplicación. Este método es esencial para prevenir ataques MITM. Se recomienda implementar SSL Pinning en aplicaciones que manejan información sensible.
|
||||
SSL Pinning es una medida de seguridad en la que la aplicación verifica el certificado del servidor frente a una copia conocida almacenada dentro de la propia aplicación. Este método es esencial para prevenir ataques MITM. Se recomienda encarecidamente implementar SSL Pinning en aplicaciones que manejen información sensible.
|
||||
|
||||
#### Inspección de tráfico
|
||||
#### Traffic Inspection
|
||||
|
||||
Para inspeccionar tráfico HTTP es necesario **instalar el certificado del proxy** (por ejemplo, Burp). Sin instalar este certificado, el tráfico cifrado podría no ser visible a través del proxy. Para una guía sobre cómo instalar un certificado CA personalizado, [**haz clic aquí**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
To inspect HTTP traffic, it's necessary to **install the proxy tool's certificate** (e.g., Burp). Without installing this certificate, encrypted traffic might not be visible through the proxy. For a guide on installing a custom CA certificate, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
|
||||
Las aplicaciones dirigidas a **API Level 24 and above** requieren modificaciones en el Network Security Config para aceptar el certificado CA del proxy. Este paso es crítico para inspeccionar tráfico cifrado. Para instrucciones sobre cómo modificar el Network Security Config, [**consulta este tutorial**](make-apk-accept-ca-certificate.md).
|
||||
Applications targeting **API Level 24 and above** require modifications to the Network Security Config to accept the proxy's CA certificate. This step is critical for inspecting encrypted traffic. For instructions on modifying the Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
Si se está usando **Flutter** debes seguir las instrucciones en [**esta página**](flutter.md). Esto se debe a que, simplemente añadiendo el certificado al store no funcionará ya que Flutter tiene su propia lista de CAs válidas.
|
||||
If **Flutter** is being used you need to to follow the instructions in [**this page**](flutter.md). This is becasue, just adding the certificate into the store won't work as Flutter has its own list of valid CAs.
|
||||
|
||||
#### Detección estática de SSL/TLS pinning
|
||||
#### Static detection of SSL/TLS pinning
|
||||
|
||||
Antes de intentar bypasses en tiempo de ejecución, mapea rápidamente dónde se aplica el pinning en el APK. El descubrimiento estático te ayuda a planificar hooks/patches y a centrarte en las rutas de código correctas.
|
||||
|
||||
Tool: SSLPinDetect
|
||||
- Utilidad open-source de análisis estático que descompila el APK a Smali (vía apktool) y escanea patrones regex curados de implementaciones de SSL/TLS pinning.
|
||||
- Reporta la ruta exacta del archivo, número de línea y un snippet de código para cada coincidencia.
|
||||
- Cubre frameworks comunes y rutas de código personalizadas: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init con TrustManagers/KeyManagers personalizados, y pins en Network Security Config XML.
|
||||
- Utilidad de análisis estático de código abierto que decompila el APK a Smali (via apktool) y escanea patrones regex curados de implementaciones de SSL/TLS pinning.
|
||||
- Informa la ruta exacta del archivo, número de línea y un fragmento de código para cada coincidencia.
|
||||
- Cubre frameworks comunes y rutas de código personalizadas: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
|
||||
|
||||
Install
|
||||
- Prereqs: Python >= 3.8, Java on PATH, apktool
|
||||
- Requisitos previos: Python >= 3.8, Java on PATH, apktool
|
||||
```bash
|
||||
git clone https://github.com/aancw/SSLPinDetect
|
||||
cd SSLPinDetect
|
||||
@ -454,8 +464,8 @@ python sslpindetect.py -f app.apk -a apktool.jar
|
||||
# Verbose (timings + per-match path:line + snippet)
|
||||
python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
|
||||
```
|
||||
Ejemplo de reglas de patrones (JSON)
|
||||
Utiliza o amplía signatures para detectar estilos de pinning propietarios/personalizados. Puedes cargar tu propio JSON y escanear a gran escala.
|
||||
Ejemplo de reglas de patrón (JSON)
|
||||
Usa o extiende signatures para detectar estilos propietarios/personalizados de pinning. Puedes cargar tu propio JSON y escanear a gran escala.
|
||||
```json
|
||||
{
|
||||
"OkHttp Certificate Pinning": [
|
||||
@ -469,43 +479,43 @@ Utiliza o amplía signatures para detectar estilos de pinning propietarios/perso
|
||||
]
|
||||
}
|
||||
```
|
||||
Notes and tips
|
||||
- Escaneo rápido en aplicaciones grandes mediante multi-threading y memory-mapped I/O; las regex precompiladas reducen la sobrecarga y los falsos positivos.
|
||||
- Pattern collection: https://github.com/aancw/smali-sslpin-patterns
|
||||
Notas y consejos
|
||||
- Escaneo rápido en aplicaciones grandes mediante multi-threading y I/O mapeado en memoria; regex precompilados reducen la sobrecarga/falsos positivos.
|
||||
- Colección de patrones: https://github.com/aancw/smali-sslpin-patterns
|
||||
- Objetivos típicos de detección para priorizar a continuación:
|
||||
- OkHttp: uso de CertificatePinner, setCertificatePinner, referencias al paquete okhttp3/okhttp
|
||||
- TrustManagers personalizados: javax.net.ssl.X509TrustManager, overrides de checkServerTrusted
|
||||
- Contextos SSL personalizados: SSLContext.getInstance + SSLContext.init con managers personalizados
|
||||
- Pins declarativos en res/xml network security config y referencias en el manifest
|
||||
- Usa las ubicaciones coincidentes para planear Frida hooks, parches estáticos o revisiones de configuración antes de las pruebas dinámicas.
|
||||
- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references
|
||||
- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides
|
||||
- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers
|
||||
- Declarative pins in res/xml network security config and manifest references
|
||||
- Usa las ubicaciones coincidentes para planear Frida hooks, parches estáticos o revisiones de config antes de las pruebas dinámicas.
|
||||
|
||||
|
||||
|
||||
#### Evasión de SSL Pinning
|
||||
|
||||
Cuando se implementa SSL Pinning, es necesario evadirlo para inspeccionar el tráfico HTTPS. Existen varios métodos para este propósito:
|
||||
When SSL Pinning is implemented, bypassing it becomes necessary to inspect HTTPS traffic. Various methods are available for this purpose:
|
||||
|
||||
- Automáticamente **modifica** el **apk** para **evadir** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). La mayor ventaja de esta opción es que no necesitarás root para evadir el SSL Pinning, pero tendrás que borrar la aplicación e instalar la nueva, y esto no siempre funcionará.
|
||||
- Puedes usar **Frida** (visto abajo) para evadir esta protección. Aquí tienes una guía para usar 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/)
|
||||
- También puedes intentar **evadir automáticamente SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- También puedes intentar **evadir automáticamente SSL Pinning** usando el análisis dinámico de **MobSF** (explicado abajo)
|
||||
- Si aún crees que hay tráfico que no estás capturando, puedes intentar reenviar el tráfico a Burp usando iptables. Lee este blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
|
||||
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
|
||||
- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use 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/)
|
||||
- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
|
||||
- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
|
||||
|
||||
#### Buscando vulnerabilidades web comunes
|
||||
#### Looking for Common Web Vulnerabilities
|
||||
|
||||
También es importante buscar vulnerabilidades web comunes dentro de la aplicación. La información detallada sobre cómo identificarlas y mitigarlas excede el alcance de este resumen pero está ampliamente cubierta en otros lugares.
|
||||
Es importante también buscar vulnerabilidades web comunes dentro de la aplicación. La información detallada sobre cómo identificar y mitigar estas vulnerabilidades excede el alcance de este resumen, pero está ampliamente cubierta en otros recursos.
|
||||
|
||||
### Frida
|
||||
|
||||
[Frida](https://www.frida.re) es un toolkit de instrumentación dinámica para desarrolladores, ingenieros inversos e investigadores de seguridad.\
|
||||
**Puedes acceder a la aplicación en ejecución y hookear métodos en tiempo de ejecución para cambiar el comportamiento, modificar valores, extraer valores, ejecutar código diferente...**\
|
||||
Si quieres pentest aplicaciones Android necesitas saber cómo usar Frida.
|
||||
[Frida](https://www.frida.re) is a dynamic instrumentation toolkit for developers, reverse-engineers, and security researchers.\
|
||||
**Puedes acceder a la aplicación en ejecución y hacer hook a métodos en tiempo de ejecución para cambiar el comportamiento, modificar valores, extraer valores, ejecutar código diferente...**\
|
||||
Si quieres pentestear aplicaciones Android necesitas saber cómo usar Frida.
|
||||
|
||||
- Aprende a usar Frida: [**Frida tutorial**](frida-tutorial/index.html)
|
||||
- Algunas "GUI" para acciones con Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Ojection es genial para automatizar el uso de Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
|
||||
- Algunas GUI para acciones con Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Objection es ideal para automatizar el uso de Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
|
||||
- Puedes encontrar algunos scripts Awesome de Frida aquí: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
- Intenta evadir mecanismos anti-debugging / anti-frida cargando Frida como se indica en [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (herramienta [linjector](https://github.com/erfur/linjector-rs))
|
||||
- Intenta eludir mecanismos anti-debugging / anti-frida cargando Frida como se indica en [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (herramienta [linjector](https://github.com/erfur/linjector-rs))
|
||||
|
||||
#### Anti-instrumentation & SSL pinning bypass workflow
|
||||
|
||||
@ -513,11 +523,11 @@ Si quieres pentest aplicaciones Android necesitas saber cómo usar Frida.
|
||||
android-anti-instrumentation-and-ssl-pinning-bypass.md
|
||||
{{#endref}}
|
||||
|
||||
### **Volcar memoria - Fridump**
|
||||
### **Volcado de memoria - Fridump**
|
||||
|
||||
Comprueba si la aplicación está almacenando información sensible en la memoria que no debería, como contraseñas o mnemónicos.
|
||||
Comprueba si la aplicación está almacenando información sensible en la memoria que no debería guardar, como contraseñas o mnemónicos.
|
||||
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) puedes volcar la memoria de la app con:
|
||||
Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with:
|
||||
```bash
|
||||
# With PID
|
||||
python3 fridump3.py -u <PID>
|
||||
@ -526,35 +536,35 @@ python3 fridump3.py -u <PID>
|
||||
frida-ps -Uai
|
||||
python3 fridump3.py -u "<Name>"
|
||||
```
|
||||
Esto volcará la memoria en la carpeta ./dump, y allí podrías hacer grep con algo como:
|
||||
Esto volcará la memoria en la carpeta ./dump, y allí podrías usar grep con algo como:
|
||||
```bash
|
||||
strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
|
||||
```
|
||||
### **Datos sensibles en Keystore**
|
||||
|
||||
En Android, el Keystore es el mejor lugar para almacenar datos sensibles; sin embargo, con suficientes privilegios todavía es **posible acceder a él**. Como las aplicaciones tienden a almacenar aquí **datos sensibles en texto claro**, los pentests deberían comprobarlo, ya que un root user o alguien con acceso físico al dispositivo podría robar estos datos.
|
||||
En Android el Keystore es el mejor lugar para almacenar datos sensibles; sin embargo, con privilegios suficientes todavía es **posible acceder a él**. Como las aplicaciones tienden a almacenar aquí **datos sensibles en texto plano**, los pentests deberían comprobarlo como root user, o alguien con acceso físico al dispositivo podría robar estos datos.
|
||||
|
||||
Incluso si una app almacenara datos en el Keystore, los datos deberían estar cifrados.
|
||||
Incluso si una app almacenara datos en el keystore, los datos deberían estar cifrados.
|
||||
|
||||
Para acceder a los datos dentro del Keystore puedes usar este script de Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
|
||||
Para acceder a los datos dentro del keystore puedes usar este Frida script: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
|
||||
```bash
|
||||
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **Fingerprint/Biometrics Bypass**
|
||||
|
||||
Usando el siguiente script de Frida podría ser posible **bypass fingerprint authentication** que las aplicaciones Android podrían estar realizando para **proteger ciertas áreas sensibles:**
|
||||
Usando el siguiente script de Frida, podría ser posible realizar un **bypass fingerprint authentication** que las aplicaciones Android llevan a cabo para **proteger ciertas áreas sensibles:**
|
||||
```bash
|
||||
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
||||
```
|
||||
### **Imágenes de fondo**
|
||||
|
||||
Cuando pones una aplicación en segundo plano, Android almacena una **instantánea de la aplicación** para que, cuando se recupere al primer plano, comience a cargar la imagen antes que la propia aplicación, haciendo que parezca que se carga más rápido.
|
||||
Cuando pones una aplicación en segundo plano, Android guarda una **instantánea de la aplicación** de modo que, cuando se recupera al primer plano, comienza cargando la imagen antes que la app para que parezca que la aplicación se cargó más rápido.
|
||||
|
||||
Sin embargo, si esta instantánea contiene **información sensible**, alguien con acceso a la instantánea podría **robar esa información** (nota: se necesita root para acceder a ella).
|
||||
Sin embargo, si esta instantánea contiene **información sensible**, alguien con acceso a la instantánea podría **robar esa información** (ten en cuenta que necesitas root para acceder a ella).
|
||||
|
||||
Las instantáneas suelen almacenarse en: **`/data/system_ce/0/snapshots`**
|
||||
Las instantáneas normalmente se almacenan en: **`/data/system_ce/0/snapshots`**
|
||||
|
||||
Android proporciona una forma de **evitar la captura de pantalla configurando el parámetro de layout FLAG_SECURE**. Al usar esta flag, el contenido de la ventana se trata como seguro, impidiendo que aparezca en capturas de pantalla o que se vea en pantallas no seguras.
|
||||
Android proporciona una forma de **evitar la captura de pantalla configurando el parámetro de layout FLAG_SECURE**. Al usar este flag, el contenido de la ventana se trata como seguro, evitando que aparezca en capturas de pantalla o que sea visible en pantallas no seguras.
|
||||
```bash
|
||||
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
@ -564,53 +574,53 @@ Esta herramienta puede ayudarte a gestionar diferentes herramientas durante el a
|
||||
|
||||
### Intent Injection
|
||||
|
||||
Los desarrolladores a menudo crean componentes proxy como activities, services y broadcast receivers que manejan estos Intents y los pasan a métodos como `startActivity(...)` o `sendBroadcast(...)`, lo cual puede ser arriesgado.
|
||||
Los desarrolladores suelen crear componentes proxy como activities, services y broadcast receivers que manejan estos Intents y los pasan a métodos como `startActivity(...)` o `sendBroadcast(...)`, lo cual puede ser arriesgado.
|
||||
|
||||
El peligro radica en permitir que atacantes activen componentes de la app no exportados o accedan a content providers sensibles al redirigir estos Intents. Un ejemplo notable es el componente `WebView` que convierte URLs en objetos `Intent` mediante `Intent.parseUri(...)` y luego los ejecuta, lo que puede conducir a malicious Intent injections.
|
||||
El peligro radica en permitir que atacantes desencadenen componentes no exportados de la app o accedan a content providers sensibles al redirigir estos Intents. Un ejemplo notable es el componente `WebView` que convierte URLs en objetos `Intent` mediante `Intent.parseUri(...)` y luego los ejecuta, lo que puede conducir a inyecciones maliciosas de Intent.
|
||||
|
||||
### Conclusiones esenciales
|
||||
### Essential Takeaways
|
||||
|
||||
- **Intent Injection** es similar al Open Redirect de la web.
|
||||
- **Intent Injection** es similar al problema web de Open Redirect.
|
||||
- Los exploits implican pasar objetos `Intent` como extras, que pueden ser redirigidos para ejecutar operaciones inseguras.
|
||||
- Puede exponer componentes no exportados y content providers a atacantes.
|
||||
- La conversión de URLs a `Intent` que realiza `WebView` puede facilitar acciones no intencionadas.
|
||||
- La conversión de URL a `Intent` de `WebView` puede facilitar acciones no deseadas.
|
||||
|
||||
### Inyecciones del lado cliente en Android y otras
|
||||
### Android Client Side Injections and others
|
||||
|
||||
Probablemente conozcas este tipo de vulnerabilidades por la Web. Debes tener especial cuidado con estas vulnerabilidades en una aplicación Android:
|
||||
|
||||
- **SQL Injection:** Al manejar queries dinámicas o Content-Providers, asegúrate de usar consultas parametrizadas.
|
||||
- **JavaScript Injection (XSS):** Verifica que el soporte de JavaScript y Plugins esté deshabilitado para cualquier WebView (deshabilitado por defecto). [Más info aquí](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** Los WebViews deberían tener el acceso al sistema de archivos deshabilitado (habilitado por defecto) - `(webview.getSettings().setAllowFileAccess(false);)`. [Más info aquí](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: En varios casos cuando la aplicación android termina la sesión, la cookie no se revoca o incluso puede guardarse en disco
|
||||
- **SQL Injection:** Al tratar consultas dinámicas o Content-Providers, asegúrate de usar consultas parametrizadas.
|
||||
- **JavaScript Injection (XSS):** Verifica que el soporte de JavaScript y Plugins esté deshabilitado para cualquier WebView (deshabilitado por defecto). [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** Los WebViews deberían tener el acceso al sistema de archivos deshabilitado (habilitado por defecto) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: En varios casos cuando la aplicación Android finaliza la sesión la cookie no se revoca o incluso puede guardarse en disco.
|
||||
- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
---
|
||||
|
||||
## Análisis automático
|
||||
## Automatic Analysis
|
||||
|
||||
### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
|
||||
|
||||
**Análisis estático**
|
||||
**Static analysis**
|
||||
|
||||
.png>)
|
||||
|
||||
**Evaluación de vulnerabilidades de la aplicación** usando una interfaz web agradable. También puedes realizar análisis dinámico (pero necesitas preparar el entorno).
|
||||
**Evaluación de vulnerabilidades de la aplicación** utilizando una agradable interfaz web. También puedes realizar análisis dinámico (pero necesitas preparar el entorno).
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf
|
||||
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
```
|
||||
Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
|
||||
Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also.
|
||||
Nota que MobSF puede analizar **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
|
||||
Además, si creas un archivo **ZIP** con el código fuente de una app **Android** o **IOS** (ve a la carpeta raíz de la aplicación, selecciona todo y crea un ZIPfile), también podrá analizarlo.
|
||||
|
||||
MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file.
|
||||
MobSF también te permite hacer **diff/Compare** de análisis e integrar **VirusTotal** (necesitarás configurar tu API key en _MobSF/settings.py_ y habilitarlo: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). También puedes poner `VT_UPLOAD` a `False`, entonces el **hash** será **upload** en vez del fichero.
|
||||
|
||||
### Assisted Dynamic analysis with MobSF
|
||||
|
||||
**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
|
||||
The **MobSF dynamic analyser** can:
|
||||
**MobSF** también puede ser muy útil para el **dynamic analysis** en **Android**, pero en ese caso necesitarás instalar MobSF y **genymotion** en tu host (una VM o Docker no funcionarán). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
|
||||
El **MobSF dynamic analyser** puede:
|
||||
|
||||
- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities.
|
||||
- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Todo esto se hace automáticamente excepto las capturas de pantalla, debes pulsar cuando quieras una captura o tienes que pulsar "**Exported Activity Tester**" para obtener capturas de todas las actividades exportadas.
|
||||
- Capture **HTTPS traffic**
|
||||
- Use **Frida** to obtain **runtime** **information**
|
||||
|
||||
@ -628,18 +638,18 @@ MobSF also allows you to load your own **Frida scripts** (to send the results of
|
||||
|
||||
Moreover, you have some Auxiliary Frida functionalities:
|
||||
|
||||
- **Enumerate Loaded Classes**: It will print all the loaded classes
|
||||
- **Capture Strings**: It will print all the capture strings while using the application (super noisy)
|
||||
- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False.
|
||||
- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class.
|
||||
- **Search Class Pattern**: Search classes by pattern
|
||||
- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods.
|
||||
- **Enumerate Loaded Classes**: Imprime todas las clases cargadas
|
||||
- **Capture Strings**: Imprime todas las capture strings mientras usas la aplicación (muy ruidoso)
|
||||
- **Capture String Comparisons**: Puede ser muy útil. **Muestra las 2 strings que se están comparando** y si el resultado fue True o False.
|
||||
- **Enumerate Class Methods**: Introduce el nombre de la clase (como "java.io.File") y mostrará todos los métodos de la clase.
|
||||
- **Search Class Pattern**: Buscar clases por patrón
|
||||
- **Trace Class Methods**: **Trace** a **whole class** (ver entradas y salidas de todos los métodos de la clase). Recuerda que por defecto MobSF traza varios métodos Android API interesantes.
|
||||
|
||||
Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**".
|
||||
Una vez que hayas seleccionado el módulo auxiliar que quieres usar debes pulsar "**Start Intrumentation**" y verás todas las salidas en "**Frida Live Logs**".
|
||||
|
||||
**Shell**
|
||||
|
||||
Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands:
|
||||
Mobsf también te proporciona un shell con algunos comandos **adb**, **MobSF commands**, y comunes **shell** **commands** en la parte inferior de la página de dynamic analysis. Algunos comandos interesantes:
|
||||
```bash
|
||||
help
|
||||
shell ls
|
||||
@ -650,32 +660,32 @@ receivers
|
||||
```
|
||||
**Herramientas HTTP**
|
||||
|
||||
Cuando el tráfico HTTP es capturado puedes ver una vista fea del tráfico capturado en el botón "**HTTP(S) Traffic**" inferior o una vista más agradable en el botón verde "**Start HTTPTools**". Desde la segunda opción, puedes **enviar** las **solicitudes capturadas** a **proxies** como Burp o Owasp ZAP.\
|
||||
Para ello, _enciende Burp -->_ _desactiva Intercept --> en MobSB HTTPTools selecciona la solicitud_ --> pulsa "**Send to Fuzzer**" --> _selecciona la dirección del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bottom or a nicer view in "**Start HTTPTools**" green bottom. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\
|
||||
To do so, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Una vez finalices el análisis dinámico con MobSF puedes pulsar "**Start Web API Fuzzer**" para **fuzz http requests** y buscar vulnerabilidades.
|
||||
Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz http requests** an look for vulnerabilities.
|
||||
|
||||
> [!TIP]
|
||||
> Después de realizar un análisis dinámico con MobSF la configuración del proxy puede quedar mal configurada y no podrás arreglarla desde la GUI. Puedes corregir la configuración del proxy haciendo:
|
||||
> After performing a dynamic analysis with MobSF the proxy settings me be misconfigured and you won't be able to fix them from the GUI. You can fix the proxy settings by doing:
|
||||
>
|
||||
> ```
|
||||
> adb shell settings put global http_proxy :0
|
||||
> ```
|
||||
|
||||
### Análisis Dinámico Asistido con Inspeckage
|
||||
### Análisis dinámico asistido con Inspeckage
|
||||
|
||||
Puedes obtener la herramienta desde [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
Esta herramienta usará algunos **Hooks** para informarte **qué está sucediendo en la aplicación** mientras realizas un **análisis dinámico**.
|
||||
You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
Esta herramienta usará algunos **Hooks** para informarte **lo que está ocurriendo en la aplicación** mientras realizas un **dynamic analysis**.
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
|
||||
Esta es una **excelente herramienta para realizar análisis estático con una GUI**
|
||||
Esta es una **gran herramienta para realizar static analysis con GUI**
|
||||
|
||||
.png>)
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
Esta herramienta está diseñada para buscar varias **vulnerabilidades de aplicaciones Android relacionadas con la seguridad**, ya sea en **código fuente** o en **APKs empaquetados**. La herramienta también es **capaz de crear un APK desplegable "Proof-of-Concept"** y **ADB commands**, para explotar algunas de las vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Al igual que con Drozer, no es necesario rootear el dispositivo de prueba.
|
||||
Esta herramienta está diseñada para buscar varias **security related Android application vulnerabilities**, ya sea en **source code** o en **packaged APKs**. La herramienta también es **capable of creating a "Proof-of-Concept" deployable APK** y **ADB commands**, para explotar algunas de las vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como con Drozer, no es necesario rootear el dispositivo de prueba.
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -684,8 +694,8 @@ qark --java path/to/specific/java/file.java
|
||||
```
|
||||
### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
|
||||
|
||||
- Muestra todos los archivos extraídos para facilitar la consulta
|
||||
- Descompila automáticamente archivos APK a formato Java y Smali
|
||||
- Muestra todos los archivos extraídos para referencia fácil
|
||||
- Decompila automáticamente archivos APK a formato Java y Smali
|
||||
- Analiza AndroidManifest.xml en busca de vulnerabilidades y comportamientos comunes
|
||||
- Análisis estático del código fuente en busca de vulnerabilidades y comportamientos comunes
|
||||
- Información del dispositivo
|
||||
@ -695,9 +705,9 @@ reverse-apk relative/path/to/APP.apk
|
||||
```
|
||||
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
|
||||
|
||||
SUPER es una aplicación de línea de comandos que puede usarse en Windows, MacOS X y Linux, y que analiza archivos _.apk_ en busca de vulnerabilidades. Lo hace descomprimiendo APKs y aplicando una serie de reglas para detectar esas vulnerabilidades.
|
||||
SUPER es una aplicación de línea de comandos que puede usarse en Windows, MacOS X y Linux, que analiza archivos _.apk_ en busca de vulnerabilidades. Lo hace descomprimiendo APKs y aplicando una serie de reglas para detectar dichas vulnerabilidades.
|
||||
|
||||
Todas las reglas están centralizadas en un archivo `rules.json`, y cada empresa o tester puede crear sus propias reglas para analizar lo que necesite.
|
||||
Todas las reglas están centralizadas en un archivo `rules.json`, y cada empresa o tester puede crear sus propias reglas para analizar lo que necesiten.
|
||||
|
||||
Descarga los últimos binarios desde la [download page](https://superanalyzer.rocks/download.html)
|
||||
```
|
||||
@ -707,17 +717,17 @@ super-analyzer {apk_file}
|
||||
|
||||
.png>)
|
||||
|
||||
StaCoAn es una herramienta **crossplatform** que ayuda a desarrolladores, bugbounty hunters y ethical hackers a realizar [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) en aplicaciones móviles.
|
||||
StaCoAn es una herramienta **multiplataforma** que ayuda a desarrolladores, bugbounty hunters y hackers éticos a realizar [análisis estático de código](https://en.wikipedia.org/wiki/Static_program_analysis) en aplicaciones móviles.
|
||||
|
||||
El concepto es que arrastres y sueltes el archivo de tu aplicación móvil (un .apk o .ipa file) en la aplicación StaCoAn y ésta generará un informe visual y portable para ti. Puedes ajustar la configuración y las wordlists para obtener una experiencia personalizada.
|
||||
El concepto es que arrastras y sueltas el archivo de tu aplicación móvil (un archivo .apk o .ipa) sobre la aplicación StaCoAn y esta generará un informe visual y portátil para ti. Puedes ajustar la configuración y las wordlists para obtener una experiencia personalizada.
|
||||
|
||||
Descargar[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
Descargar [última versión](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
./stacoan
|
||||
```
|
||||
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
|
||||
|
||||
AndroBugs Framework es un sistema de análisis de vulnerabilidades para Android que ayuda a desarrolladores o hackers a encontrar posibles vulnerabilidades de seguridad en aplicaciones Android.\
|
||||
AndroBugs Framework es un sistema de análisis de vulnerabilidades para Android que ayuda a desarrolladores o hackers a encontrar vulnerabilidades de seguridad potenciales en aplicaciones Android.\
|
||||
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
|
||||
```
|
||||
python androbugs.py -f [APK file]
|
||||
@ -727,9 +737,9 @@ androbugs.exe -f [APK file]
|
||||
|
||||
**Androwarn** es una herramienta cuyo objetivo principal es detectar y advertir al usuario sobre posibles comportamientos maliciosos desarrollados por una aplicación Android.
|
||||
|
||||
La detección se realiza mediante el **análisis estático** del bytecode Dalvik de la aplicación, representado como **Smali**, con la librería [`androguard`](https://github.com/androguard/androguard).
|
||||
La detección se realiza mediante el **static analysis** del Dalvik bytecode de la aplicación, representado como **Smali**, con la librería [`androguard`](https://github.com/androguard/androguard).
|
||||
|
||||
Esta herramienta busca **comportamientos comunes de aplicaciones "malas"** como: exfiltración de identificadores de telefonía, intercepción de flujos de audio/video, modificación de datos PIM, ejecución arbitraria de código...
|
||||
Esta herramienta busca **comportamientos comunes de "bad" applications** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
|
||||
```
|
||||
python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
```
|
||||
@ -737,15 +747,15 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
|
||||
.png>)
|
||||
|
||||
**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Es una herramienta que reúne herramientas comúnmente usadas de reverse engineering y análisis de aplicaciones móviles, para ayudar en las pruebas de aplicaciones móviles frente a las amenazas de seguridad móviles de OWASP. Su objetivo es hacer esta tarea más fácil y accesible para desarrolladores de aplicaciones móviles y profesionales de seguridad.
|
||||
**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Es una herramienta que agrupa herramientas comúnmente usadas de reverse engineering y analysis de aplicaciones móviles, para ayudar en las pruebas de aplicaciones móviles frente a las amenazas de seguridad móvil de OWASP. Su objetivo es hacer esta tarea más fácil y accesible para desarrolladores de aplicaciones móviles y profesionales de seguridad.
|
||||
|
||||
It is able to:
|
||||
|
||||
- Extract Java and Smali code using different tools
|
||||
- Analyze APKs using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
|
||||
- Extract private information from the APK using regexps.
|
||||
- Analyze the Manifest.
|
||||
- Analyze found domains using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- Extraer código Java y Smali usando diferentes herramientas
|
||||
- Analizar APKs usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
|
||||
- Extraer información privada del APK usando regexps.
|
||||
- Analizar el Manifest.
|
||||
- Analizar dominios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com)
|
||||
|
||||
### Koodous
|
||||
@ -754,19 +764,19 @@ It is able to:
|
||||
|
||||
## Obfuscating/Deobfuscating code
|
||||
|
||||
Ten en cuenta que, dependiendo del servicio y la configuración que uses para ofuscar el código, los secretos pueden o no quedar ofuscados.
|
||||
Ten en cuenta que, dependiendo del servicio y la configuración que utilices para obfuscate el código, los Secrets pueden o no terminar obfuscated.
|
||||
|
||||
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
|
||||
|
||||
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. It is able to optimize bytecode as well as detect and remove unused instructions. ProGuard is free software and is distributed under the GNU General Public License, version 2.
|
||||
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. Es capaz de optimizar bytecode así como detectar y eliminar instrucciones no utilizadas. ProGuard es software libre y se distribuye bajo la GNU General Public License, versión 2.
|
||||
|
||||
ProGuard is distributed as part of the Android SDK and runs when building the application in release mode.
|
||||
ProGuard se distribuye como parte del Android SDK y se ejecuta al construir la aplicación en release mode.
|
||||
|
||||
### [DexGuard](https://www.guardsquare.com/dexguard)
|
||||
|
||||
Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
Encuentra una guía paso a paso para deobfuscate el apk en [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
|
||||
(From that guide) Last time we checked, the Dexguard mode of operation was:
|
||||
(From that guide) La última vez que lo comprobamos, el modo de operación de Dexguard era:
|
||||
|
||||
- load a resource as an InputStream;
|
||||
- feed the result to a class inheriting from FilterInputStream to decrypt it;
|
||||
@ -778,29 +788,29 @@ Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexgu
|
||||
|
||||
**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
|
||||
|
||||
Puedes subir un APK ofuscado a su plataforma.
|
||||
Puedes subir un APK obfuscated a su plataforma.
|
||||
|
||||
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
|
||||
|
||||
This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API.
|
||||
Esta es una herramienta LLM para encontrar posibles vulnerabilidades de seguridad en android apps y deobfuscate android app code. Usa la Gemini public API de Google.
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
It is a **generic android deobfuscator.** Simplify **virtually executes an app** to understand its behavior and then **tries to optimize the code** so it behaves identically but is easier for a human to understand. Each optimization type is simple and generic, so it doesn't matter what the specific type of obfuscation is used.
|
||||
It is a **generic android deobfuscator.** Simplify **virtually executes an app** para entender su comportamiento y luego **tries to optimize the code** para que se comporte idénticamente pero sea más fácil para un humano entender. Cada tipo de optimización es simple y generic, por lo que no importa qué tipo específico de obfuscation se use.
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
APKiD gives you information about **how an APK was made**. It identifies many **compilers**, **packers**, **obfuscators**, and other weird stuff. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android.
|
||||
APKiD te da información sobre **how an APK was made**. Identifica muchos **compilers**, **packers**, **obfuscators**, y otras cosas raras. Es [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
|
||||
|
||||
### Manual
|
||||
|
||||
[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
|
||||
[Lee este tutorial para aprender algunos trucos sobre **how to reverse custom obfuscation**](manual-deobfuscation.md)
|
||||
|
||||
## Labs
|
||||
|
||||
### [Androl4b](https://github.com/sh4hin/Androl4b)
|
||||
|
||||
AndroL4b is an Android security virtual machine based on ubuntu-mate includes the collection of latest framework, tutorials and labs from different security geeks and researchers for reverse engineering and malware analysis.
|
||||
AndroL4b es una Android security virtual machine basada en ubuntu-mate que incluye la colección de los últimos framework, tutorials y labs de diferentes security geeks y researchers para reverse engineering y malware analysis.
|
||||
|
||||
## References
|
||||
|
||||
@ -813,6 +823,7 @@ AndroL4b is an Android security virtual machine based on ubuntu-mate includes th
|
||||
- [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097)
|
||||
- [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect)
|
||||
- [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns)
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
|
||||
## Yet to try
|
||||
|
||||
|
||||
@ -2,28 +2,28 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Esta página proporciona un flujo de trabajo práctico para recuperar el análisis dinámico contra aplicaciones Android que detectan/bloquean instrumentación por root o aplican TLS pinning. Se centra en un triage rápido, detecciones comunes y hooks/tácticas copiables para evitarlas sin reempaquetar cuando sea posible.
|
||||
Esta página ofrece un flujo de trabajo práctico para recuperar el análisis dinámico contra aplicaciones Android que detectan/bloquean instrumentación por root o imponen TLS pinning. Se centra en triage rápido, detecciones comunes y hooks/tácticas copiables para eludirlas sin repackear cuando sea posible.
|
||||
|
||||
## Detection Surface (what apps check)
|
||||
## Superficie de detección (qué comprueban las apps)
|
||||
|
||||
- Root checks: su binary, Magisk paths, getprop values, common root packages
|
||||
- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs
|
||||
- Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
|
||||
- Early init checks: Application.onCreate() or process start hooks that crash if instrumentation is present
|
||||
- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins
|
||||
- Comprobaciones de root: su binario, rutas de Magisk, valores de getprop, paquetes comunes de root
|
||||
- Comprobaciones Frida/debugger (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), escaneo de /proc, classpath, librerías cargadas
|
||||
- Anti‑debug nativo: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
|
||||
- Comprobaciones en init temprano: Application.onCreate() u hooks de inicio de proceso que provocan crash si la instrumentación está presente
|
||||
- TLS pinning: TrustManager/HostnameVerifier personalizados, OkHttp CertificatePinner, Conscrypt pinning, pins nativos
|
||||
|
||||
## Step 1 — Quick win: hide root with Magisk DenyList
|
||||
## Paso 1 — Victoria rápida: ocultar root con Magisk DenyList
|
||||
|
||||
- Enable Zygisk in Magisk
|
||||
- Enable DenyList, add the target package
|
||||
- Reboot and retest
|
||||
- Habilitar Zygisk en Magisk
|
||||
- Habilitar DenyList, añadir el paquete objetivo
|
||||
- Reiniciar y volver a probar
|
||||
|
||||
Muchas apps solo buscan indicadores obvios (su/Magisk paths/getprop). DenyList a menudo neutraliza comprobaciones ingenuas.
|
||||
Muchas apps solo buscan indicadores obvios (su/rutas de Magisk/getprop). DenyList a menudo neutraliza comprobaciones ingenuas.
|
||||
|
||||
Referencias:
|
||||
References:
|
||||
- Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk
|
||||
|
||||
## Step 2 — 30‑second Frida Codeshare tests
|
||||
## Paso 2 — Tests rápidos de 30 segundos con Frida Codeshare
|
||||
|
||||
Prueba scripts comunes drop‑in antes de profundizar:
|
||||
|
||||
@ -35,42 +35,59 @@ Example:
|
||||
```bash
|
||||
frida -U -f com.example.app -l anti-frida-detection.js
|
||||
```
|
||||
Estos típicamente crean stubs para las comprobaciones Java de root/debug, los escaneos de process/service y la ptrace() nativa. Útiles en apps con protección ligera; objetivos hardened pueden necesitar hooks personalizados.
|
||||
Normalmente crean stubs para las comprobaciones Java de root/debug, los process/service scans y la llamada nativa ptrace(). Útiles en apps poco protegidas; los objetivos reforzados pueden necesitar hooks personalizados.
|
||||
|
||||
- Codeshare: https://codeshare.frida.re/
|
||||
|
||||
## Paso 3 — Bypass init-time detectors by attaching late
|
||||
## Automatizar con Medusa (Frida framework)
|
||||
|
||||
Muchas detecciones sólo se ejecutan durante el spawn del proceso/onCreate(). La inyección en spawn‑time (-f) o los gadgets suelen ser detectados; adjuntar después de que la UI cargue puede pasar desapercibido.
|
||||
Medusa proporciona 90+ módulos listos para usar para SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception, y más.
|
||||
```bash
|
||||
git clone https://github.com/Ch0pin/medusa
|
||||
cd medusa
|
||||
pip install -r requirements.txt
|
||||
python medusa.py
|
||||
|
||||
# Example interactive workflow
|
||||
show categories
|
||||
use http_communications/multiple_unpinner
|
||||
use root_detection/universal_root_detection_bypass
|
||||
run com.target.app
|
||||
```
|
||||
Consejo: Medusa es ideal para conseguir victorias rápidas antes de escribir hooks personalizados. También puedes seleccionar módulos y combinarlos con tus propios scripts.
|
||||
|
||||
## Paso 3 — Evadir detectores en tiempo de inicialización adjuntando más tarde
|
||||
|
||||
Muchas detecciones sólo se ejecutan durante el spawn del proceso/onCreate(). Spawn‑time injection (-f) o gadgets son detectados; adjuntar después de que la UI cargue puede pasar desapercibido.
|
||||
```bash
|
||||
# Launch the app normally (launcher/adb), wait for UI, then attach
|
||||
frida -U -n com.example.app
|
||||
# Or with Objection to attach to running process
|
||||
aobjection --gadget com.example.app explore # if using gadget
|
||||
```
|
||||
Si esto funciona, mantén la sesión estable y procede a mapear y comprobar stubs.
|
||||
Si esto funciona, mantén la sesión estable y procede a mapear y comprobar los stubs.
|
||||
|
||||
## Paso 4 — Mapear la lógica de detección vía Jadx y búsqueda de cadenas
|
||||
## Paso 4 — Mapear la lógica de detección con Jadx y búsqueda de strings
|
||||
|
||||
Palabras clave de triage estático en Jadx:
|
||||
Static triage keywords in Jadx:
|
||||
- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger"
|
||||
|
||||
Patrones Java típicos:
|
||||
Typical Java patterns:
|
||||
```java
|
||||
public boolean isFridaDetected() {
|
||||
return getRunningServices().contains("frida");
|
||||
}
|
||||
```
|
||||
APIs comunes a revisar/hook:
|
||||
APIs comunes para revisar/hook:
|
||||
- android.os.Debug.isDebuggerConnected
|
||||
- android.app.ActivityManager.getRunningAppProcesses / getRunningServices
|
||||
- java.lang.System.loadLibrary / System.load (native bridge)
|
||||
- java.lang.Runtime.exec / ProcessBuilder (probing commands)
|
||||
- android.os.SystemProperties.get (root/emulator heuristics)
|
||||
|
||||
## Paso 5 — Runtime stubbing con Frida (Java)
|
||||
## Paso 5 — Sustitución en tiempo de ejecución con Frida (Java)
|
||||
|
||||
Anular guardias personalizados para devolver valores seguros sin reempaquetar:
|
||||
Sobrescribe validaciones personalizadas para devolver valores seguros sin reempaquetado:
|
||||
```js
|
||||
Java.perform(() => {
|
||||
const Checks = Java.use('com.example.security.Checks');
|
||||
@ -85,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager');
|
||||
AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); };
|
||||
});
|
||||
```
|
||||
¿Clasificando fallos tempranos? Dump classes justo antes de que muera para detectar posibles namespaces de detección:
|
||||
¿Clasificando fallos tempranos? Dump classes justo antes de que se cierre para identificar namespaces de detección probables:
|
||||
```js
|
||||
Java.perform(() => {
|
||||
Java.enumerateLoadedClasses({
|
||||
@ -94,7 +111,15 @@ onComplete: () => console.log('Done')
|
||||
});
|
||||
});
|
||||
```
|
||||
Log y neutraliza métodos sospechosos para confirmar el flujo de ejecución:
|
||||
// Quick root detection stub example (adapt to target package/class names)
|
||||
Java.perform(() => {
|
||||
try {
|
||||
const RootChecker = Java.use('com.target.security.RootCheck');
|
||||
RootChecker.isDeviceRooted.implementation = function () { return false; };
|
||||
} catch (e) {}
|
||||
});
|
||||
|
||||
Registra y neutraliza métodos sospechosos para confirmar el flujo de ejecución:
|
||||
```js
|
||||
Java.perform(() => {
|
||||
const Det = Java.use('com.example.security.DetectionManager');
|
||||
@ -104,24 +129,64 @@ return false;
|
||||
};
|
||||
});
|
||||
```
|
||||
## Paso 6 — Sigue la pista JNI/native cuando los hooks de Java fallan
|
||||
## Evadir la detección de emulador/VM (Java stubs)
|
||||
|
||||
Traza puntos de entrada JNI para localizar native loaders y detection init:
|
||||
Heurísticas comunes: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE que contienen generic/goldfish/ranchu/sdk; artefactos de QEMU como /dev/qemu_pipe, /dev/socket/qemud; MAC por defecto 02:00:00:00:00:00; NAT 10.0.2.x; ausencia de telefonía/sensores.
|
||||
|
||||
Falsificación rápida de campos Build:
|
||||
```js
|
||||
Java.perform(function(){
|
||||
var Build = Java.use('android.os.Build');
|
||||
Build.MODEL.value = 'Pixel 7 Pro';
|
||||
Build.MANUFACTURER.value = 'Google';
|
||||
Build.BRAND.value = 'google';
|
||||
Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys';
|
||||
});
|
||||
```
|
||||
Complementar con stubs para comprobaciones de existencia de archivos y identificadores (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) para devolver valores realistas.
|
||||
|
||||
## SSL pinning bypass quick hook (Java)
|
||||
|
||||
Neutraliza TrustManagers personalizados y fuerza contextos SSL permisivos:
|
||||
```js
|
||||
Java.perform(function(){
|
||||
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
|
||||
var SSLContext = Java.use('javax.net.ssl.SSLContext');
|
||||
|
||||
// No-op validations
|
||||
X509TrustManager.checkClientTrusted.implementation = function(){ };
|
||||
X509TrustManager.checkServerTrusted.implementation = function(){ };
|
||||
|
||||
// Force permissive TrustManagers
|
||||
var TrustManagers = [ X509TrustManager.$new() ];
|
||||
var SSLContextInit = SSLContext.init.overload('[Ljavax.net.ssl.KeyManager;','[Ljavax.net.ssl.TrustManager;','java.security.SecureRandom');
|
||||
SSLContextInit.implementation = function(km, tm, sr){
|
||||
return SSLContextInit.call(this, km, TrustManagers, sr);
|
||||
};
|
||||
});
|
||||
```
|
||||
Notas
|
||||
- Extender para OkHttp: hook okhttp3.CertificatePinner y HostnameVerifier según sea necesario, o usa un unpinning script universal de CodeShare.
|
||||
- Ejemplo de ejecución: `frida -U -f com.target.app -l ssl-bypass.js --no-pause`
|
||||
|
||||
## Paso 6 — Sigue la pista JNI/nativa cuando los hooks de Java fallen
|
||||
|
||||
Rastrea los puntos de entrada JNI para localizar cargadores nativos e inicialización de detección:
|
||||
```bash
|
||||
frida-trace -n com.example.app -i "JNI_OnLoad"
|
||||
```
|
||||
Clasificación rápida nativa de los archivos .so incluidos:
|
||||
Triage nativo rápido de archivos .so empaquetados:
|
||||
```bash
|
||||
# List exported symbols & JNI
|
||||
nm -D libfoo.so | head
|
||||
objdump -T libfoo.so | grep Java_
|
||||
strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root'
|
||||
```
|
||||
Reversing interactivo/nativo:
|
||||
Interactivo/nativo reversing:
|
||||
- Ghidra: https://ghidra-sre.org/
|
||||
- r2frida: https://github.com/nowsecure/r2frida
|
||||
|
||||
Ejemplo: neutralizar ptrace para eludir un anti‑debug simple en libc:
|
||||
Ejemplo: neutralizar ptrace para derrotar un simple anti‑debug en libc:
|
||||
```js
|
||||
const ptrace = Module.findExportByName(null, 'ptrace');
|
||||
if (ptrace) {
|
||||
@ -130,7 +195,7 @@ return -1; // pretend failure
|
||||
}, 'int', ['int', 'int', 'pointer', 'pointer']));
|
||||
}
|
||||
```
|
||||
Véase también:
|
||||
Ver también:
|
||||
{{#ref}}
|
||||
reversing-native-libraries.md
|
||||
{{#endref}}
|
||||
@ -142,21 +207,23 @@ Cuando prefieras repacking en lugar de runtime hooks, prueba:
|
||||
objection patchapk --source app.apk
|
||||
```
|
||||
Notas:
|
||||
- Requiere apktool; asegúrate de usar una versión actual siguiendo la guía oficial para evitar problemas de compilación: https://apktool.org/docs/install
|
||||
- Gadget injection permite instrumentation sin root, pero aún puede ser detectado por init‑time checks más estrictos.
|
||||
- Requiere apktool; asegúrate de una versión actual siguiendo la guía oficial para evitar problemas de compilación: https://apktool.org/docs/install
|
||||
- Gadget injection permite instrumentation sin root, pero aún puede ser detectado por init‑time checks más fuertes.
|
||||
|
||||
Opcionalmente, añade módulos LSPosed y Shamiko para un ocultamiento de root más sólido en entornos Zygisk, y configura DenyList para cubrir procesos hijo.
|
||||
|
||||
Referencias:
|
||||
- Objection: https://github.com/sensepost/objection
|
||||
|
||||
## Paso 8 — Solución alternativa: Parchear TLS pinning para visibilidad de la red
|
||||
## Paso 8 — Solución alternativa: Parchear TLS pinning para visibilidad de red
|
||||
|
||||
Si instrumentation está bloqueada, aún puedes inspeccionar el tráfico eliminando pinning de forma estática:
|
||||
Si instrumentation está bloqueado, aún puedes inspeccionar el tráfico eliminando el pinning de forma estática:
|
||||
```bash
|
||||
apk-mitm app.apk
|
||||
# Then install the patched APK and proxy via Burp/mitmproxy
|
||||
```
|
||||
- Herramienta: https://github.com/shroudedcode/apk-mitm
|
||||
- Para trucos de CA‑trust en la configuración de red (y la confianza de CA de usuario en Android 7+), ver:
|
||||
- Para trucos de confianza de CA en la configuración de red (y la confianza de CA de usuario en Android 7+), ver:
|
||||
|
||||
{{#ref}}
|
||||
make-apk-accept-ca-certificate.md
|
||||
@ -166,7 +233,7 @@ make-apk-accept-ca-certificate.md
|
||||
install-burp-certificate.md
|
||||
{{#endref}}
|
||||
|
||||
## Hoja de referencia rápida de comandos
|
||||
## Hoja de trucos de comandos útiles
|
||||
```bash
|
||||
# List processes and attach
|
||||
frida-ps -Uai
|
||||
@ -187,11 +254,11 @@ apk-mitm app.apk
|
||||
## Consejos y advertencias
|
||||
|
||||
- Prefiere attaching tarde en lugar de spawning cuando las apps se bloquean al iniciarse
|
||||
- Algunas detecciones se re‑ejecutan en flujos críticos (p. ej., payment, auth) — mantén los hooks activos durante la navegación
|
||||
- Combina estático y dinámico: string hunt en Jadx para preseleccionar clases; luego hookea métodos para verificar en tiempo de ejecución
|
||||
- Las apps reforzadas pueden usar packers y native TLS pinning — prepárate para revertir código nativo
|
||||
- Algunas detecciones se vuelven a ejecutar en flujos críticos (p. ej., payment, auth) — mantén los hooks activos durante la navegación
|
||||
- Mezcla estático y dinámico: string hunt en Jadx para acotar clases; luego hook methods para verificar en runtime
|
||||
- Las apps hardened pueden usar packers y native TLS pinning — espera tener que reverse native code
|
||||
|
||||
## References
|
||||
## Referencias
|
||||
|
||||
- [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/)
|
||||
- [Frida Codeshare](https://codeshare.frida.re/)
|
||||
@ -202,5 +269,7 @@ apk-mitm app.apk
|
||||
- [r2frida](https://github.com/nowsecure/r2frida)
|
||||
- [Apktool install guide](https://apktool.org/docs/install)
|
||||
- [Magisk](https://github.com/topjohnwu/Magisk)
|
||||
- [Medusa (Android Frida framework)](https://github.com/Ch0pin/medusa)
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,31 +4,31 @@
|
||||
|
||||
Muchas gracias a [**@offsecjay**](https://twitter.com/offsecjay) por su ayuda al crear este contenido.
|
||||
|
||||
## Qué es
|
||||
## ¿Qué es
|
||||
|
||||
Android Studio permite **ejecutar máquinas virtuales de Android que puedes usar para probar APKs**. Para usarlas necesitarás:
|
||||
|
||||
- Las **herramientas del SDK de Android** - [Descargar aquí](https://developer.android.com/studio/releases/sdk-tools).
|
||||
- O **Android Studio** (con herramientas del SDK de Android) - [Descargar aquí](https://developer.android.com/studio).
|
||||
- Las **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools).
|
||||
- O **Android Studio** (con Android SDK tools) - [Download here](https://developer.android.com/studio).
|
||||
|
||||
En Windows (en mi caso) **después de instalar Android Studio** tenía las **herramientas del SDK instaladas en**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
|
||||
En Windows (en mi caso) **después de instalar Android Studio** tuve las **SDK Tools instaladas en**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
|
||||
|
||||
En mac puedes **descargar las herramientas del SDK** y tenerlas en el PATH ejecutando:
|
||||
En mac puedes **descargar las SDK tools** y tenerlas en el PATH ejecutando:
|
||||
```bash
|
||||
brew tap homebrew/cask
|
||||
brew install --cask android-sdk
|
||||
```
|
||||
O desde **Android Studio GUI** como se indica en [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) que los instalará en `~/Library/Android/sdk/cmdline-tools/latest/bin/` y `~/Library/Android/sdk/platform-tools/` y `~/Library/Android/sdk/emulator/`
|
||||
O desde **Android Studio GUI** como se indica en [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) que los instalará en `~/Library/Android/sdk/cmdline-tools/latest/bin/`, `~/Library/Android/sdk/platform-tools/` y `~/Library/Android/sdk/emulator/`
|
||||
|
||||
Para los problemas de Java:
|
||||
Para los problemas con Java:
|
||||
```java
|
||||
export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home
|
||||
```
|
||||
## GUI
|
||||
|
||||
### Preparar Máquina Virtual
|
||||
### Preparar la Máquina Virtual
|
||||
|
||||
Si instalaste Android Studio, solo puedes abrir la vista principal del proyecto y acceder a: _**Tools**_ --> _**AVD Manager.**_
|
||||
Si instalaste Android Studio, simplemente puedes abrir la vista principal del proyecto y acceder: _**Tools**_ --> _**AVD Manager.**_
|
||||
|
||||
<div align="center" data-full-width="false">
|
||||
|
||||
@ -40,34 +40,34 @@ Luego, haz clic en _**Create Virtual Device**_
|
||||
|
||||
<figure><img src="../../images/image (1143).png" alt="" width="188"><figcaption></figcaption></figure>
|
||||
|
||||
_**selecciona** el teléfono que deseas usar_ y haz clic en _**Next.**_
|
||||
_**selecciona** el teléfono que quieres usar_ y haz clic en _**Next.**_
|
||||
|
||||
> [!WARNING]
|
||||
> Si necesitas un teléfono con Play Store instalado, selecciona uno con el ícono de Play Store en él.
|
||||
> Si necesitas un teléfono con Play Store instalado selecciona uno con el icono de Play Store.
|
||||
>
|
||||
> <img src="../../images/image (1144).png" alt="" data-size="original">
|
||||
|
||||
En la vista actual podrás **seleccionar y descargar la imagen de Android** que el teléfono va a ejecutar:
|
||||
En la vista actual podrás **seleccionar y descargar la imagen de Android** que ejecutará el teléfono:
|
||||
|
||||
<figure><img src="../../images/image (1145).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
Así que, selecciónala y si no está descargada, haz clic en el símbolo de _**Download**_ junto al nombre (**ahora espera hasta que la imagen se descargue).**\
|
||||
Una vez que la imagen esté descargada, solo selecciona **`Next`** y **`Finish`**.
|
||||
Entonces, selecciónala y si no está descargada haz clic en el símbolo _**Download**_ junto al nombre (**espera hasta que la imagen se descargue**).\
|
||||
Una vez que la imagen esté descargada, simplemente selecciona **`Next`** y **`Finish`**.
|
||||
|
||||
La máquina virtual será creada. Ahora **cada vez que accedas al AVD manager estará presente**.
|
||||
La máquina virtual será creada. Ahora **cada vez que accedas al AVD Manager estará presente**.
|
||||
|
||||
### Ejecutar Máquina Virtual
|
||||
### Ejecutar la Máquina Virtual
|
||||
|
||||
Para **ejecutarla** solo presiona el _**Start button**_.
|
||||
|
||||
.png>)
|
||||
|
||||
## Herramienta de Línea de Comando
|
||||
## Herramienta de Línea de Comandos
|
||||
|
||||
> [!WARNING]
|
||||
> Para macOS puedes encontrar la herramienta `avdmanager` en `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` y el `emulator` en `/Users/<username>/Library/Android/sdk/emulator/emulator` si los tienes instalados.
|
||||
|
||||
Primero que nada, necesitas **decidir qué teléfono deseas usar**, para ver la lista de teléfonos posibles ejecuta:
|
||||
Primero necesitas **decidir qué teléfono quieres usar**, para ver la lista de teléfonos disponibles ejecuta:
|
||||
```
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device
|
||||
|
||||
@ -95,16 +95,16 @@ Name: Nexus 10
|
||||
OEM : Google
|
||||
[...]
|
||||
```
|
||||
Una vez que hayas decidido el nombre del dispositivo que deseas usar, necesitas **decidir qué imagen de Android quieres ejecutar en este dispositivo.**\
|
||||
Una vez que hayas decidido el nombre del dispositivo que quieres usar, necesitas **decidir qué imagen de Android quieres ejecutar en este dispositivo.**\
|
||||
Puedes listar todas las opciones usando `sdkmanager`:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list
|
||||
```
|
||||
Y **descarga** el que (o todos) que quieras usar con:
|
||||
Y **descarga** el que (o todos) quieras usar con:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"
|
||||
```
|
||||
Una vez que hayas descargado la imagen de Android que deseas usar, puedes **listar todas las imágenes de Android descargadas** con:
|
||||
Una vez que hayas descargado la imagen de Android que quieres usar, puedes **listar todas las imágenes de Android descargadas** con:
|
||||
```
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target
|
||||
----------
|
||||
@ -120,7 +120,7 @@ Type: Platform
|
||||
API level: 29
|
||||
Revision: 4
|
||||
```
|
||||
En este momento has decidido el dispositivo que deseas usar y has descargado la imagen de Android, así que **puedes crear la máquina virtual usando**:
|
||||
En este momento has decidido el dispositivo que quieres usar y has descargado la imagen de Android, así que **puedes crear la máquina virtual usando**:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X"
|
||||
```
|
||||
@ -140,10 +140,10 @@ Name: Pixel_2_API_27
|
||||
Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd
|
||||
Error: Google pixel_2 no longer exists as a device
|
||||
```
|
||||
### Ejecutar Máquina Virtual
|
||||
### Ejecutar máquina virtual
|
||||
|
||||
> [!WARNING]
|
||||
> Para macOS, puedes encontrar la herramienta `avdmanager` en `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` y el `emulator` en `/Users/<username>/Library/Android/sdk/emulator/emulator` si los tienes instalados.
|
||||
> Para macOS puedes encontrar la herramienta `avdmanager` en `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` y el `emulator` en `/Users/<username>/Library/Android/sdk/emulator/emulator` si los tienes instalados.
|
||||
|
||||
Ya hemos visto cómo puedes listar las máquinas virtuales creadas, pero **también puedes listarlas usando**:
|
||||
```bash
|
||||
@ -156,59 +156,115 @@ Puedes simplemente **ejecutar cualquier máquina virtual creada** usando:
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9"
|
||||
```
|
||||
O utilizando opciones más avanzadas, puedes ejecutar una máquina virtual como:
|
||||
O usando opciones más avanzadas puedes ejecutar una máquina virtual como:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
|
||||
```
|
||||
### Opciones de línea de comandos
|
||||
|
||||
Sin embargo, hay **muchas opciones útiles de línea de comandos** que puedes usar para iniciar una máquina virtual. A continuación, puedes encontrar algunas opciones interesantes, pero puedes [**encontrar una lista completa aquí**](https://developer.android.com/studio/run/emulator-commandline)
|
||||
Sin embargo, hay **muchas opciones útiles de línea de comandos** que puedes usar para iniciar una máquina virtual. A continuación puedes encontrar algunas opciones interesantes, pero puedes [**encontrar la lista completa aquí**](https://developer.android.com/studio/run/emulator-commandline)
|
||||
|
||||
**Arranque**
|
||||
|
||||
- `-snapshot name` : Iniciar instantánea de VM
|
||||
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Listar todas las instantáneas grabadas
|
||||
- `-snapshot name` : Start VM snapshot
|
||||
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : List all the snapshots recorded
|
||||
|
||||
**Red**
|
||||
|
||||
- `-dns-server 192.0.2.0, 192.0.2.255` : Permitir indicar separados por comas los servidores DNS a la VM.
|
||||
- **`-http-proxy 192.168.1.12:8080`** : Permitir indicar un proxy HTTP a usar (muy útil para capturar el tráfico usando Burp)
|
||||
- Si la configuración del proxy no está funcionando por alguna razón, intenta configurarlas internamente o usando una aplicación como "Super Proxy" o "ProxyDroid".
|
||||
- `-netdelay 200` : Establecer la emulación de latencia de red en milisegundos.
|
||||
- `-port 5556` : Establecer el número de puerto TCP que se usa para la consola y adb.
|
||||
- `-ports 5556,5559` : Establecer los puertos TCP utilizados para la consola y adb.
|
||||
- **`-tcpdump /path/dumpfile.cap`** : Capturar todo el tráfico en un archivo
|
||||
- `-dns-server 192.0.2.0, 192.0.2.255` : Permite indicar, separados por comas, los servidores DNS para la VM.
|
||||
- **`-http-proxy 192.168.1.12:8080`** : Permite indicar un HTTP proxy a usar (muy útil para capturar el tráfico usando Burp)
|
||||
- Si la configuración del proxy no funciona por alguna razón, intenta configurarlos internamente o usando una aplicación como "Super Proxy" o "ProxyDroid".
|
||||
- `-netdelay 200` : Set the network latency emulation in milliseconds.
|
||||
- `-port 5556` : Set the TCP port number that's used for the console and adb.
|
||||
- `-ports 5556,5559` : Set the TCP ports used for the console and adb.
|
||||
- **`-tcpdump /path/dumpfile.cap`** : Capture all the traffic in a file
|
||||
|
||||
**Sistema**
|
||||
|
||||
- `-selinux {disabled|permissive}` : Establecer el módulo de seguridad Security-Enhanced Linux en modo deshabilitado o permisivo en un sistema operativo Linux.
|
||||
- `-timezone Europe/Paris` : Establecer la zona horaria para el dispositivo virtual
|
||||
- `-screen {touch(default)|multi-touch|o-touch}` : Establecer el modo de pantalla táctil emulada.
|
||||
- **`-writable-system`** : Usa esta opción para tener una imagen del sistema escribible durante tu sesión de emulación. También necesitarás ejecutar `adb root; adb remount`. Esto es muy útil para instalar un nuevo certificado en el sistema.
|
||||
- `-selinux {disabled|permissive}` : Set the Security-Enhanced Linux security module to either disabled or permissive mode on a Linux operating system.
|
||||
- `-timezone Europe/Paris` : Set the timezone for the virtual device
|
||||
- `-screen {touch(default)|multi-touch|o-touch}` : Set emulated touch screen mode.
|
||||
- **`-writable-system`** : Use this option to have a writable system image during your emulation session. You will need also to run `adb root; adb remount`. This is very useful to install a new certificate in the system.
|
||||
|
||||
## Rootear un dispositivo de Play Store
|
||||
## Configuración de la CLI en Linux (SDK/AVD inicio rápido)
|
||||
|
||||
Si descargaste un dispositivo con Play Store, no podrás obtener root directamente, y recibirás este mensaje de error.
|
||||
Las herramientas CLI oficiales facilitan crear emuladores rápidos y depurables sin Android Studio.
|
||||
```bash
|
||||
# Directory layout
|
||||
mkdir -p ~/Android/cmdline-tools/latest
|
||||
|
||||
# Download commandline tools (Linux)
|
||||
wget https://dl.google.com/android/repository/commandlinetools-linux-13114758_latest.zip -O /tmp/cmdline-tools.zip
|
||||
unzip /tmp/cmdline-tools.zip -d ~/Android/cmdline-tools/latest
|
||||
rm /tmp/cmdline-tools.zip
|
||||
|
||||
# Env vars (add to ~/.bashrc or ~/.zshrc)
|
||||
export ANDROID_HOME=$HOME/Android
|
||||
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH
|
||||
|
||||
# Install core SDK components
|
||||
sdkmanager --install "platform-tools" "emulator"
|
||||
|
||||
# Install a debuggable x86_64 system image (Android 11 / API 30)
|
||||
sdkmanager --install "system-images;android-30;google_apis;x86_64"
|
||||
|
||||
# Create an AVD and run it with a writable /system & snapshot name
|
||||
avdmanager create avd -n PixelRootX86 -k "system-images;android-30;google_apis;x86_64" -d "pixel"
|
||||
emulator -avd PixelRootX86 -writable-system -snapshot PixelRootX86_snap
|
||||
|
||||
# Verify root (debuggable images allow `adb root`)
|
||||
adb root
|
||||
adb shell whoami # expect: root
|
||||
```
|
||||
Notas
|
||||
- Variantes de imágenes del sistema: google_apis (debuggable, permite `adb root`), google_apis_playstore (not rootable), aosp/default (ligera).
|
||||
- Tipos de build: userdebug suele permitir `adb root` en imágenes con capacidad de depuración. Las imágenes de Play Store son builds de producción y bloquean el root.
|
||||
- En hosts x86_64, la emulación ARM64 a nivel de sistema completo no es compatible desde API 28+. Para Android 11+ usa imágenes Google APIs/Play que incluyen traducción por app de ARM a x86 para ejecutar muchas apps exclusivas de ARM rápidamente.
|
||||
|
||||
### Snapshots desde la CLI
|
||||
```bash
|
||||
# Save a clean snapshot from the running emulator
|
||||
adb -s emulator-5554 emu avd snapshot save my_clean_setup
|
||||
|
||||
# Boot from a named snapshot (if it exists)
|
||||
emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup
|
||||
```
|
||||
## ARM→x86 traducción de binarios (Android 11+)
|
||||
|
||||
Google APIs y las imágenes de Play Store en Android 11+ pueden traducir binarios de apps ARM por proceso mientras mantienen el resto del sistema nativo x86/x86_64. Esto suele ser lo suficientemente rápido para probar muchas aplicaciones solo ARM en escritorio.
|
||||
|
||||
> Consejo: Prefiere las imágenes Google APIs x86/x86_64 durante los pentests. Las imágenes Play son convenientes pero bloquean `adb root`; úsalas solo cuando necesites específicamente Play services y aceptes la falta de root.
|
||||
|
||||
## Rooting de un dispositivo con Play Store
|
||||
|
||||
Si descargaste un dispositivo con Play Store no vas a poder obtener root directamente, y obtendrás este mensaje de error
|
||||
```
|
||||
$ adb root
|
||||
adbd cannot run as root in production builds
|
||||
```
|
||||
Usando [rootAVD](https://github.com/newbit1/rootAVD) con [Magisk](https://github.com/topjohnwu/Magisk) pude obtener acceso root (sigue por ejemplo [**este video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **o** [**este otro**](https://www.youtube.com/watch?v=qQicUW0svB8)).
|
||||
Using [rootAVD](https://github.com/newbit1/rootAVD) with [Magisk](https://github.com/topjohnwu/Magisk) pude rootearlo (sigue por ejemplo [**este vídeo**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **o** [**este otro**](https://www.youtube.com/watch?v=qQicUW0svB8)).
|
||||
|
||||
## Instalar Certificado de Burp
|
||||
## Instalar certificado de Burp
|
||||
|
||||
Consulta la siguiente página para aprender a instalar un certificado CA personalizado:
|
||||
|
||||
Consulta la siguiente página para aprender cómo instalar un certificado CA personalizado:
|
||||
|
||||
{{#ref}}
|
||||
install-burp-certificate.md
|
||||
{{#endref}}
|
||||
|
||||
## Opciones AVD Interesantes
|
||||
## Opciones útiles de AVD
|
||||
|
||||
### Tomar una Instantánea
|
||||
### Tomar una instantánea
|
||||
|
||||
Puedes **usar la GUI** para tomar una instantánea de la VM en cualquier momento:
|
||||
|
||||
.png>)
|
||||
|
||||
## Referencias
|
||||
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
- [Android Emulator command line](https://developer.android.com/studio/run/emulator-commandline)
|
||||
- [Run ARM apps on the Android Emulator (x86 translation)](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Tutorial de Frida
|
||||
# Frida Tutorial
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,45 +10,98 @@ Instalar **frida tools**:
|
||||
pip install frida-tools
|
||||
pip install frida
|
||||
```
|
||||
**Descargar e instalar** en el android el **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
|
||||
Comando de una línea para reiniciar adb en modo root, conectarse a él, subir frida-server, dar permisos de ejecución y ejecutarlo en segundo plano:
|
||||
**Descargar e instalar** en el dispositivo Android el **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
|
||||
Comando de una sola línea para reiniciar adb en modo root, conectarse a él, subir frida-server, darle permisos de ejecución y ejecutarlo en segundo plano:
|
||||
```bash
|
||||
adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &"
|
||||
```
|
||||
**Verifica** si está **funcionando**:
|
||||
**Comprueba** si está **funcionando**:
|
||||
```bash
|
||||
frida-ps -U #List packages and processes
|
||||
frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
|
||||
```
|
||||
## Frida server vs. Gadget (root vs. no-root)
|
||||
|
||||
Dos formas comunes de instrumentar aplicaciones Android con Frida:
|
||||
|
||||
- Frida server (rooted devices): Empuja y ejecuta un daemon nativo que te permite adjuntarte a cualquier proceso.
|
||||
- Frida Gadget (no root): Incluye Frida como una biblioteca compartida dentro del APK y la carga automáticamente en el proceso objetivo.
|
||||
|
||||
Frida server (rooted)
|
||||
```bash
|
||||
# Download the matching frida-server binary for your device's arch
|
||||
# https://github.com/frida/frida/releases
|
||||
adb root
|
||||
adb push frida-server-<ver>-android-<arch> /data/local/tmp/frida-server
|
||||
adb shell chmod 755 /data/local/tmp/frida-server
|
||||
adb shell /data/local/tmp/frida-server & # run at boot via init/magisk if desired
|
||||
|
||||
# From host, list processes and attach
|
||||
frida-ps -Uai
|
||||
frida -U -n com.example.app
|
||||
```
|
||||
Frida Gadget (no-root)
|
||||
|
||||
1) Desempaqueta el APK, añade el gadget .so y la config:
|
||||
- Coloca libfrida-gadget.so en lib/<abi>/ (p. ej., lib/arm64-v8a/)
|
||||
- Crea assets/frida-gadget.config con la configuración para cargar tu script
|
||||
|
||||
Ejemplo frida-gadget.config
|
||||
```json
|
||||
{
|
||||
"interaction": { "type": "script", "path": "/sdcard/ssl-bypass.js" },
|
||||
"runtime": { "logFile": "/sdcard/frida-gadget.log" }
|
||||
}
|
||||
```
|
||||
2) Referencia/carga el gadget para que se inicialice temprano:
|
||||
- Lo más sencillo: Añade un pequeño stub Java con System.loadLibrary("frida-gadget") en Application.onCreate(), o usa la carga nativa de librerías ya presente.
|
||||
|
||||
3) Reempaqueta y firma el APK, luego instálalo:
|
||||
```bash
|
||||
apktool d app.apk -o app_m
|
||||
# ... add gadget .so and config ...
|
||||
apktool b app_m -o app_gadget.apk
|
||||
uber-apk-signer -a app_gadget.apk -o out_signed
|
||||
adb install -r out_signed/app_gadget-aligned-debugSigned.apk
|
||||
```
|
||||
4) Adjuntar desde el host al proceso del gadget:
|
||||
```bash
|
||||
frida-ps -Uai
|
||||
frida -U -n com.example.app
|
||||
```
|
||||
Notas
|
||||
- Gadget es detectado por algunas protecciones; mantén los nombres/rutas sigilosos y cárgalo tarde/condicionalmente si es necesario.
|
||||
- En aplicaciones endurecidas, prefiere pruebas en dispositivos rooteados con server + late attach, o combina con ocultamiento Magisk/Zygisk.
|
||||
|
||||
## Tutoriales
|
||||
|
||||
### [Tutorial 1](frida-tutorial-1.md)
|
||||
|
||||
**De**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
|
||||
**Fuente**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
|
||||
**APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\
|
||||
**Código Fuente**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
|
||||
**Código fuente**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
|
||||
|
||||
**Sigue el [enlace para leerlo](frida-tutorial-1.md).**
|
||||
**Sigue el [link to read it](frida-tutorial-1.md).**
|
||||
|
||||
### [Tutorial 2](frida-tutorial-2.md)
|
||||
|
||||
**De**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Partes 2, 3 y 4)\
|
||||
**APKs y Código fuente**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
|
||||
**Fuente**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Partes 2, 3 & 4)\
|
||||
**APKs y código fuente**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
|
||||
|
||||
**Sigue el [enlace para leerlo.](frida-tutorial-2.md)**
|
||||
**Sigue el[ link to read it.](frida-tutorial-2.md)**
|
||||
|
||||
### [Tutorial 3](owaspuncrackable-1.md)
|
||||
|
||||
**De**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
|
||||
**Fuente**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
|
||||
**APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk)
|
||||
|
||||
**Sigue el [enlace para leerlo](owaspuncrackable-1.md).**
|
||||
**Sigue el [link to read it](owaspuncrackable-1.md).**
|
||||
|
||||
**Puedes encontrar más increíbles scripts de Frida aquí:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
**You can find more Awesome Frida scripts here:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
|
||||
## Ejemplos Rápidos
|
||||
## Ejemplos rápidos
|
||||
|
||||
### Llamando a Frida desde la línea de comandos
|
||||
### Calling Frida from command line
|
||||
```bash
|
||||
frida-ps -U
|
||||
|
||||
@ -72,9 +125,9 @@ print('[ * ] Running Frida Demo application')
|
||||
script.load()
|
||||
sys.stdin.read()
|
||||
```
|
||||
### Hooking functions without parameters
|
||||
### Hooking funciones sin parámetros
|
||||
|
||||
Hook la función `a()` de la clase `sg.vantagepoint.a.c`
|
||||
Hook the function `a()` de la clase `sg.vantagepoint.a.c`
|
||||
```javascript
|
||||
Java.perform(function () {
|
||||
; rootcheck1.a.overload().implementation = function() {
|
||||
@ -84,14 +137,14 @@ return false;
|
||||
};
|
||||
});
|
||||
```
|
||||
Enganchar java `exit()`
|
||||
Hook java `exit()`
|
||||
```javascript
|
||||
var sysexit = Java.use("java.lang.System")
|
||||
sysexit.exit.overload("int").implementation = function (var_0) {
|
||||
send("java.lang.System.exit(I)V // We avoid exiting the application :)")
|
||||
}
|
||||
```
|
||||
Enganchar MainActivity `.onStart()` y `.onCreate()`
|
||||
Hook MainActivity `.onStart()` & `.onCreate()`
|
||||
```javascript
|
||||
var mainactivity = Java.use("sg.vantagepoint.uncrackable1.MainActivity")
|
||||
mainactivity.onStart.overload().implementation = function () {
|
||||
@ -115,9 +168,9 @@ send("Activity HIT!!!")
|
||||
var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0)
|
||||
}
|
||||
```
|
||||
### Enganchando funciones con parámetros y recuperando el valor
|
||||
### Hooking functions con parámetros y recuperando el valor
|
||||
|
||||
Enganchando una función de desencriptación. Imprimir la entrada, llamar a la función original para desencriptar la entrada y, finalmente, imprimir los datos en texto plano:
|
||||
Hooking a decryption function. Imprime el input, llama a la función original para decrypt el input y, finalmente, imprime los datos en claro:
|
||||
```javascript
|
||||
function getString(data) {
|
||||
var ret = ""
|
||||
@ -142,9 +195,9 @@ send("Decrypted flag: " + flag)
|
||||
return ret //[B
|
||||
}
|
||||
```
|
||||
### Enganchando funciones y llamándolas con nuestra entrada
|
||||
### Hooking functions y llamándolas con nuestra entrada
|
||||
|
||||
Engancha una función que recibe una cadena y llámala con otra cadena (de [aquí](https://11x256.github.io/Frida-hooking-android-part-2/))
|
||||
Hook a function que recibe un string y llámala con otro string (from [here](https://11x256.github.io/Frida-hooking-android-part-2/))
|
||||
```javascript
|
||||
var string_class = Java.use("java.lang.String") // get a JS wrapper for java's String class
|
||||
|
||||
@ -157,11 +210,11 @@ console.log("Return value: " + ret)
|
||||
return ret
|
||||
}
|
||||
```
|
||||
### Obtener un objeto ya creado de una clase
|
||||
### Obteniendo un objeto ya creado de una clase
|
||||
|
||||
Si deseas extraer algún atributo de un objeto creado, puedes usar esto.
|
||||
Si quieres extraer algún atributo de un objeto creado, puedes usar esto.
|
||||
|
||||
En este ejemplo, verás cómo obtener el objeto de la clase my_activity y cómo llamar a la función .secret() que imprimirá un atributo privado del objeto:
|
||||
En este ejemplo verás cómo obtener el objeto de la clase my_activity y cómo llamar a la función .secret() que imprimirá un atributo privado del objeto:
|
||||
```javascript
|
||||
Java.choose("com.example.a11x256.frida_test.my_activity", {
|
||||
onMatch: function (instance) {
|
||||
@ -175,7 +228,13 @@ onComplete: function () {},
|
||||
## Otros tutoriales de Frida
|
||||
|
||||
- [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs)
|
||||
- [Parte 1 de la serie de blogs sobre el uso avanzado de Frida: Bibliotecas de cifrado de IOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
|
||||
- [Part 1 of Advanced Frida Usage blog series: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
|
||||
|
||||
|
||||
## Referencias
|
||||
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
- [Frida Gadget documentation](https://frida.re/docs/gadget/)
|
||||
- [Frida releases (server binaries)](https://github.com/frida/frida/releases)
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,20 +1,32 @@
|
||||
# Instalar el Certificado de Burp
|
||||
# Instalar certificado de Burp
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## En una Máquina Virtual
|
||||
## Proxy a nivel del sistema vía ADB
|
||||
|
||||
Primero que nada, necesitas descargar el certificado Der de Burp. Puedes hacer esto en _**Proxy**_ --> _**Options**_ --> _**Importar / Exportar certificado CA**_
|
||||
Configura un proxy HTTP global para que todas las apps enruten el tráfico a través de tu interceptor (Burp/mitmproxy):
|
||||
```bash
|
||||
# Set proxy (device/emulator must reach your host IP)
|
||||
adb shell settings put global http_proxy 192.168.1.2:8080
|
||||
|
||||
# Clear proxy
|
||||
adb shell settings put global http_proxy :0
|
||||
```
|
||||
Consejo: En Burp, vincula tu listener a 0.0.0.0 para que los dispositivos en la LAN puedan conectarse (Proxy -> Options -> Proxy Listeners).
|
||||
|
||||
## En una máquina virtual
|
||||
|
||||
Primero necesitas descargar el certificado Der desde Burp. Puedes hacerlo en _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
|
||||
|
||||
.png>)
|
||||
|
||||
**Exporta el certificado en formato Der** y vamos a **transformarlo** a una forma que **Android** va a poder **entender.** Ten en cuenta que **para configurar el certificado de burp en la máquina Android en AVD** necesitas **ejecutar** esta máquina **con** la opción **`-writable-system`**.\
|
||||
Por ejemplo, puedes ejecutarlo así:
|
||||
**Exporta el certificado en formato Der** y vamos a **transformarlo** a una forma que **Android** pueda **entender.** Ten en cuenta que **para configurar el certificado de Burp en la máquina Android en AVD** necesitas **ejecutar** esta máquina **con** la opción **`-writable-system`**.\
|
||||
Por ejemplo, puedes ejecutarla así:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
|
||||
```
|
||||
Luego, para **configurar el certificado de burp haz**:
|
||||
Entonces, para **configurar el certificado de burps, haz lo siguiente**:
|
||||
```bash
|
||||
openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem
|
||||
CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0"
|
||||
@ -25,39 +37,43 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc
|
||||
adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges
|
||||
adb reboot #Now, reboot the machine
|
||||
```
|
||||
Una vez que la **máquina termine de reiniciarse**, ¡el certificado de burp estará en uso por ella!
|
||||
¡Una vez que la **máquina termine de reiniciarse**, el certificado de Burp estará en uso!
|
||||
|
||||
## Usando Magisc
|
||||
## Using Magisc
|
||||
|
||||
Si **has rooteado tu dispositivo con Magisc** (quizás un emulador), y **no puedes seguir** los **pasos** anteriores para instalar el certificado de Burp porque el **sistema de archivos es de solo lectura** y no puedes volver a montarlo como escribible, hay otra forma.
|
||||
Si **rooteaste tu dispositivo con Magisc** (quizá un emulador), y **no puedes seguir** los **pasos** anteriores para instalar el Burp cert porque el **filesystem es de solo lectura** y no puedes remontarlo como escribible, hay otra forma.
|
||||
|
||||
Explicado en [**este video**](https://www.youtube.com/watch?v=qQicUW0svB8) necesitas:
|
||||
|
||||
1. **Instalar un certificado CA**: Simplemente **arrastra y suelta** el certificado DER de Burp **cambiando la extensión** a `.crt` en el móvil para que se almacene en la carpeta de Descargas y ve a `Instalar un certificado` -> `Certificado CA`
|
||||
1. **Install a CA certificate**: Simplemente **arrastrar&soltar** el DER Burp certificate cambiando la extensión a `.crt` en el móvil para que se almacene en la carpeta Downloads y ve a `Install a certificate` -> `CA certificate`
|
||||
|
||||
<figure><img src="../../images/image (53).png" alt="" width="164"><figcaption></figcaption></figure>
|
||||
|
||||
- Verifica que el certificado se haya almacenado correctamente yendo a `Credenciales de confianza` -> `USUARIO`
|
||||
- Comprueba que el certificado se almacenó correctamente yendo a `Trusted credentials` -> `USER`
|
||||
|
||||
<figure><img src="../../images/image (54).png" alt="" width="334"><figcaption></figcaption></figure>
|
||||
|
||||
2. **Hacerlo de confianza del sistema**: Descarga el módulo de Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (un archivo .zip), **arrástralo y suéltalo** en el teléfono, ve a la **app de Magics** en el teléfono a la sección **`Módulos`**, haz clic en **`Instalar desde almacenamiento`**, selecciona el módulo `.zip` y una vez instalado **reinicia** el teléfono:
|
||||
2. **Make it System trusted**: Descarga el módulo Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (un archivo .zip), **arrástralo&solta** en el teléfono, entra en la app Magics del teléfono en la sección `Modules`, haz clic en `Install from storage`, selecciona el módulo `.zip` y una vez instalado **reincia** el teléfono:
|
||||
|
||||
<figure><img src="../../images/image (55).png" alt="" width="345"><figcaption></figcaption></figure>
|
||||
|
||||
- Después de reiniciar, ve a `Credenciales de confianza` -> `SISTEMA` y verifica que el certificado de Postswigger esté allí
|
||||
- Después del reinicio, ve a `Trusted credentials` -> `SYSTEM` y verifica que el Postswigger cert esté ahí
|
||||
|
||||
<figure><img src="../../images/image (56).png" alt="" width="314"><figcaption></figcaption></figure>
|
||||
|
||||
### Learn how to create a Magisc module
|
||||
|
||||
Consulta [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
|
||||
|
||||
## Post Android 14
|
||||
|
||||
En la última versión de Android 14, se ha observado un cambio significativo en el manejo de los certificados de Autoridad de Certificación (CA) de confianza del sistema. Anteriormente, estos certificados se encontraban en **`/system/etc/security/cacerts/`**, accesibles y modificables por usuarios con privilegios de root, lo que permitía su aplicación inmediata en todo el sistema. Sin embargo, con Android 14, la ubicación de almacenamiento se ha trasladado a **`/apex/com.android.conscrypt/cacerts`**, un directorio dentro de la ruta **`/apex`**, que es inmutable por naturaleza.
|
||||
En la más reciente versión Android 14, se ha observado un cambio significativo en el manejo de los certificados de autoridad (CA) de confianza del sistema. Anteriormente, estos certificados residían en **`/system/etc/security/cacerts/`**, accesibles y modificables por usuarios con privilegios root, lo que permitía su aplicación inmediata en todo el sistema. Sin embargo, con Android 14, la ubicación de almacenamiento se ha movido a **`/apex/com.android.conscrypt/cacerts`**, un directorio dentro de la ruta **`/apex`**, que es inmutable por naturaleza.
|
||||
|
||||
Los intentos de volver a montar la **ruta APEX cacerts** como escribible fracasan, ya que el sistema no permite tales operaciones. Incluso los intentos de desmontar o superponer el directorio con un sistema de archivos temporal (tmpfs) no eluden la inmutabilidad; las aplicaciones continúan accediendo a los datos del certificado original independientemente de los cambios a nivel de sistema de archivos. Esta resistencia se debe a que el montaje de **`/apex`** está configurado con propagación PRIVADA, asegurando que cualquier modificación dentro del directorio **`/apex`** no afecte a otros procesos.
|
||||
Los intentos de remontar la **APEX cacerts path** como escribible fallan, ya que el sistema no permite tales operaciones. Incluso los intentos de desmontar o sobreponer el directorio con un sistema de archivos temporal (tmpfs) no evitan la inmutabilidad; las aplicaciones siguen accediendo a los datos de certificado originales sin importar los cambios a nivel de sistema de archivos. Esta resistencia se debe a que el montaje de **`/apex`** está configurado con PRIVATE propagation, lo que asegura que cualquier modificación dentro del directorio **`/apex`** no afecte a otros procesos.
|
||||
|
||||
La inicialización de Android implica el proceso `init`, que, al iniciar el sistema operativo, también inicia el proceso Zygote. Este proceso es responsable de lanzar procesos de aplicación con un nuevo espacio de nombres de montaje que incluye un montaje privado de **`/apex`**, aislando así los cambios en este directorio de otros procesos.
|
||||
La inicialización de Android involucra el proceso `init`, que al iniciar el sistema operativo también lanza el proceso Zygote. Este proceso es responsable de lanzar los procesos de las aplicaciones con un nuevo mount namespace que incluye un montaje privado de **`/apex`**, aislando así los cambios en este directorio del resto de los procesos.
|
||||
|
||||
Sin embargo, existe una solución para aquellos que necesitan modificar los certificados CA de confianza del sistema dentro del directorio **`/apex`**. Esto implica volver a montar manualmente **`/apex`** para eliminar la propagación PRIVADA, haciéndolo escribible. El proceso incluye copiar el contenido de **`/apex/com.android.conscrypt`** a otra ubicación, desmontar el directorio **`/apex/com.android.conscrypt`** para eliminar la restricción de solo lectura y luego restaurar el contenido a su ubicación original dentro de **`/apex`**. Este enfoque requiere acción rápida para evitar fallos del sistema. Para asegurar la aplicación de estos cambios en todo el sistema, se recomienda reiniciar el `system_server`, lo que efectivamente reinicia todas las aplicaciones y lleva al sistema a un estado consistente.
|
||||
No obstante, existe una solución para quienes necesitan modificar los certificados CA de confianza del sistema dentro del directorio **`/apex`**. Esto implica remontar manualmente **`/apex`** para eliminar la PRIVATE propagation, haciendo que sea escribible. El proceso incluye copiar el contenido de **`/apex/com.android.conscrypt`** a otra ubicación, desmontar el directorio **`/apex/com.android.conscrypt`** para eliminar la restricción de solo lectura, y luego restaurar el contenido a su ubicación original dentro de **`/apex`**. Este enfoque requiere actuar con rapidez para evitar fallos del sistema. Para asegurar que los cambios se apliquen en todo el sistema, se recomienda reiniciar el `system_server`, lo que efectivamente reinicia todas las aplicaciones y lleva el sistema a un estado consistente.
|
||||
```bash
|
||||
# Create a separate temp directory, to hold the current certificates
|
||||
# Otherwise, when we add the mount we can't read the current certs anymore.
|
||||
@ -115,28 +131,28 @@ wait # Launched in parallel - wait for completion here
|
||||
|
||||
echo "System certificate injected"
|
||||
```
|
||||
### Montaje por enlace a través de NSEnter
|
||||
### Bind-mounting through NSEnter
|
||||
|
||||
1. **Configuración de un Directorio Escribible**: Inicialmente, se establece un directorio escribible montando un `tmpfs` sobre el directorio de certificados del sistema no-APEX existente. Esto se logra con el siguiente comando:
|
||||
1. **Configuración de un directorio escribible**: Inicialmente, se crea un directorio escribible montando un `tmpfs` sobre el directorio de certificados del sistema no-APEX existente. Esto se logra con el siguiente comando:
|
||||
```bash
|
||||
mount -t tmpfs tmpfs /system/etc/security/cacerts
|
||||
```
|
||||
2. **Preparación de Certificados CA**: Después de configurar el directorio escribible, los certificados CA que se pretende utilizar deben ser copiados en este directorio. Esto puede implicar copiar los certificados predeterminados de `/apex/com.android.conscrypt/cacerts/`. Es esencial ajustar los permisos y las etiquetas SELinux de estos certificados en consecuencia.
|
||||
3. **Montaje Bind para Zygote**: Utilizando `nsenter`, se entra en el espacio de nombres de montaje de Zygote. Zygote, siendo el proceso responsable de lanzar aplicaciones de Android, requiere este paso para asegurar que todas las aplicaciones iniciadas a partir de ahora utilicen los certificados CA recién configurados. El comando utilizado es:
|
||||
2. **Preparing CA Certificates**: Tras configurar el directorio escribible, los certificados CA que se pretendan usar deben copiarse en este directorio. Esto puede implicar copiar los certificados predeterminados desde `/apex/com.android.conscrypt/cacerts/`. Es esencial ajustar los permisos y las etiquetas SELinux de estos certificados en consecuencia.
|
||||
3. **Bind Mounting for Zygote**: Utilizando `nsenter`, se accede al namespace de montaje de Zygote. Zygote, al ser el proceso responsable de lanzar las aplicaciones Android, requiere este paso para garantizar que todas las aplicaciones iniciadas a partir de entonces utilicen los certificados CA recién configurados. El comando utilizado es:
|
||||
```bash
|
||||
nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
|
||||
```
|
||||
Esto asegura que cada nueva aplicación iniciada se adherirá a la configuración actualizada de certificados CA.
|
||||
Esto garantiza que cada nueva app iniciada cumplirá con la configuración actualizada de certificados CA.
|
||||
|
||||
4. **Aplicando Cambios a Aplicaciones en Ejecución**: Para aplicar los cambios a las aplicaciones que ya están en ejecución, se utiliza nuevamente `nsenter` para entrar en el espacio de nombres de cada aplicación individualmente y realizar un montaje de enlace similar. El comando necesario es:
|
||||
4. **Aplicar cambios a las apps en ejecución**: Para aplicar los cambios a las aplicaciones que ya están en ejecución, se vuelve a usar `nsenter` para entrar en el namespace de cada app individualmente y realizar un bind mount similar. El comando necesario es:
|
||||
```bash
|
||||
nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
|
||||
```
|
||||
5. **Enfoque Alternativo - Reinicio Suave**: Un método alternativo implica realizar el montaje de enlace en el proceso `init` (PID 1) seguido de un reinicio suave del sistema operativo con los comandos `stop && start`. Este enfoque propagaría los cambios a través de todos los espacios de nombres, evitando la necesidad de abordar individualmente cada aplicación en ejecución. Sin embargo, este método generalmente es menos preferido debido a la inconveniencia de reiniciar.
|
||||
5. **Enfoque alternativo - Reinicio suave**: Un método alternativo consiste en realizar el bind mount en el proceso `init` (PID 1) seguido de un reinicio suave del sistema operativo con los comandos `stop && start`. Este enfoque propagará los cambios a través de todos los namespaces, evitando la necesidad de dirigirse individualmente a cada app en ejecución. Sin embargo, este método generalmente es menos preferido debido a la inconveniencia de reiniciar.
|
||||
|
||||
## Referencias
|
||||
|
||||
- [https://httptoolkit.com/blog/android-14-install-system-ca-certificate/](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
|
||||
|
||||
- [Android 14: Install a system CA certificate on a rooted device](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user