diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 6fcf52e77..059756b07 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -2,9 +2,10 @@ {{#include ../../banners/hacktricks-training.md}} -## Fundamentos de Aplicaciones Android +## Conceptos Básicos de Aplicaciones Android + +Es altamente recomendable empezar leyendo esta página para conocer las **partes más importantes relacionadas con la seguridad Android y los componentes más peligrosos en una aplicación Android**: -Se recomienda encarecidamente comenzar a leer 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}} android-applications-basics.md @@ -12,22 +13,22 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Esta es la herramienta principal que necesitas para conectarte a un dispositivo android (emulado o físico).\ -**ADB** permite controlar dispositivos ya sea a través de **USB** o **Red** desde una computadora. Esta utilidad habilita la **copia** de archivos en ambas direcciones, **instalación** y **desinstalación** de aplicaciones, **ejecución** de comandos de shell, **respaldo** de datos, **lectura** de registros, entre otras funciones. +Esta es la herramienta principal que necesitas para conectarte a un dispositivo Android (emulado o físico).\ +**ADB** permite controlar dispositivos tanto por **USB** como por **Network** desde un ordenador. Esta utilidad habilita la **copia** de archivos en ambos sentidos, 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. -Echa un vistazo a la siguiente lista de [**Comandos ADB**](adb-commands.md) para aprender a usar adb. +Consulta la siguiente lista de [**Comandos ADB**](adb-commands.md) para aprender cómo 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 o flags bien ofuscados). Entonces, podría ser interesante descompilar el apk, modificar el código y recompilarlo.\ -[**En este tutorial** puedes **aprender a descompilar un APK, modificar el código Smali y recompilar el APK** con la nueva funcionalidad](smali-changes.md). Esto podría ser muy útil como una **alternativa para varias pruebas durante el análisis dinámico** que se van a presentar. Entonces, **siempre ten en cuenta esta posibilidad**. +A veces es interesante **modificar el código de la aplicación** para acceder a **información oculta** (quizá contraseñas bien ofuscadas o flags). Entonces, puede ser interesante decompilar el apk, modificar el código y recompilarlo.\ +[**En este tutorial** puedes **aprender cómo decompilar un APK, modificar código Smali y recompilar el APK** con la nueva funcionalidad](smali-changes.md). Esto puede ser muy útil como **alternativa para varias pruebas durante el análisis dinámico** que se van a presentar. Por lo tanto, **mantén siempre en mente esta posibilidad**. ## Otros trucos interesantes -- [Suplantar tu ubicación en Play Store](spoofing-your-location-in-play-store.md) -- [API Privilegiada Shizuku (acceso privilegiado no root basado en ADB)](shizuku-privileged-api.md) -- [Explotar Mecanismos de Actualización Insegura en la Aplicación](insecure-in-app-update-rce.md) -- [Abusar de los Servicios de Accesibilidad (Android RAT)](accessibility-services-abuse.md) +- [Falsificar tu ubicación en Play Store](spoofing-your-location-in-play-store.md) +- [Shizuku Privileged API (acceso privilegiado sin root basado en ADB)](shizuku-privileged-api.md) +- [Explotando mecanismos de actualización in-app inseguros](insecure-in-app-update-rce.md) +- [Abusar de Accessibility Services (Android RAT)](accessibility-services-abuse.md) - **Descargar APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) - Extraer APK del dispositivo: ```bash @@ -39,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Combina todos los splits y apks base con [APKEditor](https://github.com/REAndroid/APKEditor): +- Fusiona todos los splits y base apks con [APKEditor](https://github.com/REAndroid/APKEditor): ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -48,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 ``` -## Estudios de Caso y Vulnerabilidades +## Estudios de caso y vulnerabilidades {{#ref}} @@ -60,166 +61,170 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Análisis Estático +## Análisis estático -Primero que nada, para analizar un APK deberías **echar un vistazo al código Java** usando un descompilador.\ -Por favor, [**lee aquí para encontrar información sobre diferentes descompiladores disponibles**](apk-decompilers.md). +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). -### Buscando Información Interesante +### Buscando información interesante -Solo echando un vistazo a las **cadenas** del APK puedes buscar **contraseñas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **claves** de **API**, **cifrado**, **uuids de bluetooth**, **tokens** y cualquier cosa interesante... busca incluso **puertas traseras** de ejecución de código o puertas traseras de autenticación (credenciales de administrador codificadas en la aplicación). +Just taking a look to the **strings** of the APK you can search for **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** and anything interesting... look even for code execution **backdoors** or authentication backdoors (hardcoded admin credentials to the app). **Firebase** -Presta especial atención a las **URLs de firebase** y verifica si está mal configurado. [Más información sobre qué es Firebase y cómo explotarlo aquí.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Pay special attention to **firebase URLs** and check if it is bad configured. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Comprensión Básica de la Aplicación - Manifest.xml, strings.xml +### 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 potenciales vulnerabilidades de seguridad**. Estos archivos pueden ser accedidos usando descompiladores o renombrando la extensión del archivo APK a .zip y luego descomprimiéndolo. +The **examination of an application's _Manifest.xml_ and **_strings.xml_** files can reveal potential security vulnerabilities**. These files can be accessed using decompilers or by renaming the APK file extension to .zip and then unzipping it. -**Vulnerabilidades** identificadas en el **Manifest.xml** incluyen: +**Vulnerabilidades** identificadas desde el **Manifest.xml** incluyen: -- **Aplicaciones Depurables**: Las aplicaciones configuradas como depurables (`debuggable="true"`) en el archivo _Manifest.xml_ representan un riesgo ya que permiten conexiones que pueden llevar a la explotación. Para una mejor comprensión sobre cómo explotar aplicaciones depurables, consulta un tutorial sobre cómo encontrar y explotar aplicaciones depurables en un dispositivo. -- **Configuraciones de Respaldo**: El atributo `android:allowBackup="false"` debe ser establecido explícitamente para aplicaciones que manejan información sensible para prevenir respaldos de datos no autorizados a través de adb, especialmente cuando la depuración por usb está habilitada. -- **Seguridad de Red**: Configuraciones de seguridad de red personalizadas (`android:networkSecurityConfig="@xml/network_security_config"`) en _res/xml/_ pueden especificar detalles de seguridad como pines de certificado y configuraciones de tráfico HTTP. Un ejemplo es permitir tráfico HTTP para dominios específicos. -- **Actividades y Servicios Exportados**: Identificar actividades y servicios exportados en el manifiesto puede resaltar componentes que podrían ser mal utilizados. Un análisis adicional durante las pruebas dinámicas puede revelar cómo explotar estos componentes. -- **Proveedores de Contenido y FileProviders**: Proveedores de contenido expuestos podrían permitir acceso o modificación no autorizada de datos. La configuración de los FileProviders también debe ser examinada. -- **Receptores de Difusión y Esquemas de URL**: Estos componentes podrían ser aprovechados para explotación, prestando especial atención a cómo se gestionan los esquemas de URL para vulnerabilidades de entrada. -- **Versiones de SDK**: Los atributos `minSdkVersion`, `targetSDKVersion` y `maxSdkVersion` indican las versiones de Android soportadas, destacando la importancia de no soportar versiones de Android obsoletas y vulnerables por razones de seguridad. +- **Aplicaciones debuggable**: Applications set as debuggable (`debuggable="true"`) in the _Manifest.xml_ file pose a risk as they allow connections that can lead to exploitation. For further understanding on how to exploit debuggable applications, refer to a tutorial on finding and exploiting debuggable applications on a device. +- **Backup Settings**: The `android:allowBackup="false"` attribute should be explicitly set for applications dealing with sensitive information to prevent unauthorized data backups via adb, especially when usb debugging is enabled. +- **Network Security**: Custom network security configurations (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ can specify security details like certificate pins and HTTP traffic settings. An example is allowing HTTP traffic for specific domains. +- **Exported Activities and Services**: Identifying exported activities and services in the manifest can highlight components that might be misused. Further analysis during dynamic testing can reveal how to exploit these components. +- **Content Providers and FileProviders**: Exposed content providers could allow unauthorized access or modification of data. The configuration of FileProviders should also be scrutinized. +- **Broadcast Receivers and URL Schemes**: These components could be leveraged for exploitation, with particular attention to how URL schemes are managed for input vulnerabilities. +- **SDK Versions**: The `minSdkVersion`, `targetSDKVersion`, and `maxSdkVersion` attributes indicate the supported Android versions, highlighting the importance of not supporting outdated, vulnerable Android versions for security reasons. -Del archivo **strings.xml**, se puede descubrir información sensible como claves de API, esquemas personalizados y otras notas de desarrollador, subrayando la necesidad de una revisión cuidadosa de estos recursos. +From the **strings.xml** file, sensitive information such as API keys, custom schemas, and other developer notes can be discovered, underscoring the need for careful review of these resources. ### Tapjacking -**Tapjacking** es un ataque donde una **aplicación maliciosa** se lanza y **se posiciona encima de una aplicación víctima**. Una vez que oculta visiblemente la aplicación 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 aplicación víctima.\ -En efecto, está **cegando al usuario para que no sepa que realmente está realizando acciones en la aplicación víctima**. +**Tapjacking** is an attack where a **malicious** **application** is launched and **positions itself on top of a victim application**. Once it visibly obscures the victim app, its user interface is designed in such a way as to trick the user to interact with it, while it is passing the interaction along to the victim app.\ +In effect, it is **blinding the user from knowing they are actually performing actions on the victim app**. -Encuentra más información en: +Find more information in: {{#ref}} tapjacking.md {{#endref}} -### Secuestro de Tareas +### Task Hijacking -Una **actividad** con el **`launchMode`** configurado como **`singleTask` sin ninguna `taskAffinity`** definida es vulnerable al secuestro de tareas. Esto significa que una **aplicación** puede ser instalada y si se lanza antes de la aplicación real, podría **secuestrar la tarea de la aplicación real** (así que el usuario estará interactuando con la **aplicación maliciosa pensando que está usando la real**). +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**). -Más información en: +More info in: {{#ref}} android-task-hijacking.md {{#endref}} -### Almacenamiento de Datos Inseguro +### Almacenamiento de datos inseguro -**Almacenamiento Interno** +**Internal Storage** -En Android, los archivos **almacenados** en el **almacenamiento interno** están **diseñados** para ser **accesibles** exclusivamente por la **aplicación** 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. Sin embargo, estos modos **no restringen el acceso** a estos archivos por otras aplicaciones, incluidas las potencialmente maliciosas. +In Android, files **stored** in **internal** storage are **designed** to be **accessible** exclusively by the **app** that **created** them. This security measure is **enforced** by the Android operating system and is generally adequate for the security needs of most applications. However, developers sometimes utilize modes such as `MODE_WORLD_READABLE` and `MODE_WORLD_WRITABLE` to **allow** files to be **shared** between different applications. Yet, these modes **do not restrict access** to these files by other applications, including potentially malicious ones. -1. **Análisis Estático:** -- **Asegúrate** de que el uso de `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` sea **examinado cuidadosamente**. Estos modos **pueden potencialmente exponer** archivos a **acceso no intencionado o no autorizado**. -2. **Análisis Dinámico:** -- **Verifica** los **permisos** establecidos en los archivos creados por la aplicación. Específicamente, **verifica** si algún archivo está **configurado para ser legible o escribible a nivel mundial**. Esto puede representar 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** estos archivos. +1. **Static Analysis:** +- **Ensure** that the use of `MODE_WORLD_READABLE` and `MODE_WORLD_WRITABLE` is **carefully scrutinized**. These modes **can potentially expose** files to **unintended or unauthorized access**. +2. **Dynamic Analysis:** +- **Verify** the **permissions** set on files created by the app. Specifically, **check** if any files are **set to be readable or writable worldwide**. This can pose a significant security risk, as it would allow **any application** installed on the device, regardless of its origin or intent, to **read or modify** these files. -**Almacenamiento Externo** +**External Storage** -Al tratar con archivos en **almacenamiento externo**, como tarjetas SD, se deben tomar ciertas precauciones: +When dealing with files on **external storage**, such as SD Cards, certain precautions should be taken: -1. **Accesibilidad**: -- Los archivos en almacenamiento externo 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 aconseja **no almacenar información sensible** en almacenamiento externo. -- El almacenamiento externo puede ser removido o accedido por cualquier aplicación, lo que lo hace menos seguro. -3. **Manejo de Datos desde Almacenamiento Externo**: -- Siempre **realiza validación de entrada** en los datos recuperados del almacenamiento externo. Esto es crucial porque los datos provienen de una fuente no confiable. -- Almacenar ejecutables o archivos de clase en almacenamiento externo para carga dinámica está fuertemente desaconsejado. -- Si tu aplicación debe recuperar archivos ejecutables del almacenamiento externo, asegúrate de que estos archivos estén **firmados y verificados criptográficamente** antes de ser cargados dinámicamente. Este paso es vital para mantener la integridad de seguridad de tu aplicación. +1. **Accessibility**: +- Files on external storage are **globally readable and writable**. This means any application or user can access these files. +2. **Security Concerns**: +- Given the ease of access, it's advised **not to store sensitive information** on external storage. +- External storage can be removed or accessed by any application, making it less secure. +3. **Handling Data from External Storage**: +- Always **perform input validation** on data retrieved from external storage. This is crucial because the data is from an untrusted source. +- Storing executables or class files on external storage for dynamic loading is strongly discouraged. +- If your application must retrieve executable files from external storage, ensure these files are **signed and cryptographically verified** before they are dynamically loaded. This step is vital for maintaining the security integrity of your application. -El almacenamiento externo puede ser **accedido** en `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` +External storage can be **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] -> A partir de Android 4.4 (**API 17**), la tarjeta SD tiene una estructura de directorios que **limita el acceso de una aplicación al directorio que es específicamente para esa aplicación**. Esto previene que aplicaciones maliciosas obtengan acceso de lectura o escritura a los archivos de otra aplicación. +> 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. -**Datos Sensibles Almacenados en Texto Claro** +**Sensitive data stored in clear-text** -- **Preferencias Compartidas**: Android permite a cada aplicación guardar fácilmente archivos xml en la ruta `/data/data//shared_prefs/` y a veces es posible encontrar información sensible en texto claro en esa carpeta. -- **Bases de Datos**: Android permite a cada aplicación guardar fácilmente bases de datos sqlite en la ruta `/data/data//databases/` y a veces es posible encontrar información sensible en texto claro en esa carpeta. +- **Shared preferences**: Android allow to each application to easily save xml files in the path `/data/data//shared_prefs/` and sometimes it's possible to find sensitive information in clear-text in that folder. +- **Databases**: Android allow to each application to easily save sqlite databases in the path `/data/data//databases/` and sometimes it's possible to find sensitive information in clear-text in that folder. -### TLS Roto +### Broken TLS -**Aceptar Todos los Certificados** +**Accept All Certificates** -Por alguna razón, a veces los desarrolladores aceptan todos los certificados incluso si, por ejemplo, el nombre de host no coincide con líneas de código como la siguiente: +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: ```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 el CA de Burp dentro del dispositivo. También puedes generar con Burp un certificado para un nombre de host diferente 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 rota -**Procesos de Gestión de Claves Pobre** +**Poor Key Management Processes** -Algunos desarrolladores guardan datos sensibles en el almacenamiento local y los encriptan con una clave codificada/predictible en el código. Esto no debería hacerse, ya que algún proceso de reversión podría permitir a los atacantes extraer la información confidencial. +Algunos desarrolladores guardan datos sensibles en el almacenamiento local y los cifran con una clave hardcoded/predictable en el código. Esto no debería hacerse, ya que algo de reversing podría permitir a los atacantes extraer la información confidencial. -**Uso de Algoritmos Inseguros y/o Obsoletos** +**Use of Insecure and/or Deprecated Algorithms** -Los desarrolladores no deberían usar **algoritmos obsoletos** para realizar **verificaciones de autorización**, **almacenar** o **enviar** datos. Algunos de estos algoritmos son: RC4, MD4, MD5, SHA1... Si se utilizan **hashes** para almacenar contraseñas, por ejemplo, se deberían usar hashes resistentes a **fuerza bruta** con sal. +Los desarrolladores no deberían usar **deprecated algorithms** para realizar authorisation **checks**, **store** o **send** datos. Algunos de estos algoritmos son: RC4, MD4, MD5, SHA1... Si **hashes** se usan para almacenar contraseñas por ejemplo, deberían emplearse hashes resistentes a brute-force con salt. -### Otras verificaciones +### Other checks -- Se recomienda **ofuscar el APK** para dificultar el trabajo de ingeniería inversa a los atacantes. -- Si la aplicación es sensible (como aplicaciones bancarias), debería realizar sus **propias verificaciones para ver si el móvil está rooteado** y actuar en consecuencia. -- Si la aplicación es sensible (como aplicaciones bancarias), debería verificar si se está utilizando un **emulador**. -- Si la aplicación es sensible (como aplicaciones bancarias), debería **verificar su propia integridad antes de ejecutarse** para comprobar si ha sido modificada. -- Usa [**APKiD**](https://github.com/rednaga/APKiD) para verificar qué compilador/empaquetador/ofuscador se utilizó para construir el APK. +- It's recommended to **obfuscate the APK** to difficult the reverse engineer labour to attackers. +- If the app is sensitive (like bank apps), it should perform it's **own checks to see if the mobile is rooted** and act in consequence. +- If the app is sensitive (like bank apps), it should check if an **emulator** is being used. +- If the app is sensitive (like bank apps), it should **check it's own integrity before executing** it to check if it was modified. +- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK -### Aplicación React Native +### React Native Application + +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}} react-native-application.md {{#endref}} -### Aplicaciones Xamarin +### Xamarin Applications + +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 aplicaciones xamarin: {{#ref}} ../xamarin-apps.md {{#endref}} -### Aplicaciones Superempaquetadas +### Superpacked Applications -Según este [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superempaquetado es un algoritmo Meta que comprime el contenido de una aplicación en un solo archivo. El blog habla sobre la posibilidad de crear una aplicación que descomprima este tipo de aplicaciones... y una forma más rápida que implica **ejecutar la aplicación y recopilar los archivos descomprimidos del sistema de archivos.** +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.** -### Análisis Estático Automatizado del Código +### Automated Static Code Analysis -La herramienta [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** al **escanear** 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** es **controlada por el usuario**), **sumideros** (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-sumideros** que indica una vulnerabilidad. +The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. -Con este conocimiento, **mariana-trench revisará el código y encontrará posibles vulnerabilidades en él**. +With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. -### Secretos filtrados +### Secrets leaked -Una aplicación puede contener secretos (claves API, contraseñas, URLs ocultas, subdominios...) dentro de ella que podrías descubrir. Podrías usar una herramienta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks). +An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) + +### Bypass Biometric Authentication -### Bypass de Autenticación Biométrica {{#ref}} bypass-biometric-authentication-android.md {{#endref}} -### Otras funciones interesantes +### Other interesting functions -- **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 revertir funciones nativas**](reversing-native-libraries.md) +- **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) + +### **Other tricks** -### **Otros trucos** {{#ref}} content-protocol.md @@ -229,156 +234,157 @@ content-protocol.md --- -## Análisis Dinámico +## Dynamic Analysis -> Primero que nada, necesitas un entorno donde puedas instalar la aplicación y todo el entorno (certificado CA de Burp, Drozer y Frida principalmente). Por lo tanto, se recomienda encarecidamente un dispositivo rooteado (emulado o no). +> 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. -### Análisis Dinámico en Línea +### Online Dynamic analysis -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. +You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving. -Incluso puedes **ver los registros de tu aplicación** en la web y conectarte a través de **adb**. +You can even **see the logs of your application** in the web and connect through **adb**. ![](<../../images/image (831).png>) -Gracias a la conexión ADB, puedes usar **Drozer** y **Frida** dentro de los emuladores. +Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators. -### Análisis Dinámico Local +### Local Dynamic Analysis -#### Usando un emulador +#### Using an emulator + +- [**Android Studio**](https://developer.android.com/studio) (You can create **x86** and **arm** devices, and according to [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). +- Learn to set it up in this page: -- [**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 necesidad de un emulador arm lento). -- Aprende a configurarlo en esta página: {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versión gratuita:** Edición Personal, 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 o Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._) +- [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer). > [!TIP] -> Al crear un nuevo emulador en cualquier plataforma, recuerda que cuanto más grande sea la pantalla, más lento funcionará el emulador. Así que selecciona pantallas pequeñas si es posible. +> When creating a new emulator on any platform remember that the bigger the screen is, the slower the emulator will run. So select small screens if possible. -Para **instalar servicios de Google** (como AppStore) en Genymotion, necesitas hacer clic en el botón marcado en rojo de la siguiente imagen: +To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image: ![](<../../images/image (277).png>) -Además, ten en cuenta que en la **configuración de la VM de Android en Genymotion** puedes seleccionar **modo de red Bridge** (esto será útil si te conectarás a la VM de Android desde una VM diferente con las herramientas). +Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools). -#### Usar un dispositivo físico +#### Use a physical device -Necesitas activar las **opciones de depuración** y sería genial si puedes **rootearlo**: +You need to activate the **debugging** options and it will be cool if you can **root** it: -1. **Configuración**. -2. (Desde Android 8.0) Selecciona **Sistema**. -3. Selecciona **Acerca del teléfono**. -4. Presiona **Número de compilación** 7 veces. -5. Regresa y encontrarás las **Opciones de desarrollador**. +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**. -> Una vez que hayas instalado la aplicación, lo primero que debes hacer es probarla e investigar qué hace, cómo funciona y familiarizarte con ella.\ -> Te sugeriré **realizar este análisis dinámico inicial usando el análisis dinámico de MobSF + pidcat**, para que podamos **aprender cómo funciona la aplicación** mientras MobSF **captura** muchos **datos interesantes** que puedes revisar más tarde. +> 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. -### Filtración de Datos No Intencionada +### Unintended Data Leakage -**Registro** +**Logging** -Los desarrolladores deben tener cuidado de exponer **información de depuración** públicamente, ya que puede llevar a filtraciones de datos sensibles. Se recomiendan las herramientas [**pidcat**](https://github.com/JakeWharton/pidcat) y `adb logcat` para monitorear los registros de la aplicación y proteger la información sensible. **Pidcat** es preferido por su facilidad de uso y legibilidad. +Developers should be cautious of exposing **debugging information** publicly, as it can lead to sensitive data leaks. The tools [**pidcat**](https://github.com/JakeWharton/pidcat) and `adb logcat` are recommended for monitoring application logs to identify and protect sensitive information. **Pidcat** is favored for its ease of use and readability. > [!WARNING] -> Ten en cuenta que desde **versiones posteriores a Android 4.0**, **las aplicaciones solo pueden acceder a sus propios registros**. Así que las aplicaciones no pueden acceder a los registros de otras aplicaciones.\ -> De todos modos, sigue siendo recomendable **no registrar información sensible**. +> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ +> Anyway, it's still recommended to **not log sensitive information**. -**Caché del Portapapeles** +**Copy/Paste Buffer Caching** -El marco **basado en portapapeles** de Android permite la funcionalidad de copiar y pegar en aplicaciones, pero presenta 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 detalles de tarjetas de crédito, para prevenir filtraciones de datos. +Android's **clipboard-based** framework enables copy-paste functionality in apps, yet poses a risk as **other applications** can **access** the clipboard, potentially exposing sensitive data. It's crucial to **disable copy/paste** functions for sensitive sections of an application, like credit card details, to prevent data leaks. -**Registros de Fallos** +**Crash Logs** -Si una aplicación **se bloquea** y **guarda registros**, estos registros pueden ayudar a los atacantes, especialmente cuando la aplicación no puede ser revertida. Para mitigar este riesgo, evita registrar en caso de fallos, y si los registros deben ser transmitidos a través de la red, asegúrate de que se envíen a través de un canal SSL por seguridad. +If an application **crashes** and **saves logs**, these logs can assist attackers, particularly when the application cannot be reverse-engineered. To mitigate this risk, avoid logging on crashes, and if logs must be transmitted over the network, ensure they are sent via an SSL channel for security. -Como pentester, **intenta echar un vistazo a estos registros**. +As pentester, **try to take a look to these logs**. -**Datos de Análisis Enviados a Terceros** +**Analytics Data Sent To 3rd Parties** -Las aplicaciones a menudo integran servicios como Google Adsense, que pueden filtrar inadvertidamente **datos sensibles** 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 verificar si se está enviando información sensible a servicios de terceros. +Applications often integrate services like Google Adsense, which can inadvertently **leak sensitive data** due to improper implementation by developers. To identify potential data leaks, it's advisable to **intercept the application's traffic** and check for any sensitive information being sent to third-party services. -### Bases de Datos SQLite +### SQLite DBs -La mayoría de las aplicaciones utilizarán **bases de datos SQLite internas** para guardar información. Durante el pentest, echa un **vistazo** a las **bases de datos** creadas, los nombres de las **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 estar ubicadas en `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`. +Most of the applications will use **internal SQLite databases** to save information. During the pentest take a **look** to the **databases** created, the names of **tables** and **columns** and all the **data** saved because you could find **sensitive information** (which would be a vulnerability).\ +Databases should be located in `/data/data/the.package.name/databases` like `/data/data/com.mwr.example.sieve/databases` -Si la base de datos está guardando información confidencial y está **encriptada** pero puedes **encontrar** la **contraseña** dentro de la aplicación, sigue siendo una **vulnerabilidad**. +If the database is saving confidential information and is **encrypted b**ut you can **find** the **password** inside the application it's still a **vulnerability**. -Enumera las tablas usando `.tables` y enumera las columnas de las tablas haciendo `.schema `. +Enumerate the tables using `.tables` and enumerate the columns of the tables doing `.schema ` -### Drozer (Explotar Actividades, Proveedores de Contenido y Servicios) +### Drozer (Exploit Activities, Content Providers and Services) -Desde [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** te permite **asumir el rol de una aplicación Android** e interactuar con otras aplicaciones. Puede hacer **cualquier cosa que una aplicación instalada puede hacer**, como hacer uso del mecanismo de Comunicación entre Procesos (IPC) de Android e interactuar con el sistema operativo subyacente.\ -Drozer es una herramienta útil para **explotar actividades exportadas, servicios exportados y Proveedores de Contenido** 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** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ +Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections. -### Explotando Actividades Exportadas +### Exploiting exported Activities -[**Lee esto si quieres refrescar qué es una Actividad de Android.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -También recuerda que el código de una actividad comienza en el **método `onCreate`**. +[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ +Also remember that the code of an activity starts in the **`onCreate`** method. -**Bypass de Autorización** +**Authorisation bypass** -Cuando una Actividad es exportada, puedes invocar su pantalla desde una aplicación externa. Por lo tanto, si una actividad con **información sensible** está **exportada**, podrías **eludir** los mecanismos de **autenticación** **para acceder a ella.** +When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.** -[**Aprende cómo explotar actividades exportadas con Drozer.**](drozer-tutorial/index.html#activities) +[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -También puedes iniciar una actividad exportada desde adb: +You can also start an exported activity from adb: -- El nombre del paquete es com.example.demo -- El nombre de la actividad exportada es com.example.test.MainActivity +- PackageName is com.example.demo +- Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTA**: MobSF detectará como malicioso el uso de _**singleTask/singleInstance**_ como `android:launchMode` en una actividad, pero debido a [esto](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente esto solo es peligroso en versiones antiguas (versiones de API < 21). +**NOTA**: MobSF detectará como malicioso el uso de _**singleTask/singleInstance**_ como `android:launchMode` en una actividad, pero debido a [this](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 bypass de autorización no siempre es una vulnerabilidad, dependerá de cómo funcione el bypass y qué información esté expuesta. +> Ten en cuenta que an authorisation bypass no siempre es una vulnerabilidad; dependerá de cómo funcione el bypass y qué información se exponga. **Filtración de información sensible** -**Las actividades también pueden devolver resultados**. Si logras encontrar una actividad exportada y desprotegida que llame al método **`setResult`** y **devuelva información sensible**, hay una filtración de información sensible. +**Las actividades también pueden devolver resultados**. Si logras encontrar una actividad exportada y sin protección que invoque el método **`setResult`** y **devuelva información sensible**, existe una filtración de información sensible. #### Tapjacking -Si el tapjacking no se previene, podrías abusar de la actividad exportada para hacer que el **usuario realice acciones inesperadas**. Para más información sobre [**qué es el Tapjacking sigue el enlace**](#tapjacking). +Si no se previene el tapjacking, podrías abusar de la actividad exportada para hacer que el **usuario realice acciones inesperadas**. Para más información sobre [**what is Tapjacking follow the link**](#tapjacking). -### Explotando Proveedores de Contenido - Accediendo y manipulando información sensible +### Exploiting Content Providers - Accessing and manipulating sensitive information -[**Lee esto si quieres refrescar qué es un Proveedor de Contenido.**](android-applications-basics.md#content-provider)\ -Los proveedores de contenido se utilizan básicamente para **compartir datos**. Si una aplicación tiene proveedores de contenido disponibles, es posible que puedas **extraer datos sensibles** de ellos. También es interesante probar posibles **inyecciones SQL** y **Path Traversals** ya que podrían ser vulnerables. +[**Read this if you want to refresh what is a 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. -[**Aprende cómo explotar Proveedores de Contenido con Drozer.**](drozer-tutorial/index.html#content-providers) +[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) -### **Explotando Servicios** +### **Exploiting Services** -[**Lee esto si quieres refrescar qué es un Servicio.**](android-applications-basics.md#services)\ -Recuerda que las acciones de un Servicio comienzan en el método `onStartCommand`. +[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ +Recuerda que las acciones de un Service comienzan en el método `onStartCommand`. -Un servicio es básicamente algo que **puede recibir datos**, **procesarlos** y **devolver** (o no) una respuesta. Entonces, si una aplicación está exportando algunos servicios, deberías **verificar** el **código** para entender qué está haciendo y **probarlo** **dinámicamente** para extraer información confidencial, eludir medidas de autenticación...\ -[**Aprende cómo explotar Servicios con 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 está exportando algunos servicios deberías **revisar** el **código** para entender qué hace y **probarlo** **dinámicamente** para extraer información confidencial, bypassing authentication measures...\ +[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) -### **Explotando Receptores de Difusión** +### **Exploiting Broadcast Receivers** -[**Lee esto si quieres refrescar qué es un Receptor de Difusión.**](android-applications-basics.md#broadcast-receivers)\ -Recuerda que las acciones de un Receptor de Difusión comienzan en el método `onReceive`. +[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ +Recuerda que las acciones de un Broadcast Receiver comienzan en el método `onReceive`. -Un receptor de difusión estará esperando un tipo de mensaje. Dependiendo de cómo el receptor maneje el mensaje, podría ser vulnerable.\ -[**Aprende cómo explotar Receptores de Difusión con Drozer.**](#exploiting-broadcast-receivers) +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) -### **Explotando Esquemas / Enlaces profundos** +### **Exploiting Schemes / Deep links** -Puedes buscar enlaces profundos manualmente, utilizando herramientas como MobSF o scripts como [este](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Puedes **abrir** un **esquema** declarado usando **adb** o un **navegador**: +Puedes buscar deep links manualmente, usando herramientas como MobSF o scripts como [this one](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] ``` -_Tenga en cuenta que puede **omitir el nombre del paquete** y el móvil llamará automáticamente a la aplicación 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 debería abrir ese enlace._ ```html Click me @@ -393,74 +399,125 @@ Para encontrar el **código que se ejecutará en la App**, ve a la actividad lla **Información sensible** -Cada vez que encuentres un deep link verifica que **no esté recibiendo datos sensibles (como contraseñas) a través de parámetros de URL**, porque cualquier otra aplicación podría **suplantar el deep link y robar esos datos!** +Cada vez que encuentres un deep link verifica que **no reciba datos sensibles (como contraseñas) vía parámetros URL**, porque cualquier otra aplicación podría **suplantar el deep link y robar esos datos!** **Parámetros en la ruta** -Debes **verificar también si algún deep link está utilizando un parámetro dentro de la ruta** de la URL como: `https://api.example.com/v1/users/{username}`, en ese caso puedes forzar un recorrido de ruta 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 de la ruta se usa como nombre de dominio), **toma de control de cuenta** (si puedes modificar los detalles de los usuarios sin un token CSRF y el endpoint vulnerable usó el método correcto) y cualquier otra vulnerabilidad. Más [info sobre esto aquí](http://dphoeniixx.com/2020/12/13-2/). +También **debes comprobar si algún deep link está usando un parámetro dentro de la ruta** 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 provocar un **Open Redirect** (si parte de la ruta se usa como nombre de dominio), **account takeover** (si puedes modificar detalles de usuarios sin token CSRF y el vuln endpoint usa el método correcto) y cualquier otra vuln. Más [info about this here](http://dphoeniixx.com/2020/12/13-2/). **Más ejemplos** -Un [informe de bug bounty interesante](https://hackerone.com/reports/855618) sobre enlaces (_/.well-known/assetlinks.json_). +Un [interesante informe de bug bounty](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_). -### Inspección y Verificación de la Capa de Transporte +### Inspección de la capa de transporte y fallos de verificación -- **Los certificados no siempre son inspeccionados adecuadamente** por las aplicaciones de Android. Es común que estas aplicaciones pasen por alto advertencias y acepten certificados autofirmados o, en algunos casos, vuelvan a usar conexiones HTTP. -- **Las negociaciones durante el apretón de manos SSL/TLS son a veces débiles**, empleando suites de cifrado inseguras. Esta vulnerabilidad hace que la conexión sea susceptible a ataques de hombre en el medio (MITM), permitiendo a los atacantes descifrar los datos. -- **La filtración de información privada** es un riesgo cuando las aplicaciones se autentican utilizando canales seguros pero luego se comunican a través de canales no seguros para otras transacciones. Este enfoque no protege los datos sensibles, como cookies de sesión o detalles del usuario, de la interceptación por entidades maliciosas. +- **Los certificados no siempre se inspeccionan correctamente** en las aplicaciones Android. Es común que estas aplicaciones pasen por alto advertencias y acepten certificados autofirmados 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. +- **Divulgación de información privada** es un riesgo cuando las aplicaciones se autentican usando canales seguros pero luego comunican por canales no seguros para otras transacciones. Este enfoque no protege datos sensibles, como cookies de sesión o detalles de usuario, de la intercepción por actores maliciosos. -#### Verificación de Certificados +#### Verificación de certificados -Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe ser verificada para mejorar la seguridad. Esto es crucial porque las configuraciones TLS inseguras y la transmisión de datos sensibles a través de canales no encriptados pueden representar riesgos significativos. Para pasos detallados sobre cómo verificar certificados de servidor y abordar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) proporciona 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. Para pasos detallados sobre cómo verificar certificados de servidor y corregir vulnerabilidades, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) ofrece una guía completa. #### SSL Pinning -SSL Pinning es una medida de seguridad donde la aplicación verifica el certificado del servidor contra 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 para aplicaciones que manejan información sensible. +SSL Pinning es una medida de seguridad donde la aplicación verifica el certificado del servidor contra 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 -Para inspeccionar el tráfico HTTP, es necesario **instalar el certificado de la herramienta proxy** (por ejemplo, Burp). Sin instalar este certificado, el tráfico encriptado 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). +Para inspeccionar tráfico HTTP, es necesario **instalar el certificado de la herramienta proxy** (p.ej., 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, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Las aplicaciones que apuntan a **API Level 24 y superiores** requieren modificaciones en la Configuración de Seguridad de Red para aceptar el certificado CA del proxy. Este paso es crítico para inspeccionar tráfico encriptado. Para instrucciones sobre cómo modificar la Configuración de Seguridad de Red, [**consulta este tutorial**](make-apk-accept-ca-certificate.md). +Las aplicaciones dirigidas a **API Level 24 and above** requieren modificaciones en la 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 la Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -Si se está utilizando **Flutter**, necesitas seguir las instrucciones en [**esta página**](flutter.md). Esto se debe a que, simplemente agregar el certificado al almacén no funcionará ya que Flutter tiene su propia lista de CAs válidas. +Si se está usando **Flutter**, debes seguir las instrucciones en [**this page**](flutter.md). Esto se debe a que, simplemente añadir el certificado al almacén no funcionará ya que Flutter tiene su propia lista de CAs válidas. -#### Bypass de SSL Pinning +#### Detección estática de SSL/TLS pinning -Cuando se implementa SSL Pinning, es necesario eludirlo para inspeccionar el tráfico HTTPS. Existen varios métodos disponibles para este propósito: +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 enfocarte en las rutas de código correctas. -- Modificar **automáticamente** el **apk** para **eludir** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). La mejor ventaja de esta opción es que no necesitarás root para eludir el SSL Pinning, pero deberás eliminar la aplicación y reinstalar la nueva, y esto no siempre funcionará. -- Podrías usar **Frida** (discutido a continuación) para eludir 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/) +Herramienta: SSLPinDetect +- 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. +- Reporta la ruta de archivo exacta, 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 custom TrustManagers/KeyManagers, y Network Security Config XML pins. + +Install +- Prerrequisitos: Python >= 3.8, Java en PATH, apktool +```bash +git clone https://github.com/aancw/SSLPinDetect +cd SSLPinDetect +pip install -r requirements.txt +``` +Uso +```bash +# Basic +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) +Usa o amplía signatures para detectar estilos propietarios/personalizados de pinning. Puedes cargar tu propio JSON y escanear a gran escala. +```json +{ +"OkHttp Certificate Pinning": [ +"Lcom/squareup/okhttp/CertificatePinner;", +"Lokhttp3/CertificatePinner;", +"setCertificatePinner" +], +"TrustManager Override": [ +"Ljavax/net/ssl/X509TrustManager;", +"checkServerTrusted" +] +} +``` +Notas y consejos +- Escaneo rápido de aplicaciones grandes mediante multi-threading y memory-mapped I/O; el uso de regex precompiladas reduce 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: 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 +- 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 pruebas dinámicas. + + + +#### Eludir SSL Pinning + +Cuando SSL Pinning está implementado, es necesario eludirlo para inspeccionar el tráfico HTTPS. Existen varios métodos para ello: + +- Modificar automáticamente el **apk** para **eludir** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). La mayor ventaja de esta opción es que no necesitarás root para eludir SSL Pinning, pero tendrás que eliminar la aplicación e instalar la nueva, y esto no siempre funciona. +- Puedes usar **Frida** (discutida más abajo) para eludir 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 **eludir 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 **eludir automáticamente SSL Pinning** usando **análisis dinámico de MobSF** (explicado a continuación) -- Si aún piensas que hay algún tráfico que no estás capturando, puedes intentar **redirigir 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) +- También puedes intentar **eludir automáticamente SSL Pinning** usando **MobSF dynamic analysis** (explicado más abajo) +- Si aún crees que hay tráfico que no estás capturando, puedes intentar **redirigir 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) -#### Búsqueda de Vulnerabilidades Web Comunes +#### Buscar vulnerabilidades web comunes -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 está más allá del alcance de este resumen, pero se cubre extensamente en otros lugares. +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. ### Frida -[Frida](https://www.frida.re) es un kit de herramientas de instrumentación dinámica para desarrolladores, ingenieros de reversa e investigadores de seguridad.\ -**Puedes acceder a la aplicación en ejecución y enganchar métodos en tiempo de ejecución para cambiar el comportamiento, cambiar valores, extraer valores, ejecutar diferentes códigos...**\ -Si deseas hacer pentesting en aplicaciones Android, necesitas saber cómo usar 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 e interceptar métodos en tiempo de ejecución para cambiar el comportamiento, modificar valores, extraer valores, ejecutar código diferente...**\ +Si quieres realizar pentesting de aplicaciones Android necesitas saber cómo usar Frida. -- Aprende a usar Frida: [**Tutorial de Frida**](frida-tutorial/index.html) +- 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 excelente 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 de Frida geniales aquí: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Intenta eludir mecanismos de 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)) +- Ojection 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 Awesome Frida scripts 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)) -#### Flujo de trabajo de elusión de anti-instrumentación y SSL pinning +#### Anti-instrumentation & SSL pinning bypass workflow {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Volcar Memoria - Fridump** +### **Volcar memoria - Fridump** -Verifica si la aplicación está almacenando información sensible en la memoria que no debería estar almacenando, como contraseñas o mnemotécnicos. +Comprueba si la aplicación está almacenando información sensible en la memoria que no debería guardar, como contraseñas o frases mnemónicas. Usando [**Fridump3**](https://github.com/rootbsd/fridump3) puedes volcar la memoria de la app con: ```bash @@ -471,68 +528,68 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Esto volcará la memoria en la carpeta ./dump, y allí podrías 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, **es posible acceder a él**. Dado que las aplicaciones tienden a almacenar aquí **datos sensibles en texto claro**, las pruebas de penetración deben verificarlo, ya que un usuario root 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 suficientes privilegios sigue siendo **posible acceder a él**. Como las aplicaciones tienden a almacenar aquí **datos sensibles en clear text**, los pentests deberían comprobarlo como root user o alguien con acceso físico al dispositivo podría robar estos datos. -Incluso si una aplicación almacena datos en el keystore, los datos deben estar cifrados. +Incluso si una app almacena datos en el Keystore, los datos deberían estar cifrados. -Para acceder a los datos dentro del keystore, podrías 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 ``` -### **Bypass de huellas dactilares/biométricos** +### **Fingerprint/Biometrics Bypass** -Usando el siguiente script de Frida, podría ser posible **eludir la autenticación por huella dactilar** que las aplicaciones de Android podrían estar realizando para **proteger ciertas áreas sensibles:** +Usando el siguiente script de Frida podría ser posible **bypass fingerprint authentication** que realizan las aplicaciones Android para **proteger ciertas áreas sensibles:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` -### **Imágenes de Fondo** +### **Imágenes de fondo** -Cuando pones una aplicación en segundo plano, Android almacena un **instantánea de la aplicación** para que cuando se recupere al primer plano, comience a cargar la imagen antes de la app, por lo que parece que la app se cargó más rápido. +Cuando pones una aplicación en segundo plano, Android guarda una **instantánea de la aplicación** para que, al recuperarla al primer plano, empiece cargando la imagen antes que la app y 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** (ten en cuenta que necesitas 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** (nota: necesitas root para acceder a ella). Las instantáneas suelen almacenarse en: **`/data/system_ce/0/snapshots`** -Android proporciona una forma de **prevenir la captura de pantalla configurando el parámetro de diseño FLAG_SECURE**. Al usar esta bandera, 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, impidiendo que aparezca en capturas de pantalla o que se muestre en displays no seguros. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` -### **Analizador de Aplicaciones Android** +### **Android Application Analyzer** Esta herramienta puede ayudarte a gestionar diferentes herramientas durante el análisis dinámico: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) -### Inyección de Intents +### Intent Injection -Los desarrolladores a menudo crean componentes proxy como actividades, servicios y receptores de difusión que manejan estos Intents y los pasan a métodos como `startActivity(...)` o `sendBroadcast(...)`, lo que puede ser arriesgado. +Los desarrolladores suelen crear proxy components como activities, services y broadcast receivers que manejan estos Intents y los pasan a métodos como `startActivity(...)` o `sendBroadcast(...)`, lo cual puede ser riesgoso. -El peligro radica en permitir que los atacantes activen componentes de la aplicación no exportados o accedan a proveedores de contenido sensibles al desviar estos Intents. Un ejemplo notable es el componente `WebView` que convierte URLs en objetos `Intent` a través de `Intent.parseUri(...)` y luego los ejecuta, lo que puede llevar a inyecciones de Intent maliciosas. +El peligro radica en permitir a los atacantes activar componentes de la app non-exported o acceder a content providers sensibles redirigiendo indebidamente estos Intents. Un ejemplo notable es el componente `WebView` convirtiendo URLs a objetos `Intent` mediante `Intent.parseUri(...)` y luego ejecutándolos, lo que puede conducir a malicious Intent injections. -### Conclusiones Esenciales +### Puntos esenciales -- **Inyección de Intents** es similar al problema de Redirección Abierta en la web. +- **Intent Injection** es similar al Open Redirect en la web. - Los exploits implican pasar objetos `Intent` como extras, que pueden ser redirigidos para ejecutar operaciones inseguras. -- Puede exponer componentes no exportados y proveedores de contenido a los atacantes. -- La conversión de URL a `Intent` de `WebView` puede facilitar acciones no intencionadas. +- Puede exponer componentes non-exported y content providers a atacantes. +- La conversión de URLs a `Intent` por parte de `WebView` puede facilitar acciones no deseadas. -### Inyecciones del Lado del Cliente en Android y otros +### Inyecciones del lado del cliente en Android y otros -Probablemente conozcas este tipo de vulnerabilidades de la web. Debes tener especial cuidado con estas vulnerabilidades en una aplicación Android: +Probablemente conozcas este tipo de vulnerabilidades desde la Web. Debes tener especial cuidado con estas vulnerabilidades en una aplicación Android: -- **Inyección SQL:** Al tratar con consultas dinámicas o Content-Providers, asegúrate de usar consultas parametrizadas. -- **Inyección de JavaScript (XSS):** Verifica que el soporte de JavaScript y Plugins esté deshabilitado para cualquier WebView (deshabilitado por defecto). [Más información aquí](webview-attacks.md#javascript-enabled). -- **Inclusión de Archivos Locales:** Los WebViews deben tener el acceso al sistema de archivos deshabilitado (habilitado por defecto) - `(webview.getSettings().setAllowFileAccess(false);)`. [Más información aquí](webview-attacks.md#javascript-enabled). -- **Cookies Eternas**: En varios casos, cuando la aplicación android finaliza la sesión, la cookie no se revoca o incluso puede ser guardada en el disco. +- **SQL Injection:** Cuando trates con 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). [Más información aquí](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** Las WebViews deberían tener el acceso al sistema de archivos deshabilitado (habilitado por defecto) - `(webview.getSettings().setAllowFileAccess(false);)`. [Más información aquí](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 ser guardada en disco - [**Secure Flag** en cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Análisis Automático +## Análisis automático ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) @@ -540,51 +597,51 @@ Probablemente conozcas este tipo de vulnerabilidades de la web. Debes tener espe ![](<../../images/image (866).png>) -**Evaluación de vulnerabilidades de la aplicación** utilizando un bonito frontend basado en la web. También puedes realizar análisis dinámico (pero necesitas preparar el entorno). +**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). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Nota que MobSF puede analizar **Android**(apk)**, IOS**(ipa) **y Windows**(apx) aplicaciones (_Las aplicaciones de Windows deben ser analizadas desde un MobSF instalado en un host de Windows_).\ -Además, si creas un archivo **ZIP** con el código fuente de una aplicación **Android** o **IOS** (ve a la carpeta raíz de la aplicación, selecciona todo y crea un archivo ZIP), también podrá analizarlo. +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. -MobSF también te permite **diff/Comparar** análisis e integrar **VirusTotal** (necesitarás configurar tu clave API en _MobSF/settings.py_ y habilitarlo: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). También puedes establecer `VT_UPLOAD` en `False`, entonces el **hash** será **subido** en lugar del archivo. +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 = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. -### Análisis dinámico asistido con MobSF +### Assisted Dynamic analysis with MobSF -**MobSF** también puede ser muy útil para el **análisis dinámico** en **Android**, pero en ese caso necesitarás instalar MobSF y **genymotion** en tu host (una VM o Docker no funcionará). _Nota: Necesitas **iniciar primero una VM en genymotion** y **luego MobSF.**_\ -El **analizador dinámico de MobSF** puede: +**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: -- **Volcar datos de la aplicación** (URLs, registros, portapapeles, capturas de pantalla hechas por ti, capturas de pantalla hechas por "**Exported Activity Tester**", correos electrónicos, bases de datos SQLite, archivos XML y otros archivos creados). Todo esto se hace automáticamente excepto por las capturas de pantalla, necesitas presionar cuando quieras una captura de pantalla o necesitas presionar "**Exported Activity Tester**" para obtener capturas de pantalla de todas las actividades exportadas. -- Capturar **tráfico HTTPS** -- Usar **Frida** para obtener **información** **en tiempo de ejecución** +- **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. +- Capture **HTTPS traffic** +- Use **Frida** to obtain **runtime** **information** -Desde versiones de android **> 5**, **iniciará automáticamente Frida** y establecerá configuraciones de **proxy** globales para **capturar** tráfico. Solo capturará tráfico de la aplicación probada. +From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. **Frida** -Por defecto, también usará algunos scripts de Frida para **eludir la fijación de SSL**, **detección de root** y **detección de depuradores** y para **monitorear APIs interesantes**.\ -MobSF también puede **invocar actividades exportadas**, tomar **capturas de pantalla** de ellas y **guardarlas** para el informe. +By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ +MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. -Para **iniciar** la prueba dinámica presiona el botón verde: "**Start Instrumentation**". Presiona "**Frida Live Logs**" para ver los registros generados por los scripts de Frida y "**Live API Monitor**" para ver todas las invocaciones a métodos enganchados, argumentos pasados y valores devueltos (esto aparecerá después de presionar "Start Instrumentation").\ -MobSF también te permite cargar tus propios **scripts de Frida** (para enviar los resultados de tus scripts de Frida a MobSF usa la función `send()`). También tiene **varios scripts preescritos** que puedes cargar (puedes agregar más en `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), solo **selecciónalos**, presiona "**Load**" y presiona "**Start Instrumentation**" (podrás ver los registros de esos scripts dentro de "**Frida Live Logs**"). +To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ +MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). ![](<../../images/image (419).png>) -Además, tienes algunas funcionalidades auxiliares de Frida: +Moreover, you have some Auxiliary Frida functionalities: -- **Enumerar Clases Cargadas**: Imprimirá todas las clases cargadas -- **Capturar Cadenas**: Imprimirá todas las cadenas capturadas mientras usas la aplicación (muy ruidoso) -- **Capturar Comparaciones de Cadenas**: Podría ser muy útil. **Mostrará las 2 cadenas que se están comparando** y si el resultado fue Verdadero o Falso. -- **Enumerar Métodos de Clase**: Pon el nombre de la clase (como "java.io.File") e imprimirá todos los métodos de la clase. -- **Buscar Patrón de Clase**: Buscar clases por patrón -- **Rastrear Métodos de Clase**: **Rastrear** una **clase completa** (ver entradas y salidas de todos los métodos de la clase). Recuerda que por defecto MobSF rastrea varios métodos interesantes de la API de Android. +- **Enumerate Loaded Classes**: Imprimirá todas las clases cargadas +- **Capture Strings**: Imprimirá todas las cadenas capturadas mientras usas la aplicación (muy ruidoso) +- **Capture String Comparisons**: Puede ser muy útil. Mostrará las 2 cadenas 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 listará todos los métodos de la clase. +- **Search Class Pattern**: Busca clases por patrón +- **Trace Class Methods**: Traza una clase completa (ver entradas y salidas de todos los métodos de la clase). Recuerda que por defecto MobSF traza varios métodos interesantes de la API de Android. -Una vez que hayas seleccionado el módulo auxiliar que deseas usar, necesitas presionar "**Start Intrumentation**" y verás todas las salidas en "**Frida Live Logs**". +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**". **Shell** -Mobsf también te ofrece una shell con algunos comandos **adb**, **comandos de MobSF**, y comandos comunes de **shell** en la parte inferior de la página de análisis dinámico. Algunos comandos interesantes: +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: ```bash help shell ls @@ -595,32 +652,32 @@ receivers ``` **Herramientas HTTP** -Cuando se captura tráfico http, puedes ver una vista fea del tráfico capturado en "**HTTP(S) Traffic**" en la parte 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 hacerlo, _enciende Burp -->_ _apaga Intercept --> en MobSB HTTPTools selecciona la solicitud_ --> presiona "**Send to Fuzzer**" --> _selecciona la dirección del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Cuando se captura tráfico HTTP puedes ver una vista tosca del tráfico capturado en el botón "**HTTP(S) Traffic**" 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 u Owasp ZAP.\ +Para ello, _enciende Burp -->_ _desactiva Intercept --> en MobSF 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)). -Una vez que termines el análisis dinámico con MobSF, puedes presionar "**Start Web API Fuzzer**" para **fuzz http requests** y buscar vulnerabilidades. +Una vez termines el análisis dinámico con MobSF puedes pulsar "**Start Web API Fuzzer**" para **fuzzear solicitudes HTTP** y buscar vulnerabilidades. > [!TIP] -> Después de realizar un análisis dinámico con MobSF, la configuración del proxy puede estar mal configurada y no podrás solucionarlo desde la GUI. Puedes corregir la configuración del proxy haciendo: +> 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 ejecutando: > > ``` > 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 de [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Esta herramienta utilizará algunos **Hooks** para informarte **qué está sucediendo en la aplicación** mientras realizas un **análisis dinámico**. +Puedes obtener la herramienta en [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ +Esta herramienta usa algunos **Hooks** para mostrarte **qué está ocurriendo en la aplicación** mientras llevas a cabo un **análisis dinámico**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Esta es una **gran herramienta para realizar análisis estático con una GUI** +Esta es una **excelente herramienta para realizar análisis estático con una GUI** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Esta herramienta está diseñada para buscar varias **vulnerabilidades relacionadas con la seguridad de aplicaciones Android**, ya sea en **código fuente** o **APKs empaquetados**. La herramienta también es **capaz de crear un APK "Proof-of-Concept" desplegable** y **comandos ADB**, para explotar algunas de las vulnerabilidades encontradas (Actividades expuestas, intents, tapjacking...). Al igual que con Drozer, no es necesario rootear el dispositivo de prueba. +Esta herramienta está diseñada para buscar varias vulnerabilidades relacionadas con la seguridad en aplicaciones Android, ya sea en el **source code** o en **packaged APKs**. La herramienta también es capaz de crear un APK desplegable tipo **"Proof-of-Concept"** y generar **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. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -629,10 +686,10 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Muestra todos los archivos extraídos para una fácil referencia -- Descompone automáticamente archivos APK a formato Java y Smali +- Muestra todos los archivos extraídos para referencia rápida +- 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 para vulnerabilidades y comportamientos comunes +- Análisis estático del código fuente en busca de vulnerabilidades y comportamientos comunes - Información del dispositivo - y más ```bash @@ -640,11 +697,11 @@ 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 se puede utilizar 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 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. Hace esto descomprimiendo APKs y aplicando una serie de reglas para detectar esas vulnerabilidades. -Todas las reglas están centradas en un archivo `rules.json`, y cada empresa o tester podría crear sus propias reglas para analizar lo que necesiten. +Todas las reglas se centralizan en un archivo `rules.json`, y cada empresa o tester puede crear sus propias reglas para analizar lo que necesiten. -Descargue los últimos binarios en la [página de descarga](https://superanalyzer.rocks/download.html) +Descarga los binarios más recientes desde la [download page](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -652,17 +709,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn es una herramienta **multiplataforma** que ayuda a desarrolladores, cazadores de bugs y hackers éticos a realizar [análisis de código estático](https://en.wikipedia.org/wiki/Static_program_analysis) en aplicaciones móviles. +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. -El concepto es que arrastras y sueltas tu archivo de aplicación móvil (un archivo .apk o .ipa) en la aplicación StaCoAn y generará un informe visual y portátil para ti. Puedes ajustar la configuración y las listas de palabras para obtener una experiencia personalizada. +El concepto es que arrastres y sueltes el archivo de tu aplicación móvil (un archivo .apk o .ipa) en la aplicación StaCoAn y esta generará un informe visual y portable para ti. Puedes ajustar la configuración y las wordlists para obtener una experiencia personalizada. -Descargar [última versión](https://github.com/vincentcox/StaCoAn/releases): +Download[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework es un sistema de análisis de vulnerabilidades de Android que ayuda a desarrolladores o hackers a encontrar posibles vulnerabilidades de seguridad en aplicaciones de Android.\ +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.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -670,11 +727,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** es una herramienta cuyo objetivo principal es detectar y advertir al usuario sobre comportamientos potencialmente maliciosos desarrollados por una aplicación de Android. +**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 con el **análisis estático** del bytecode Dalvik de la aplicación, representado como **Smali**, con la biblioteca [`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, interceptación de flujos de audio/video, modificación de datos PIM, ejecución de código arbitrario... +Esta herramienta busca **comportamientos comunes de aplicaciones "malas"** 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 ``` @@ -682,79 +739,82 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** es un **M**obile **A**pplication **R**everse engineering y **A**nalysis Framework. Es una herramienta que reúne herramientas comúnmente utilizadas para la ingeniería inversa y análisis de aplicaciones móviles, para ayudar en la prueba de aplicaciones móviles contra las amenazas de seguridad móvil de OWASP. Su objetivo es facilitar esta tarea y hacerla más amigable para los desarrolladores de aplicaciones móviles y profesionales de seguridad. +**MARA** es un Framework de Ingeniería Inversa y Análisis de Aplicaciones Móviles. Es una herramienta que agrupa herramientas comúnmente usadas para la ingeniería inversa y el 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 amigable para desarrolladores de aplicaciones móviles y profesionales de seguridad. Es capaz de: -- Extraer código Java y Smali utilizando diferentes herramientas +- 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 expresiones regulares. +- 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) y [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Desofuscar APK a través de [apk-deguard.com](http://www.apk-deguard.com) +- Analizar los dominios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) y [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Desofuscar APK vía [apk-deguard.com](http://www.apk-deguard.com) ### Koodous Útil para detectar malware: [https://koodous.com/](https://koodous.com) -## Ofuscando/Desofuscando código +## Obfuscating/Deobfuscating code -Tenga en cuenta que dependiendo del servicio y la configuración que utilice para ofuscar el código. Los secretos pueden o no terminar ofuscados. +Tenga en cuenta que, dependiendo del servicio y la configuración que use para ofuscar el código, los secretos pueden o no terminar ofuscados. ### [ProGuard]() -De [Wikipedia](): **ProGuard** es una herramienta de línea de comandos de código abierto que reduce, optimiza y ofusca el código Java. Es capaz de optimizar bytecode así como detectar y eliminar instrucciones no utilizadas. ProGuard es software libre y se distribuye bajo la Licencia Pública General de GNU, versión 2. +From [Wikipedia](): **ProGuard** es una herramienta de línea de comandos de código abierto que reduce, optimiza y ofusca código Java. 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 se distribuye como parte del SDK de Android y se ejecuta al construir la aplicación en modo de lanzamiento. +ProGuard se distribuye como parte del Android SDK y se ejecuta al compilar la aplicación en modo release. ### [DexGuard](https://www.guardsquare.com/dexguard) Encuentra una guía paso a paso para desofuscar el apk en [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(De esa guía) La última vez que verificamos, el modo de operación de Dexguard era: +(Según esa guía) La última vez que comprobamos, el modo de operación de Dexguard era: - cargar un recurso como un InputStream; -- alimentar el resultado a una clase que hereda de FilterInputStream para descifrarlo; -- hacer alguna ofuscación inútil para perder unos minutos de tiempo de un reversor; -- alimentar el resultado descifrado a un ZipInputStream para obtener un archivo DEX; -- finalmente cargar el DEX resultante como un Recurso usando el método `loadDex`. +- pasar el resultado a una clase que hereda de FilterInputStream para descifrarlo; +- hacer alguna ofuscación inútil para hacer perder unos minutos a un analista de ingeniería inversa; +- pasar el resultado descifrado a un ZipInputStream para obtener un archivo DEX; +- finalmente cargar el DEX resultante como un Resource usando el método `loadDex`. ### [DeGuard](http://apk-deguard.com) -**DeGuard revierte el proceso de ofuscación realizado por herramientas de ofuscación de Android. Esto permite numerosos análisis de seguridad, incluyendo inspección de código y predicción de bibliotecas.** +**DeGuard invierte el proceso de ofuscación realizado por las herramientas de ofuscación de Android. Esto permite numerosos análisis de seguridad, incluyendo la inspección de código y la identificación de librerías.** Puedes subir un APK ofuscado a su plataforma. -### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app) +### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -Esta es una herramienta LLM para encontrar cualquier vulnerabilidad de seguridad potencial en aplicaciones android y desofuscar el código de aplicaciones android. Utiliza la API pública de Gemini de Google. +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. ### [Simplify](https://github.com/CalebFenton/simplify) -Es un **desofuscador genérico de android.** Simplify **ejecuta virtualmente una aplicación** para entender su comportamiento y luego **intenta optimizar el código** para que se comporte de manera idéntica pero sea más fácil de entender para un humano. Cada tipo de optimización es simple y genérico, por lo que no importa qué tipo específico de ofuscación se utilice. +Es un deofuscador genérico para android. Simplify ejecuta virtualmente una app para entender su comportamiento y luego intenta optimizar el código para que se comporte de forma idéntica pero sea más fácil de entender para un humano. Cada tipo de optimización es simple y genérica, por lo que no importa qué tipo específico de ofuscación se haya usado. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD te da información sobre **cómo se hizo un APK**. Identifica muchos **compiladores**, **empaquetadores**, **ofuscadores**, y otras cosas raras. Es [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android. +APKiD te da información sobre cómo se hizo un APK. Identifica muchos compiladores, packers, ofuscadores y otras cosas raras. Es el [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android. ### Manual -[Lee este tutorial para aprender algunos trucos sobre **cómo revertir la ofuscación personalizada**](manual-deobfuscation.md) +[Lee este tutorial para aprender algunos trucos sobre cómo revertir ofuscaciones personalizadas](manual-deobfuscation.md) ## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b es una máquina virtual de seguridad de Android basada en ubuntu-mate que incluye la colección de los últimos frameworks, tutoriales y laboratorios de diferentes expertos en seguridad e investigadores para ingeniería inversa y análisis de malware. +AndroL4b es una máquina virtual de seguridad Android basada en ubuntu-mate que incluye la colección de los últimos frameworks, tutoriales y labs de diferentes entusiastas e investigadores de seguridad para reverse engineering y análisis de malware. ## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Es una gran lista de recursos -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Curso rápido de Android +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) +- [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) ## Yet to try