maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/mobile-pentesting/android-app-pentesting/android-an

Browse Source
This commit is contained in:
Translator 2025-09-08 01:36:53 +00:00
parent 76f265906a
commit ebd9c7b203
5 changed files with 580 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

481
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -1,10 +1,10 @@
# Aplicações Android Pentesting
# Pentesting de Aplicações Android
{{#include ../../banners/hacktricks-training.md}}
## Noções Básicas sobre Aplicações Android
## Conceitos Básicos de Aplicações Android
É fortemente recomendado começar lendo esta página para conhecer as **partes mais importantes relacionadas à segurança Android e os componentes mais perigosos em uma aplicação Android**:
É altamente recomendável começar por ler esta página para conhecer as **partes mais importantes relacionadas à segurança do Android e os componentes mais perigosos em uma aplicação Android**:
{{#ref}}
@ -13,23 +13,23 @@ android-applications-basics.md
## ADB (Android Debug Bridge)
Esta é a ferramenta principal que você precisa para se conectar a um dispositivo Android (emulado ou físico).\
**ADB** permite controlar dispositivos tanto via **USB** quanto via **Network** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de apps, **execução** de comandos shell, **backup** de dados, **leitura** de logs, entre outras funções.
Esta é a ferramenta principal que você precisa para conectar-se a um dispositivo Android (emulado ou físico).\
**ADB** permite controlar dispositivos tanto via **USB** quanto via **Network** a partir de um computador. Esta utilidade possibilita o **copiamento** de arquivos em ambas direções, a **instalação** e **desinstalação** de apps, a **execução** de comandos shell, o **backup** de dados, a **leitura** de logs, entre outras funções.
Dê uma olhada na seguinte lista de [**ADB Commands**](adb-commands.md) para aprender a usar o adb.
Veja a seguinte lista de [**ADB Commands**](adb-commands.md) para aprender a usar o adb.
## Smali
Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas ou flags bem ofuscadas). Nesse caso, pode ser interessante decompilar o APK, modificar o código e recompilá-lo.\
[**Neste tutorial** você pode **aprender como decompilar um APK, modificar código Smali e recompilar o APK** com a nova funcionalidade](smali-changes.md). Isso pode ser muito útil como uma **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Portanto, **mantenha sempre em mente essa possibilidade**.
Por vezes é interessante **modificar o código da aplicação** para acessar **informações escondidas** (talvez senhas bem ofuscadas ou flags). Nesse caso, pode ser interessante decompilar o apk, modificar o código e recompilar o apk.\
[**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). Isto pode ser muito útil como uma **alternativa para vários testes durante o dynamic analysis** que serão apresentados. Portanto, **tenha sempre em mente essa possibilidade**.
## Outros truques interessantes
## Outras dicas interessantes
- [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md)
- [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)
- **Baixar 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)
- **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)
- Extrair APK do dispositivo:
```bash
adb shell pm list packages
@ -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
```
- Mescle todos os splits e os base apks com [APKEditor](https://github.com/REAndroid/APKEditor):
- Mescle todos os splits e apks base com [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
@ -68,32 +68,32 @@ Please, [**read here to find information about different available decompilers**
### Procurando informações interessantes
Basta olhar as **strings** do APK para procurar **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais de admin hardcoded no app).
Apenas dando uma olhada nas **strings** do APK você pode procurar por **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais admin hardcoded no app).
**Firebase**
Preste atenção especial às URLs do **Firebase** e verifique se está mal configurado. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
Preste atenção especial às **firebase URLs** e verifique se está mal configurado. [Mais informação sobre o que é Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Compreensão básica da aplicação - Manifest.xml, strings.xml
### Entendimento básico da aplicação - Manifest.xml, strings.xml
A **examinação dos arquivos _Manifest.xml_ e _strings.xml_ de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompilers ou renomeando a extensão do APK para .zip e então descompactando-o.
A **examinação dos arquivos _Manifest.xml_ e _strings.xml_ de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do APK para .zip e descompactando-o.
**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem:
- **Debuggable Applications**: Aplicações definidas como debuggable (`debuggable="true"`) no _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para mais detalhes sobre como explorar aplicações debuggable, consulte um tutorial sobre encontrar e explorar aplicações debuggable em um dispositivo.
- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis, para prevenir backups não autorizados via adb, especialmente quando o usb debugging está habilitado.
- **Network Security**: Configurações customizadas de network security (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
- **Exported Activities and Services**: Identificar activities e services exportados no manifest pode evidenciar componentes que podem ser mal utilizados. Análises adicionais durante testes dinâmicos podem revelar como explorar esses componentes.
- **Debuggable Applications**: Aplicações marcadas como debuggable (`debuggable="true"`) no _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para entender melhor como explorar aplicações debuggable, consulte um tutorial sobre como encontrar e explorar aplicações debuggable em um dispositivo.
- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups não autorizados via adb, especialmente quando usb debugging está ativado.
- **Network Security**: Configurações de network security customizadas (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
- **Exported Activities and Services**: Identificar activities e services exportados no manifest pode destacar componentes que podem ser mal utilizados. Análises adicionais durante testes dinâmicos podem revelar como explorar esses componentes.
- **Content Providers and FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser examinada.
- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção especial em como as URL schemes são gerenciadas para vulnerabilidades de input.
- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões antigas e vulneráveis do Android por motivos de segurança.
- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção particular a como os URL schemes são gerenciados para vulnerabilidades de input.
- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões antigas e vulneráveis do Android por razões de segurança.
A partir do **strings.xml**, informações sensíveis como API keys, custom schemas e outras notas de desenvolvedores podem ser descobertas, ressaltando a necessidade de revisar cuidadosamente esses recursos.
A partir do arquivo **strings.xml**, informações sensíveis como API keys, custom schemas e outras notas de desenvolvedor podem ser descobertas, ressaltando a necessidade de revisão cuidadosa desses recursos.
### Tapjacking
**Tapjacking** é um ataque onde uma **malicious application** é lançada e se **posiciona sobre uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface é projetada de forma a enganar o usuário para interagir com ela, enquanto repassa a interação para o app vítima.\
Em efeito, é **cegar o usuário quanto ao fato de que ele está realmente realizando ações no app vítima**.
**Tapjacking** é um ataque onde uma **malicious application** é iniciada e **se posiciona por cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface é desenhada de forma a enganar o usuário para interagir com ela, enquanto repassa a interação para o app vítima.\
Na prática, é **cegar o usuário para que ele não saiba que na verdade está executando ações no app vítima**.
Find more information in:
@ -104,7 +104,7 @@ tapjacking.md
### Task Hijacking
Uma **activity** com o **`launchMode`** definido como **`singleTask` sem qualquer `taskAffinity`** definida é vulnerável ao Task Hijacking. Isso significa que uma **application** pode ser instalada e, se iniciada antes da aplicação real, poderia **hijackar a task da aplicação real** (então o usuário estará interagindo com a **malicious application** pensando que está usando a aplicação real).
Uma **activity** com o **`launchMode`** definido como **`singleTask` sem nenhum `taskAffinity`** definido é vulnerável a Task Hijacking. Isso significa que uma **application** pode ser instalada e, se for lançada antes da aplicação real, poderia **hijack the task of the real application** (portanto o usuário estará interagindo com a **malicious application pensando que está usando a aplicação real**).
More info in:
@ -113,73 +113,73 @@ More info in:
android-task-hijacking.md
{{#endref}}
### Armazenamento de dados inseguro
### Insecure data storage
**Armazenamento Interno**
**Internal Storage**
No **Android**, arquivos **armazenados** no **internal storage** são **projetados** para serem **acessíveis** exclusivamente pela **app** que os **criou**. Essa medida de segurança é **aplicada** pelo sistema operacional Android e é geralmente adequada para as necessidades de segurança da maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Ainda assim, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo potenciais maliciosas.
No Android, arquivos **armazenados** em **internal** storage são **projetados** para serem **acessíveis** exclusivamente pelo **app** que os **criou**. Essa medida de segurança é **aplicada** pelo sistema operacional Android e geralmente é adequada para as necessidades de segurança da maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Ainda assim, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo possivelmente maliciosas.
1. **Static Analysis:**
- **Ensure** que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente escrutinado**. Esses modos **podem expor potencialmente** arquivos a **acessos não intencionais ou não autorizados**.
- **Verifique** cuidadosamente o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE`. Esses modos **podem expor** arquivos a **acesso não intencional ou não autorizado**.
2. **Dynamic Analysis:**
- **Verify** as **permissions** definidas em arquivos criados pelo app. Especificamente, **cheque** se algum arquivo está **definido como legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, a **ler ou modificar** esses arquivos.
- **Confirme** as **permissões** definidas em arquivos criados pelo app. Especificamente, **verifique** se algum arquivo está **definido como legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria que **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, **leia ou modifique** esses arquivos.
**Armazenamento Externo**
**External Storage**
Ao lidar com arquivos no **external storage**, como SD Cards, certas precauções devem ser tomadas:
Ao lidar com arquivos em **external storage**, como SD Cards, certas precauções devem ser tomadas:
1. **Accessibility**:
- Arquivos no external storage são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos.
2. **Security Concerns**:
- Dada a facilidade de acesso, é recomendado **não armazenar informações sensíveis** no external storage.
- O external storage pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro.
3. **Handling Data from External Storage**:
- Sempre **realize validação de entrada** nos dados recuperados do external storage. Isso é crucial porque os dados vêm de uma fonte não confiável.
- Evite armazenar executáveis ou arquivos de classe no external storage para carregamento dinâmico.
- Se sua aplicação precisar recuperar arquivos executáveis do external storage, assegure que esses arquivos estejam **signed and cryptographically verified** antes de serem carregados dinamicamente. Esse passo é vital para manter a integridade de segurança da sua aplicação.
1. **Acessibilidade**:
- Arquivos em external storage são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos.
2. **Preocupações de Segurança**:
- Dada a facilidade de acesso, é aconselhável **não armazenar informações sensíveis** em external storage.
- External storage pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro.
3. **Tratamento de Dados vindos de External Storage**:
- Sempre **faça validação de input** em dados recuperados de external storage. Isso é crucial porque os dados vêm de uma fonte não confiável.
- Armazenar executáveis ou arquivos .class em external storage para carregamento dinâmico é fortemente desaconselhado.
- Se sua aplicação precisa recuperar arquivos executáveis de external storage, certifique-se de que esses arquivos estejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Essa etapa é vital para manter a integridade de segurança da sua aplicação.
External storage pode ser **acessado** em `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
> [!TIP]
> A partir do Android 4.4 (**API 17**), o SD card possui uma estrutura de diretórios que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou escrita aos arquivos de outro app.
> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretórios que **limita o acesso de um app ao diretório que é especificamente daquele app**. Isso evita que uma malicious application obtenha acesso de leitura ou escrita aos arquivos de outro app.
**Dados sensíveis armazenados em texto claro**
**Sensitive data stored in clear-text**
- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data/<packagename>/shared_prefs/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta.
- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data/<packagename>/databases/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta.
- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data/<packagename>/shared_prefs/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta.
- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data/<packagename>/databases/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta.
### Broken TLS
**Accept All Certificates**
Por alguma razão, às vezes os desenvolvedores aceitam todos os certificados mesmo que, por exemplo, o hostname não coincida, com linhas de código como a seguinte:
Por algum motivo, às vezes desenvolvedores aceitam todos os certificados mesmo se, por exemplo, o hostname não corresponder, com linhas de código como a seguinte:
```java
SSLSocketFactory sf = new cc(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
```
Uma boa forma de testar isso é tentar capturar o tráfego usando algum proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Além disso, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo.
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.
### Criptografia Quebrada
### Criptografia quebrada
**Processos de gerenciamento de chaves inadequados**
**Poor Key Management Processes**
Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave hardcoded/predictable no código. Isso não deve ser feito, pois algum reversing pode permitir que atacantes extraiam as informações confidenciais.
Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os encriptam com uma chave hardcoded/predictable no código. Isso não deveria ser feito, pois algum reversing poderia permitir que atacantes extraiam a informação confidencial.
**Uso de algoritmos inseguros e/ou obsoletos**
**Use of Insecure and/or Deprecated Algorithms**
Developers não devem usar **deprecated algorithms** para realizar verificações de authorisation **checks**, **store** ou **send** data. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** são usados para armazenar passwords por exemplo, devem ser usados hashes resistentes a brute-force com salt.
Desenvolvedores não deveriam usar **deprecated algorithms** para realizar **authorisation checks**, **store** ou **send** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas por exemplo, hashes brute-force **resistant** deveriam ser usados com salt.
### Outras verificações
- É recomendado **obfuscar o APK** para dificultar o trabalho de reverse engineer aos atacantes.
- Se o app for sensível (como apps bancários), ele deve realizar suas **próprias verificações para ver se o mobile está rooted** e agir em conformidade.
- Se o app for sensível (como apps bancários), ele deve verificar se um **emulator** está sendo usado.
- Se o app for sensível (como apps bancários), ele deve **verificar sua própria integridade antes de executar** para checar se foi modificado.
- Use [**APKiD**](https://github.com/rednaga/APKiD) para checar qual compiler/packer/obfuscator foi usado para construir o APK
- É recomendado **obfuscar o APK** para dificultar o trabalho de reverse engineering dos atacantes.
- Se o app for sensível (como apps bancários), ele deveria executar suas **próprias verificações para ver se o mobile está rootado** e agir em consequência.
- Se o app for sensível (como apps bancários), ele deveria checar se um **emulador** está sendo usado.
- Se o app for sensível (como apps bancários), ele deveria **verificar sua própria integridade antes de executar** para checar se foi modificado.
- Use [**APKiD**](https://github.com/rednaga/APKiD) para verificar qual compiler/packer/obfuscator foi usado para construir o APK
### React Native Application
Read the following page to learn how to easily access javascript code of React applications:
Leia a seguinte página para aprender como acessar facilmente o código javascript de aplicações React:
{{#ref}}
@ -188,7 +188,7 @@ react-native-application.md
### Xamarin Applications
Read the following page to learn how to easily access C# code of a xamarin applications:
Leia a página seguinte para aprender como acessar facilmente o código C# de aplicações Xamarin:
{{#ref}}
@ -201,9 +201,9 @@ According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpa
### Automated Static Code Analysis
The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability.
A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilities** ao **scan** do **code** da aplicação. Essa ferramenta contém uma série de **known sources** (que indica ao tool os **lugares** onde o **input** é **controlled by the user**), **sinks** (que indica ao tool **dangerous** **places** onde input malicioso do usuário poderia causar danos) e **rules**. Essas rules indicam a **combination** de **sources-sinks** que indicam uma vulnerability.
With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**.
Com esse conhecimento, **mariana-trench vai revisar o código e encontrar possíveis vulnerabilities nele**.
### Secrets leaked
@ -216,12 +216,12 @@ An application may contain secrets (API keys, passwords, hidden urls, subdomains
bypass-biometric-authentication-android.md
{{#endref}}
### Other interesting functions
### Outras funções interessantes
- **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)
- **Native functions** declaradas como `native`: `public native, System.loadLibrary, System.load`
- [Leia isto para aprender **como reverter native functions**](reversing-native-libraries.md)
### **Other tricks**
@ -234,25 +234,25 @@ content-protocol.md
---
## Dynamic Analysis
## Análise Dinâmica
> 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.
> Primeiro, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (Burp CA cert, Drozer and Frida mainly). Portanto, um dispositivo rootado (emulado ou não) é extremamente recomendado.
### Online Dynamic analysis
### Análise dinâmica online
You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving.
Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io). Essa plataforma permite **upload** e **execução** de APKs, então é útil para ver como um apk está se comportando.
You can even **see the logs of your application** in the web and connect through **adb**.
Você pode até **ver os logs da sua aplicação** na web e conectar via **adb**.
![](<../../images/image (831).png>)
Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators.
Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emuladores.
### Local Dynamic Analysis
### Análise dinâmica local
#### Using an emulator
#### Usando um emulador
- [**Android Studio**](https://developer.android.com/studio) (Você pode criar **x86** e **arm** devices, e de acordo com [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** sem precisar de um lento emulator arm).
- [**Android Studio**](https://developer.android.com/studio) (Você pode criar dispositivos **x86** e **arm**, e de acordo com [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator).
- Aprenda a configurá-lo nesta página:
@ -260,36 +260,44 @@ Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emu
avd-android-virtual-device.md
{{#endref}}
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Personal Edition, é necessário criar uma conta. _É recomendado **baixar** a versão **WITH** _**VirtualBox** para evitar erros potenciais._)
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Personal Edition, é necessário criar uma conta. _É recomendado **download** da versão **WITH** _**VirtualBox** para evitar potenciais erros._)
- [**Nox**](https://es.bignox.com) (Gratuito, mas não suporta Frida ou Drozer).
> [!TIP]
> Ao criar um novo emulator em qualquer plataforma lembre-se que quanto maior a tela, mais lento o emulator irá rodar. Então selecione telas pequenas se possível.
> Ao criar um novo emulador em qualquer plataforma lembre-se que quanto maior a tela, mais lento o emulador irá rodar. Então selecione telas pequenas se possível.
To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image:
Para **instalar google services** (como AppStore) no Genymotion você precisa clicar no botão marcado em vermelho da imagem seguinte:
![](<../../images/image (277).png>)
Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools).
Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar **Bridge Network mode** (isso será útil se você for conectar à VM Android a partir de uma VM diferente com as ferramentas).
#### Use a physical device
#### Use um dispositivo físico
Você precisa ativar as opções de **debugging** e é recomendável que você possa **root** o dispositivo:
Você precisa ativar as opções de **debugging** e seria bom se você puder **rootear**:
1. **Configurações**.
2. (A partir do Android 8.0) Selecione **Sistema**.
3. Selecione **Sobre o telefone**.
4. Pressione **Número da versão** 7 vezes.
5. Volte e você encontrará as **Opções do desenvolvedor**.
1. **Settings**.
2. (FromAndroid 8.0) Selecione **System**.
3. Selecione **About phone**.
4. Pressione **Build number** 7 vezes.
5. Volte e você encontrará as **Developer options**.
> Once you have installed the application, the first thing you should do is to try it and investigate what does it do, how does it work and get comfortable with it.\
> I will suggest to **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, so we will be able to **learn how the application works** while MobSF **captures** a lot of **interesting** **data** you can review later on.
> Uma vez que você tenha instalado a aplicação, a primeira coisa que deveria fazer é testá-la e investigar o que ela faz, como funciona e ficar confortável com ela.\
> Sugiro **realizar essa análise dinâmica inicial usando MobSF dynamic analysis + pidcat**, assim seremos capazes de **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar mais tarde.
### Unintended Data Leakage
Magisk/Zygisk quick notes (recommended on Pixel devices)
- 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
### Vazamento não intencional de dados
**Logging**
Desenvolvedores devem ter cautela ao expor **informações de debugging** publicamente, pois isso pode levar a leak de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar os logs da aplicação para identificar e proteger informações sensíveis. **Pidcat** é preferida por sua facilidade de uso e legibilidade.
Desenvolvedores devem ter cautela ao expor **debugging information** publicamente, pois isso pode levar a sensitive data leaks. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar logs da aplicação e identificar/proteger informações sensíveis. **Pidcat** é preferida por sua facilidade de uso e legibilidade.
> [!WARNING]
> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\
@ -297,90 +305,90 @@ Desenvolvedores devem ter cautela ao expor **informações de debugging** public
**Copy/Paste Buffer Caching**
O framework do Android baseado em **clipboard** habilita a funcionalidade de copiar/colar em apps, mas apresenta risco pois **outras aplicações** podem **acessar** a clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar** as funções de copy/paste para seções sensíveis de uma aplicação, como dados de cartão de crédito, para prevenir leaks de dados.
O framework **clipboard-based** do Android permite a funcionalidade de copiar/colar em apps, contudo apresenta risco já que **outras aplicações** podem **access** o clipboard, expondo potencialmente dados sensíveis. É crucial **desabilitar funções de copy/paste** para seções sensíveis da aplicação, como detalhes de cartão de crédito, para prevenir data leaks.
**Crash Logs**
Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, particularmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes, e se os logs precisarem ser transmitidos na rede, garanta que sejam enviados via um canal SSL para segurança.
Se uma aplicação **crasha** e **salva logs**, esses logs podem ajudar atacantes, particularmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes e, se logs precisarem ser transmitidos pela rede, garanta que sejam enviados via canal SSL para segurança.
Como pentester, **tente dar uma olhada nesses logs**.
**Analytics Data Sent To 3rd Parties**
Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente causar leak de dados sensíveis devido a implementação imprópria pelos desenvolvedores. Para identificar potenciais leaks de dados, é recomendável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada para serviços de terceiros.
Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **leak sensitive data** devido à implementação imprópria por desenvolvedores. Para identificar possíveis vazamentos, é aconselhável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada para serviços de terceiros.
### SQLite DBs
A maioria das aplicações usa **bancos SQLite internos** para salvar informações. Durante o pentest dê uma **olhada** nos **databases** criados, nos nomes das **tabelas** e **colunas** e em todos os **dados** salvos pois você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\
A maioria das aplicações irá usar **internal SQLite databases** para salvar informação. Durante o pentest dê uma **olhada** nos **databases** criados, nos nomes de **tables** e **columns** e em todos os **dados** salvos pois você pode encontrar **informação sensível** (o que seria uma vulnerability).\
Databases devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
Se o banco de dados está salvando informações confidenciais e está **criptografado**, mas você consegue encontrar a **senha** dentro da aplicação, isso ainda é uma **vulnerabilidade**.
Se o database está salvando informação confidencial e está **encrypted b**ut você pode **find** a **password** dentro da aplicação, isso ainda é uma **vulnerability**.
Enumere as tabelas usando `.tables` e enumere as colunas das tabelas com `.schema <table_name>`
Enumere as tabelas usando `.tables` e enumere as colunas das tabelas usando `.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** permite que você **assuma o papel de um app Android** e interaja com outros apps. Ele pode fazer **anything that an installed application can do**, como fazer uso do Android’s Inter-Process Communication (IPC) mechanism e interagir com o sistema operacional subjacente. .\
Drozer é uma ferramenta útil para **explorar exported activities, exported services and Content Providers** como você aprenderá nas seções seguintes.
### Exploiting exported Activities
[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
Also remember that the code of an activity starts in the **`onCreate`** method.
Lembre-se também que o código de uma activity começa no método **`onCreate`**.
**Authorisation bypass**
When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.**
Quando uma Activity é exportada você pode invocar sua tela a partir de um app externo. Portanto, se uma activity com **informação sensível** está **exported** você poderia **bypass** os mecanismos de **authentication** **to access it.**
[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
You can also start an exported activity from adb:
Você também pode iniciar uma activity exportada via adb:
- PackageName é com.example.demo
- Exported ActivityName é com.example.test.MainActivity
- PackageName is com.example.demo
- Exported ActivityName is com.example.test.MainActivity
```bash
adb shell am start -n com.example.demo/com.example.test.MainActivity
```
**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21).
**NOTA**: MobSF vai detectar como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma activity, mas devido a [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (API versions < 21).
> [!TIP]
> Note that an authorisation bypass is not always a vulnerability, it would depend on how the bypass works and which information is exposed.
> Note que um bypass de autorização nem sempre é uma vulnerabilidade; depende de como o bypass funciona e qual informação é exposta.
**Vazamento de informações sensíveis**
**Sensitive information leakage**
Activities can also return results. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, there is a sensitive information leakage.
**Activities também podem retornar resultados**. Se conseguir encontrar uma activity exportada e desprotegida que chama o método **`setResult`** e **retorna informações sensíveis**, há uma sensitive information leakage.
#### Tapjacking
If tapjacking isn't prevented, you could abuse the exported activity to make the **user perform unexpected actions**. For more info about [**what is Tapjacking follow the link**](#tapjacking).
Se o Tapjacking não for prevenido, você pode abusar da activity exportada para fazer o **usuário executar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking — siga o link**](#tapjacking).
### Exploiting Content Providers - Acessando e manipulando informações sensíveis
### Explorando Content Providers - Acessando e manipulando informações sensíveis
[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\
Content providers are basically used to **share data**. If an app has available content providers you may be able to **extract sensitive** data from them. It also interesting to test possible **SQL injections** and **Path Traversals** as they could be vulnerable.
[**Leia isto se quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\
Content providers são basicamente usados para **compartilhar dados**. Se um app possui content providers disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **SQL injections** e **Path Traversals**, pois podem ser vulneráveis.
[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers)
[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers)
### **Exploiting Services**
### **Explorando Services**
[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\
Remember that a the actions of a Service start in the method `onStartCommand`.
[**Leia isto se quiser relembrar o que é um Service.**](android-applications-basics.md#services)\
Lembre que as ações de um Service começam no método `onStartCommand`.
As service is basically something that **can receive data**, **process** it and **returns** (or not) a response. Then, if an application is exporting some services you should **check** the **code** to understand what is it doing and **test** it **dynamically** for extracting confidential info, bypassing authentication measures...\
[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services)
Um Service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Logo, se um aplicativo estiver exportando alguns services você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, burlar medidas de autenticação...\
[**Aprenda como explorar Services com Drozer.**](drozer-tutorial/index.html#services)
### **Exploiting Broadcast Receivers**
### **Explorando Broadcast Receivers**
[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
Remember that a the actions of a Broadcast Receiver start in the method `onReceive`.
[**Leia isto se quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
Lembre que as ações de um Broadcast Receiver começam no método `onReceive`.
A broadcast receiver will be waiting for a type of message. Depending on how the receiver handles the message it could be vulnerable.\
[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers)
Um broadcast receiver ficará esperando por um tipo de mensagem. Dependendo de como o receiver lida com a mensagem, ele pode ser vulnerável.\
[**Aprenda como explorar Broadcast Receivers com Drozer.**](#exploiting-broadcast-receivers)
### **Exploiting Schemes / Deep links**
### **Explorando Schemes / Deep links**
You can look for deep links manually, using tools like MobSF or scripts like [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
You can **open** a declared **scheme** using **adb** or a **browser**:
Você pode procurar por deep links manualmente, usando ferramentas como MobSF ou scripts como [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
Você pode **abrir** um **scheme** declarado usando **adb** ou um **browser**:
```bash
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
```
@ -393,56 +401,56 @@ _Observe que você pode **omitir o nome do pacote** e o dispositivo móvel chama
```
**Código executado**
Para encontrar o **código que will be executed in the App**, vá para a activity chamada pelo deeplink e procure a função **`onNewIntent`**.
Para encontrar o **código que será executado no App**, vá para a activity chamada pelo deeplink e procure a função **`onNewIntent`**.
![](<../../images/image (436) (1) (1) (1).png>)
**Informação sensível**
Cada vez que encontrar um deep link verifique que i**não está recebendo dados sensíveis (como senhas) via URL parameters**, porque qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!**
Sempre que encontrar um deeplink verifique que **ele não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, porque qualquer outra aplicação poderia **se passar pelo deeplink e roubar esses dados!**
**Parâmetros no path**
Você **deve também verificar se algum deep link está usando um parâmetro dentro do path** da URL como: `https://api.example.com/v1/users/{username}` , nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
Note que se você encontrar os endpoints corretos dentro da aplicação pode ser capaz de causar um **Open Redirect** (se parte do path for usada como domain name), **account takeover** (se você conseguir modificar users details sem CSRF token e o vuln endpoint usar o método correto) e qualquer outra vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
Você **deve também verificar se algum deeplink está usando um parâmetro dentro do path** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
Note que se você encontrar os endpoints corretos dentro da aplicação você pode ser capaz de causar um **Open Redirect** (se parte do path for usada como domain name), **account takeover** (se você conseguir modificar os detalhes dos usuários sem token CSRF e o vuln endpoint usar o método correto) e qualquer outra vuln. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/).
**More examples**
**Mais exemplos**
An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
Um [interesting bug bounty report](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_).
### Inspeção da Camada de Transporte e Falhas de Verificação
- **Certificates are not always inspected properly** por aplicações Android. É comum que essas aplicações ignorem avisos e aceitem self-signed certificates ou, em alguns casos, regressem para conexões HTTP.
- **Negotiations during the SSL/TLS handshake are sometimes weak**, empregando cipher suites inseguros. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decodifiquem os dados.
- **Leakage of private information** é um risco quando aplicações autenticam usando canais seguros, mas então comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como session cookies ou detalhes do usuário, contra interceptação por entidades maliciosas.
- **Certificates are not always inspected properly** by Android applications. It's common for these applications to overlook warnings and accept self-signed certificates or, in some instances, revert to using HTTP connections.
- **Negotiations during the SSL/TLS handshake are sometimes weak**, employing insecure cipher suites. This vulnerability makes the connection susceptible to man-in-the-middle (MITM) attacks, allowing attackers to decrypt the data.
- **Leakage of private information** is a risk when applications authenticate using secure channels but then communicate over non-secure channels for other transactions. This approach fails to protect sensitive data, such as session cookies or user details, from interception by malicious entities.
#### Verificação de Certificados
#### Verificação de Certificado
Vamos focar em **verificação de certificados**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não encriptados podem representar riscos significativos. Para passos detalhados sobre como verificar certificados de servidor e mitigar vulnerabilidades, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente.
Vamos focar na **verificação de certificados**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não criptografados podem representar riscos significativos. Para passos detalhados sobre verificar certificados de servidor e tratar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente.
#### SSL Pinning
SSL Pinning é uma medida de segurança onde a aplicação verifica o certificado do servidor contra uma cópia conhecida armazenada dentro da própria aplicação. Esse método é essencial para prevenir ataques MITM. Implementar SSL Pinning é fortemente recomendado para aplicações que lidam com informação sensível.
SSL Pinning é uma medida de segurança onde a aplicação verifica o certificado do servidor contra uma cópia conhecida armazenada dentro da própria aplicação. Esse método é essencial para prevenir ataques MITM. Recomenda-se fortemente implementar SSL Pinning em aplicações que lidam com informações sensíveis.
#### Inspeção de Tráfego
Para inspecionar tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (e.g., Burp). Sem instalar esse certificado, o tráfego encriptado pode não ser visível através do proxy. Para um guia sobre como instalar um certificado CA customizado, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Para inspecionar o tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar esse certificado, o tráfego criptografado pode não ser visível através do proxy. Para um guia sobre como instalar um certificado CA customizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Aplicações direcionadas para **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Esta etapa é crítica para inspecionar tráfego encriptado. Para instruções sobre modificar o Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
Aplicações targeting **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Este passo é crítico para inspecionar tráfego criptografado. Para instruções sobre modificar o Network Security Config, [**consulte este tutorial**](make-apk-accept-ca-certificate.md).
Se **Flutter** estiver sendo usado, você precisa seguir as instruções em [**this page**](flutter.md). Isso porque apenas adicionar o certificado ao store não funcionará, já que Flutter possui sua própria lista de CAs válidas.
Se **Flutter** estiver sendo usado você precisa seguir as instruções em [**esta página**](flutter.md). Isso porque apenas adicionar o certificado ao store não funcionará, já que o Flutter tem sua própria lista de CAs válidas.
#### Detecção estática de SSL/TLS pinning
Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e a focar nos code paths corretos.
Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e focar nos caminhos de código corretos.
Tool: SSLPinDetect
- Utilitário de análise estática open-source que decompila o APK para Smali (via apktool) e escaneia por padrões regex curados de implementações de SSL/TLS pinning.
- Reporta o caminho exato do arquivo, número da linha, e um snippet de código para cada correspondência.
- Cobre frameworks comuns e caminhos de código customizados: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
- Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations.
- Reports exact file path, line number, and a code snippet for each match.
- Covers common frameworks and custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
Instalar
- Pré-requisitos: Python >= 3.8, Java on PATH, apktool
Install
- Prereqs: Python >= 3.8, Java on PATH, apktool
```bash
git clone https://github.com/aancw/SSLPinDetect
cd SSLPinDetect
@ -457,7 +465,7 @@ python sslpindetect.py -f app.apk -a apktool.jar
python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
```
Exemplo de regras de padrão (JSON)
Use ou estenda signatures para detectar estilos de pinning proprietários/personalizados. Você pode carregar seu próprio JSON e escanear em larga escala.
Use ou estenda as signatures para detectar estilos proprietários/custom de pinning. Você pode carregar seu próprio JSON e realizar scan em larga escala.
```json
{
"OkHttp Certificate Pinning": [
@ -471,55 +479,55 @@ Use ou estenda signatures para detectar estilos de pinning proprietários/person
]
}
```
Notes and tips
- Fast scanning on large apps via multi-threading and memory-mapped I/O; pre-compiled regex reduces overhead/false positives.
- Pattern collection: https://github.com/aancw/smali-sslpin-patterns
- Typical detection targets to triage next:
Notas e dicas
- Escaneamento rápido em apps grandes via multi-threading e I/O mapeado em memória; regex pré-compilado reduz overhead/falsos positivos.
- Coleção de padrões: https://github.com/aancw/smali-sslpin-patterns
- Alvos típicos de detecção para triagem a seguir:
- 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.
- TrustManagers personalizados: javax.net.ssl.X509TrustManager, overrides de checkServerTrusted
- Custom SSL contexts: SSLContext.getInstance + SSLContext.init com managers personalizados
- Pins declarativos em res/xml network security config e referências no manifest
- Use as localizações correspondentes para planejar Frida hooks, patches estáticos ou revisões de configuração antes do teste dinâmico.
#### Contornando SSL Pinning
When SSL Pinning is implemented, bypassing it becomes necessary to inspect HTTPS traffic. Various methods are available for this purpose:
Quando SSL Pinning está implementado, contorná-lo torna-se necessário para inspecionar o tráfego HTTPS. Vários métodos estão disponíveis para esse fim:
- Automatically **modificar** o **apk** para **contornar** SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
- Modifique automaticamente o **apk** para **contornar** SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem desta opção é que você não precisará de root para contornar o SSL Pinning, mas será necessário apagar o aplicativo e reinstalar o novo, e isso nem sempre funciona.
- Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui está um guia para usar Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
- Você também pode tentar **contornar automaticamente o SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- Você também pode tentar **contornar automaticamente o SSL Pinning** usando **MobSF dynamic analysis** (explicado abaixo)
- Se você ainda achar que há tráfego que não está capturando, pode tentar **encaminhar o tráfego para o burp usando iptables**. Leia este blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
#### Looking for Common Web Vulnerabilities
#### Procurando por Vulnerabilidades Web Comuns
It's important to also search for common web vulnerabilities within the application. Detailed information on identifying and mitigating these vulnerabilities is beyond the scope of this summary but is extensively covered elsewhere.
Também é importante procurar por vulnerabilidades web comuns dentro do aplicativo. Informações detalhadas sobre identificação e mitigação dessas vulnerabilidades estão além do escopo deste resumo, mas são amplamente abordadas em outros recursos.
### Frida
[Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, reverse-engineers, e pesquisadores de segurança.\
**You can access running application and hook methods on run time to change the behaviour, change values, extract values, run different code...**\
If you want to pentest Android applications you need to know how to use Frida.
[Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, engenheiros de reverso e pesquisadores de segurança.\
**Você pode acessar a aplicação em execução e hookar métodos em tempo de execução para alterar o comportamento, mudar valores, extrair valores, executar código diferente...**\
Se você quer fazer pentest em aplicações Android, precisa saber usar o 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)
- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
- Aprenda a usar o Frida: [**Frida tutorial**](frida-tutorial/index.html)
- Algumas "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
- Ojection é ótimo para automatizar o uso do Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
- Você pode encontrar alguns scripts Awesome do Frida aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
- Tente contornar mecanismos anti-debugging / anti-frida carregando o Frida conforme indicado em [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (ferramenta [linjector](https://github.com/erfur/linjector-rs))
#### Anti-instrumentation & SSL pinning bypass workflow
#### Anti-instrumentation & fluxo de bypass de SSL pinning
{{#ref}}
android-anti-instrumentation-and-ssl-pinning-bypass.md
{{#endref}}
### **Dump Memory - Fridump**
### **Dump de memória - Fridump**
Check if the application is storing sensitive information inside the memory that it shouldn't be storing like passwords or mnemonics.
Verifique se o aplicativo está armazenando informações sensíveis na memória que não deveria, como senhas ou frases mnemônicas.
Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with:
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode fazer dump da memória do app com:
```bash
# With PID
python3 fridump3.py -u <PID>
@ -528,35 +536,35 @@ python3 fridump3.py -u <PID>
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
Isso irá fazer o dump da memória na pasta ./dump, e lá você pode usar grep com algo como:
Isso irá dump a memória na pasta ./dump, e aí você pode grep com 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]+$"
```
### **Dados sensíveis no Keystore**
No Android, o Keystore é o melhor lugar para armazenar dados sensíveis, porém, com privilégios suficientes ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso como usuário root ou alguém com acesso físico ao dispositivo poderia ser capaz de roubar esses dados.
No Android o Keystore é o melhor lugar para armazenar dados sensíveis; no entanto, com privilégios suficientes ainda é **possível acessá-lo**. Como aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso, pois um root user ou alguém com acesso físico ao dispositivo poderia roubar esses dados.
Mesmo que um app tenha armazenado dados no Keystore, os dados devem estar criptografados.
Mesmo que um app armazene dados no keystore, os dados devem estar criptografados.
Para acessar os dados dentro do Keystore você pode usar este script do Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
Para acessar os dados dentro do keystore você pode 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 o seguinte Frida script, pode ser possível **bypass fingerprint authentication** que aplicações Android realizem para **proteger certas áreas sensíveis:**
Usando o seguinte Frida script, pode ser possível **bypass fingerprint authentication** que aplicativos Android podem estar realizando para **proteger certas áreas sensíveis:**
```bash
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
```
### **Imagens de Fundo**
Quando você coloca um aplicativo em segundo plano, o Android armazena uma **captura (snapshot) da aplicação** para que, quando for trazido de volta ao primeiro plano, comece a carregar a imagem antes do app, dando a impressão de que o aplicativo carregou mais rápido.
Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo da aplicação** para que, quando ele for recuperado para o foreground, comece carregando a imagem antes do app, fazendo com que pareça que o aplicativo foi carregado mais rápido.
No entanto, se essa captura contiver **informação sensível**, alguém com acesso à captura pode **roubar essa informação** (observe que é preciso root para acessá-la).
No entanto, se esse instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essa informação** (observe que você precisa de root para acessá-lo).
As capturas geralmente são armazenadas em: **`/data/system_ce/0/snapshots`**
Os instantâneos geralmente são armazenados em: **`/data/system_ce/0/snapshots`**
O Android fornece uma forma de **impedir a captura de tela definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em capturas de tela ou que seja exibido em displays não seguros.
O Android fornece uma maneira de **impedir a captura de screenshot definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em screenshots ou que seja exibido em displays não seguros.
```bash
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
```
@ -566,30 +574,30 @@ Esta ferramenta pode ajudar a gerenciar diferentes ferramentas durante a anális
### Intent Injection
Developers often create proxy components like activities, services, and broadcast receivers that handle these Intents and pass them to methods such as `startActivity(...)` or `sendBroadcast(...)`, which can be risky.
Desenvolvedores frequentemente criam componentes proxy como activities, services e broadcast receivers que manipulam esses Intents e os passam para métodos como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado.
The danger lies in allowing attackers to trigger non-exported app components or access sensitive content providers by misdirecting these Intents. A notable example is the `WebView` component converting URLs to `Intent` objects via `Intent.parseUri(...)` and then executing them, potentially leading to malicious Intent injections.
O perigo está em permitir que atacantes acionem componentes da app não-exportados ou acessem content providers sensíveis ao desviar esses Intents. Um exemplo notável é o componente `WebView` converter URLs em objetos `Intent` via `Intent.parseUri(...)` e então executá-los, potencialmente levando a injeções maliciosas de Intent.
### Essential Takeaways
- **Intent Injection** é similar ao Open Redirect da web.
- Exploits involve passing `Intent` objects as extras, which can be redirected to execute unsafe operations.
- Pode expor componentes não-exportados e content providers a atacantes.
- `WebView`’s URL to `Intent` conversion pode facilitar ações não intencionais.
- **Intent Injection** é similar ao problema de Open Redirect na web.
- Exploits envolvem passar objetos `Intent` como extras, que podem ser redirecionados para executar operações inseguras.
- Pode expor componentes não-exportados e content providers aos atacantes.
- A conversão de URLs para `Intent` do `WebView` pode facilitar ações não intencionais.
### Android Client Side Injections and others
### Injeções do Lado do Cliente no Android e outros
Provavelmente você conhece este tipo de vulnerabilidade pela Web. Deve ter cuidado especial com estas vulnerabilidades em uma aplicação Android:
Provavelmente você conhece esse tipo de vulnerabilidade da Web. É preciso ter cuidado especial com essas vulnerabilidades em uma aplicação Android:
- **SQL Injection:** Ao lidar com queries dinâmicas ou Content-Providers, garanta que está usando queries parametrizadas.
- **JavaScript Injection (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para qualquer WebView (desativado por padrão). [More info here](webview-attacks.md#javascript-enabled).
- **Local File Inclusion:** Os WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
- **Eternal cookies**: Em vários casos, quando a aplicação android finaliza a sessão, o cookie não é revogado ou pode até ser salvo no disco
- **SQL Injection:** Ao lidar com queries dinâmicas ou Content-Providers, garanta o uso de queries parametrizadas.
- **JavaScript Injection (XSS):** Verifique se o suporte a JavaScript e Plugins está desabilitado para quaisquer WebViews (desabilitado por padrão). [More info here](webview-attacks.md#javascript-enabled).
- **Local File Inclusion:** Os WebViews devem ter o acesso ao sistema de arquivos desabilitado (habilitado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
- **Eternal cookies**: Em vários casos, quando a aplicação Android finaliza a sessão, o cookie não é revogado ou pode até ser salvo em disco
- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
---
## Automatic Analysis
## Análise Automática
### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
@ -624,7 +632,7 @@ By default, it will also use some Frida Scripts to **bypass SSL pinning**, **roo
MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report.
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**").
MobSF also allows you to load your own **Frida scripts** (to send the results of your Frida scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**").
![](<../../images/image (419).png>)
@ -652,13 +660,13 @@ receivers
```
**Ferramentas HTTP**
When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" botão or a nicer view in "**Start HTTPTools**" botão verde. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\
To do so, _power on Burp -->_ _turn off Intercept --> in MobSF HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
Quando o tráfego HTTP é capturado você pode ver uma visão feia do tráfego capturado no botão "**HTTP(S) Traffic**" ou uma visão mais agradável no botão verde "**Start HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
Para isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a request_ --> pressione "**Send to Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
Once you finish the análise dinâmica with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz** requisições HTTP e procurar vulnerabilidades.
Uma vez que você termine a análise dinâmica com MobSF você pode pressionar "**Start Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
> [!TIP]
> Após realizar uma análise dinâmica com MobSF as configurações de proxy podem ficar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações de proxy executando:
> Após realizar uma análise dinâmica com MobSF as configurações do proxy podem ficar mal configuradas e você não conseguirá corrigir isso pela GUI. Você pode corrigir as configurações do proxy fazendo:
>
> ```
> adb shell settings put global http_proxy :0
@ -666,8 +674,8 @@ Once you finish the análise dinâmica with MobSF you can press on "**Start Web
### Assisted Dynamic Analysis with Inspeckage
You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
Esta ferramenta vai usar alguns **Hooks** para informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**.
Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
Essa ferramenta usa alguns **Hooks** para informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**.
### [Yaazhini](https://www.vegabird.com/yaazhini/)
@ -677,7 +685,7 @@ Esta é uma **ótima ferramenta para realizar análise estática com uma GUI**
### [Qark](https://github.com/linkedin/qark)
Esta ferramenta foi projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **source code** ou em **packaged APKs**. A ferramenta também é **capaz de criar um "Proof-of-Concept" deployable APK** e **ADB commands**, para explorar algumas das vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como com Drozer, não é necessário root no dispositivo de teste.
Essa ferramenta foi projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja em **código-fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um APK "Proof-of-Concept" deployable** e **ADB commands**, para explorar algumas das vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Assim como com Drozer, não há necessidade de root no dispositivo de teste.
```bash
pip3 install --user qark # --user is only needed if not using a virtualenv
qark --apk path/to/my.apk
@ -688,8 +696,8 @@ qark --java path/to/specific/java/file.java
- Exibe todos os arquivos extraídos para referência rápida
- Descompila automaticamente arquivos APK para os formatos Java e Smali
- Analisa AndroidManifest.xml em busca de vulnerabilidades comuns e comportamento
- Análise estática do código-fonte para detectar vulnerabilidades e comportamento comuns
- Analisa AndroidManifest.xml em busca de vulnerabilidades e comportamentos comuns
- Análise estática de código-fonte para vulnerabilidades e comportamentos comuns
- Informações do dispositivo
- e mais
```bash
@ -697,11 +705,11 @@ reverse-apk relative/path/to/APP.apk
```
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
SUPER é um aplicativo de linha de comando que pode ser usado em Windows, MacOS X e Linux, que analisa arquivos _.apk_ em busca de vulnerabilidades. Faz isso descompactando APKs e aplicando uma série de regras para detectar essas vulnerabilidades.
SUPER é uma aplicação de linha de comando que pode ser usada em Windows, MacOS X e Linux, que analisa _.apk_ files em busca de vulnerabilidades. Faz isso descomprimindo APKs e aplicando uma série de regras para detectar essas vulnerabilidades.
Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisarem.
Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou tester pode criar suas próprias regras para analisar o que for necessário.
Baixe os binários mais recentes na [download page](https://superanalyzer.rocks/download.html)
Faça o download dos binários mais recentes na [download page](https://superanalyzer.rocks/download.html)
```
super-analyzer {apk_file}
```
@ -711,15 +719,15 @@ super-analyzer {apk_file}
StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, bugbounty hunters e ethical hackers na realização de [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicações móveis.
O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ele gerará um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada.
O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela irá gerar um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada.
Baixar[ latest release](https://github.com/vincentcox/StaCoAn/releases):
Download[ latest release](https://github.com/vincentcox/StaCoAn/releases):
```
./stacoan
```
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
AndroBugs Framework é um sistema de análise de vulnerabilidades do Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicativos Android.\
AndroBugs Framework é um sistema de análise de vulnerabilidades em Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
```
python androbugs.py -f [APK file]
@ -727,11 +735,11 @@ androbugs.exe -f [APK file]
```
### [Androwarn](https://github.com/maaaaz/androwarn)
**Androwarn** é uma ferramenta cujo principal objetivo é detectar e alertar o usuário sobre comportamentos potencialmente maliciosos desenvolvidos por uma aplicação Android.
**Androwarn** é uma ferramenta cujo principal objetivo é detectar e alertar o usuário sobre potenciais comportamentos maliciosos desenvolvidos por uma aplicação Android.
A detecção é realizada através da **static analysis** do bytecode Dalvik da aplicação, representado como **Smali**, usando a biblioteca [`androguard`](https://github.com/androguard/androguard).
A detecção é realizada com a **static analysis** do bytecode Dalvik da aplicação, representado como **Smali**, com a biblioteca [`androguard`](https://github.com/androguard/androguard).
Esta ferramenta procura por **common behavior of "bad" applications** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
Esta ferramenta procura por **comportamentos comuns de "bad" applications** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
```
python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
```
@ -739,36 +747,36 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
![](<../../images/image (595).png>)
**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que agrupa ferramentas comumente usadas para reverse engineering e analysis de aplicações móveis, para auxiliar nos testes de aplicações móveis contra as ameaças de segurança mobile do OWASP. Seu objetivo é tornar essa tarefa mais fácil e mais amigável para desenvolvedores de aplicações móveis e profissionais de segurança.
**MARA** é uma estrutura de **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para mobile application reverse engineering e análise, para auxiliar nos testes de aplicações móveis contra as ameaças de segurança mobile do OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicações móveis e profissionais de segurança.
It is able to:
Ela é capaz de:
- Extract Java and Smali code using different tools
- Analyze APKs using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
- Extract private information from the APK using regexps.
- Analyze the Manifest.
- Analyze found domains using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com)
- Extrair código Java e Smali usando diferentes ferramentas
- Analisar 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)
- Extrair informações privadas do APK usando regexps.
- Analisar o Manifest.
- Analisar domínios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
- Desofuscar APK via [apk-deguard.com](http://www.apk-deguard.com)
### Koodous
Útil para detectar malware: [https://koodous.com/](https://koodous.com/)
## Obfuscating/Deobfuscating code
## Ofuscação/Desofuscação de código
Note que, dependendo do serviço e da configuração que você usa para ofuscar o código, segredos podem ou não ficar ofuscados.
Note que, dependendo do serviço e da configuração usados para ofuscar o código, segredos podem ou não ficar ofuscados.
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. It is able to optimize bytecode as well as detect and remove unused instructions. ProGuard is free software and is distributed under the GNU General Public License, version 2.
ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação no modo release.
O ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação em modo release.
### [DexGuard](https://www.guardsquare.com/dexguard)
Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
(From that guide) Last time we checked, the Dexguard mode of operation was:
(From that guide) Da última vez que verificamos, o modo de operação do Dexguard era:
- load a resource as an InputStream;
- feed the result to a class inheriting from FilterInputStream to decrypt it;
@ -778,45 +786,46 @@ Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexgu
### [DeGuard](http://apk-deguard.com)
**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação Android. Isso permite diversas análises de segurança, incluindo inspeção de código e identificação de bibliotecas.**
Você pode enviar um APK ofuscado para a plataforma deles.
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API.
Esta é uma ferramenta LLM para encontrar potenciais vulnerabilidades de segurança em Android apps e desofuscar o código de apps Android. Usa a Google's Gemini public API.
### [Simplify](https://github.com/CalebFenton/simplify)
It is a **generic android deobfuscator.** Simplify **virtually executes an app** to understand its behavior and then **tries to optimize the code** so it behaves identically but is easier for a human to understand. Each optimization type is simple and generic, so it doesn't matter what the specific type of obfuscation is used.
É um **desofuscador android genérico.** Simplify **executa virtualmente um app** para entender seu comportamento e então **tenta otimizar o código** para que ele se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual tipo específico de ofuscação foi usado.
### [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 fornece informações sobre **how an APK was made**. Identifica muitos **compilers**, **packers**, **obfuscators**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
### Manual
[Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação customizada**](manual-deobfuscation.md)
Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação customizada** {#ref}manual-deobfuscation.md{#endref}
## Labs
## Laboratórios
### [Androl4b](https://github.com/sh4hin/Androl4b)
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui uma coleção dos frameworks, tutoriais e labs mais recentes de diferentes entusiastas e pesquisadores de segurança para reverse engineering e malware analysis.
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos frameworks mais recentes, tutoriais e labs de diferentes geeks e pesquisadores de segurança para reverse engineering e análise de malware.
## References
## Referências
- [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) É uma ótima lista de recursos
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Curso rápido de Android
- [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/)
- [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
- [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
- [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097)
- [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect)
- [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns)
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
## Yet to try
## Ainda por tentar
- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)

147
src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
View File

@ -2,60 +2,77 @@
{{#include ../../banners/hacktricks-training.md}}
Esta página fornece um fluxo de trabalho prático para recuperar a análise dinâmica contra apps Android que detectam ou bloqueiam instrumentation por root ou impõem TLS pinning. Concentra‑se em triagem rápida, detecções comuns e hooks/tactics copiáveis para contorná‑los sem repacking quando possível.
Esta página fornece um fluxo de trabalho prático para retomar análise dinâmica contra apps Android que detectam/blockam instrumentation ou impõem TLS pinning. Foca em triagem rápida, detecções comuns e hooks/táticas prontas para copiar/colar para contorná‑los sem repacking quando possível.
## Detection Surface (what apps check)
- Verificações de root: su binary, Magisk paths, getprop values, pacotes root comuns
- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs
- Anti‑debug nativo: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
- Verificações de inicialização precoce: Application.onCreate() ou process start hooks que causam crash se instrumentation estiver presente
- Root checks: su binary, Magisk paths, getprop values, common root packages
- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), varredura de /proc, classpath, loaded libs
- Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
- Early init checks: Application.onCreate() or process start hooks that crash if instrumentation is present
- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins
## Passo 1 — Quick win: hide root with Magisk DenyList
## Step 1 — Quick win: hide root with Magisk DenyList
- Habilite Zygisk in Magisk
- Habilite DenyList, adicione o pacote alvo
- Reinicie e reteste
- Enable Zygisk in Magisk
- Enable DenyList, add the target package
- Reboot and retest
Muitos apps só procuram indicadores óbvios (su/Magisk paths/getprop). DenyList frequentemente neutraliza checagens ingênuas.
Many apps only look for obvious indicators (su/Magisk paths/getprop). DenyList often neutralizes naive checks.
References:
- Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk
## Passo 2 — 30‑second Frida Codeshare tests
## Step 2 — 30‑second Frida Codeshare tests
Tente scripts drop‑in comuns antes de aprofundar:
Try common drop‑in scripts before deep diving:
- anti-root-bypass.js
- anti-frida-detection.js
- hide_frida_gum.js
Exemplo:
Example:
```bash
frida -U -f com.example.app -l anti-frida-detection.js
```
Estes tipicamente stub Java root/debug checks, process/service scans, e ptrace() nativo. Úteis em apps pouco protegidos; hardened targets podem precisar de hooks personalizados.
Normalmente anulam verificações Java de root/debug, process/service scans e ptrace() nativo. Úteis em apps pouco protegidos; alvos mais hardenizados podem precisar de hooks sob medida.
- Codeshare: https://codeshare.frida.re/
## Automatize com Medusa (Frida framework)
Medusa fornece mais de 90 módulos prontos para SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception, e mais.
```bash
git clone https://github.com/Ch0pin/medusa
cd medusa
pip install -r requirements.txt
python medusa.py
# Example interactive workflow
show categories
use http_communications/multiple_unpinner
use root_detection/universal_root_detection_bypass
run com.target.app
```
Dica: Medusa é ótimo para ganhos rápidos antes de escrever custom hooks. Você também pode selecionar módulos e combiná-los com seus próprios scripts.
## Passo 3 — Contornar detectores em tempo de inicialização anexando-se mais tarde
Muitas detecções só são executadas durante process spawn/onCreate(). Spawn‑time injection (-f) ou gadgets são detectados; anexar-se depois que a UI carrega pode passar despercebido.
Muitas detecções só rodam durante process spawn/onCreate(). Spawn‑time injection (-f) ou gadgets são detectados; anexar-se depois que a UI carrega pode passar despercebido.
```bash
# Launch the app normally (launcher/adb), wait for UI, then attach
frida -U -n com.example.app
# Or with Objection to attach to running process
aobjection --gadget com.example.app explore # if using gadget
```
Se isso funcionar, mantenha a sessão estável e prossiga para mapear e verificar stubs.
Se isso funcionar, mantenha a sessão estável e prossiga para mapear e realizar verificações de stub.
## Etapa 4 — Mapear lógica de detecção via Jadx e busca por strings
## Step 4 — Map detection logic via Jadx and busca por strings
Palavras-chave de triagem estática no Jadx:
Static triage keywords in Jadx:
- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger"
Padrões típicos em Java:
Padrões Java típicos:
```java
public boolean isFridaDetected() {
return getRunningServices().contains("frida");
@ -68,9 +85,9 @@ APIs comuns para revisar/hook:
- java.lang.Runtime.exec / ProcessBuilder (probing commands)
- android.os.SystemProperties.get (root/emulator heuristics)
## Passo 5 — Runtime stubbing com Frida (Java)
## Passo 5 — Substituição em tempo de execução com Frida (Java)
Override custom guards para retornar valores seguros sem repacking:
Substitua verificações personalizadas para retornar valores seguros sem repacking:
```js
Java.perform(() => {
const Checks = Java.use('com.example.security.Checks');
@ -85,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager');
AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); };
});
```
Triagem de early crashes? Dump classes pouco antes de morrer para identificar possíveis detection namespaces:
Triando crashes iniciais? Dump classes pouco antes de morrer para identificar namespaces prováveis de detecção:
```js
Java.perform(() => {
Java.enumerateLoadedClasses({
@ -94,7 +111,15 @@ onComplete: () => console.log('Done')
});
});
```
Log e neutralize métodos suspeitos para confirmar o fluxo de execução:
// Quick root detection stub example (adapt to target package/class names)
Java.perform(() => {
try {
const RootChecker = Java.use('com.target.security.RootCheck');
RootChecker.isDeviceRooted.implementation = function () { return false; };
} catch (e) {}
});
Registre e neutralize métodos suspeitos para confirmar o fluxo de execução:
```js
Java.perform(() => {
const Det = Java.use('com.example.security.DetectionManager');
@ -104,9 +129,49 @@ return false;
};
});
```
## Step 6 — Siga a trilha JNI/native quando Java hooks falharem
## Bypass emulator/VM detection (Java stubs)
Rastreie os JNI entry points para localizar native loaders e detection init:
Heurísticas comuns: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE contendo generic/goldfish/ranchu/sdk; artefatos QEMU como /dev/qemu_pipe, /dev/socket/qemud; MAC padrão 02:00:00:00:00:00; NAT 10.0.2.x; ausência de telephony/sensors.
Spoof rápido dos campos Build:
```js
Java.perform(function(){
var Build = Java.use('android.os.Build');
Build.MODEL.value = 'Pixel 7 Pro';
Build.MANUFACTURER.value = 'Google';
Build.BRAND.value = 'google';
Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys';
});
```
Complete com stubs para verificações de existência de arquivos e identificadores (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) para retornar valores realistas.
## SSL pinning bypass quick hook (Java)
Neutralizar TrustManagers personalizados e forçar contextos SSL permissivos:
```js
Java.perform(function(){
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
var SSLContext = Java.use('javax.net.ssl.SSLContext');
// No-op validations
X509TrustManager.checkClientTrusted.implementation = function(){ };
X509TrustManager.checkServerTrusted.implementation = function(){ };
// Force permissive TrustManagers
var TrustManagers = [ X509TrustManager.$new() ];
var SSLContextInit = SSLContext.init.overload('[Ljavax.net.ssl.KeyManager;','[Ljavax.net.ssl.TrustManager;','java.security.SecureRandom');
SSLContextInit.implementation = function(km, tm, sr){
return SSLContextInit.call(this, km, TrustManagers, sr);
};
});
```
Notas
- Estenda para OkHttp: hook okhttp3.CertificatePinner e HostnameVerifier conforme necessário, ou use um script universal de unpinning do CodeShare.
- Exemplo de execução: `frida -U -f com.target.app -l ssl-bypass.js --no-pause`
## Passo 6 — Siga a trilha JNI/native quando hooks Java falharem
Rastreie pontos de entrada JNI para localizar carregadores nativos e inicialização de detecção:
```bash
frida-trace -n com.example.app -i "JNI_OnLoad"
```
@ -121,7 +186,7 @@ Interativo/nativo reversing:
- Ghidra: https://ghidra-sre.org/
- r2frida: https://github.com/nowsecure/r2frida
Exemplo: neuter ptrace to defeat simple anti‑debug in libc:
Exemplo: neutralizar ptrace para derrotar anti‑debug simples em libc:
```js
const ptrace = Module.findExportByName(null, 'ptrace');
if (ptrace) {
@ -135,28 +200,30 @@ Veja também:
reversing-native-libraries.md
{{#endref}}
## Passo 7 — Objection patching (embed gadget / strip basics)
## Etapa 7 — Objection patching (embed gadget / strip basics)
Quando você prefere repacking em vez de runtime hooks, tente:
Quando você prefere repacking em vez de runtime hooks, experimente:
```bash
objection patchapk --source app.apk
```
Notas:
- Requer apktool; garanta uma versão atual seguindo o guia oficial para evitar problemas de build: https://apktool.org/docs/install
- Gadget injection permite instrumentation sem root, mas ainda pode ser detectado por verificações init‑time mais rigorosas.
- Requer apktool; certifique-se de usar uma versão atual a partir do guia oficial para evitar problemas de build: https://apktool.org/docs/install
- Gadget injection permite instrumentation sem root, mas ainda pode ser detectado por verificações mais rígidas em tempo de inicialização.
Opcionalmente, adicione módulos LSPosed e Shamiko para ocultação de root mais eficaz em ambientes Zygisk, e ajuste DenyList para cobrir processos filhos.
Referências:
- Objection: https://github.com/sensepost/objection
## Passo 8 — Plano B: Corrigir TLS pinning para visibilidade de rede
## Passo 8 — Contingência: Corrigir TLS pinning para visibilidade de rede
Se instrumentation estiver bloqueado, você ainda pode inspecionar o tráfego removendo o pinning estaticamente:
Se a instrumentation estiver bloqueada, você ainda pode inspecionar o tráfego removendo o pinning estaticamente:
```bash
apk-mitm app.apk
# Then install the patched APK and proxy via Burp/mitmproxy
```
- Ferramenta: https://github.com/shroudedcode/apk-mitm
- Para truques de configuração de rede relacionados à confiança de CA (e à confiança de CA de usuário no Android 7+), veja:
- Para truques de CA‑trust na configuração de rede (e user CA trust no Android 7+), veja:
{{#ref}}
make-apk-accept-ca-certificate.md
@ -166,7 +233,7 @@ make-apk-accept-ca-certificate.md
install-burp-certificate.md
{{#endref}}
## Resumo prático de comandos
## Guia rápido de comandos
```bash
# List processes and attach
frida-ps -Uai
@ -184,12 +251,12 @@ objection --gadget com.example.app explore
# Static TLS pinning removal
apk-mitm app.apk
```
## Dicas & caveats
## Dicas e advertências
- Prefira attaching late em vez de spawning quando apps travam na inicialização
- Algumas detecções re-executam em fluxos críticos (e.g., payment, auth) — mantenha hooks ativos durante a navegação
- Misture análise estática e dinâmica: string hunt em Jadx para reduzir as classes; depois hook métodos para verificar em runtime
- Aplicativos hardened podem usar packers e native TLS pinning — espere reverter código nativo
- Prefira attaching mais tarde em vez de spawning quando apps travam na inicialização
- Algumas detecções re‑executam em fluxos críticos (e.g., payment, auth) — mantenha hooks ativos durante a navegação
- Combine estático e dinâmico: busca de strings no Jadx para pré-selecionar classes; depois hook methods para verificar em runtime
- Apps hardened podem usar packers e native TLS pinning — espere ter que reverter código nativo
## Referências
@ -202,5 +269,7 @@ apk-mitm app.apk
- [r2frida](https://github.com/nowsecure/r2frida)
- [Apktool install guide](https://apktool.org/docs/install)
- [Magisk](https://github.com/topjohnwu/Magisk)
- [Medusa (Android Frida framework)](https://github.com/Ch0pin/medusa)
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
{{#include ../../banners/hacktricks-training.md}}

154
src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md
View File

@ -6,21 +6,21 @@ Muito obrigado a [**@offsecjay**](https://twitter.com/offsecjay) pela ajuda na c
## O que é
O Android Studio permite **executar máquinas virtuais do Android que você pode usar para testar APKs**. Para usá-las, você precisará:
Android Studio permite **executar máquinas virtuais do Android que você pode usar para testar APKs**. Para usá-las você vai precisar:
- As **ferramentas do Android SDK** - [Baixe aqui](https://developer.android.com/studio/releases/sdk-tools).
- Ou **Android Studio** (com ferramentas do Android SDK) - [Baixe aqui](https://developer.android.com/studio).
- Os **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools).
- Ou **Android Studio** (com Android SDK tools) - [Download here](https://developer.android.com/studio).
No Windows (no meu caso) **após instalar o Android Studio** eu tinha as **ferramentas do SDK instaladas em**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
No Windows (no meu caso) **após instalar o Android Studio** eu tinha as **SDK Tools instaladas em**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
No mac você pode **baixar as ferramentas do SDK** e tê-las no PATH executando:
No mac você pode **baixar os SDK tools** e colocá-los no PATH executando:
```bash
brew tap homebrew/cask
brew install --cask android-sdk
```
Ou a partir do **Android Studio GUI** conforme indicado em [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) que irá instalá-los em `~/Library/Android/sdk/cmdline-tools/latest/bin/` e `~/Library/Android/sdk/platform-tools/` e `~/Library/Android/sdk/emulator/`
Ou a partir da **GUI do Android Studio** como indicado em [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) que irá instalá-los em `~/Library/Android/sdk/cmdline-tools/latest/bin/` and `~/Library/Android/sdk/platform-tools/` and `~/Library/Android/sdk/emulator/`
Para os problemas de Java:
Para os problemas com Java:
```java
export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home
```
@ -28,7 +28,7 @@ export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home
### Preparar Máquina Virtual
Se você instalou o Android Studio, pode apenas abrir a visualização principal do projeto e acessar: _**Tools**_ --> _**AVD Manager.**_
Se você instalou o Android Studio, pode simplesmente abrir a vista principal do projeto e acessar: _**Tools**_ --> _**AVD Manager.**_
<div align="center" data-full-width="false">
@ -36,38 +36,38 @@ Se você instalou o Android Studio, pode apenas abrir a visualização principal
</div>
Em seguida, clique em _**Create Virtual Device**_
Então, clique em _**Create Virtual Device**_
<figure><img src="../../images/image (1143).png" alt="" width="188"><figcaption></figcaption></figure>
_**selecione** o telefone que você deseja usar_ e clique em _**Next.**_
_**selecione** o telefone que deseja usar_ e clique em _**Next.**_
> [!WARNING]
> Se você precisar de um telefone com o Play Store instalado, selecione um com o ícone do Play Store nele!
> Se você precisa de um telefone com Play Store instalado, selecione um que tenha o ícone do Play Store!
>
> <img src="../../images/image (1144).png" alt="" data-size="original">
Na visualização atual, você poderá **selecionar e baixar a imagem do Android** que o telefone irá executar:
Na vista atual você poderá **selecionar e baixar a imagem Android** que o telefone irá executar:
<figure><img src="../../images/image (1145).png" alt="" width="375"><figcaption></figcaption></figure>
Então, selecione-a e se não estiver baixada, clique no símbolo de _**Download**_ ao lado do nome (**agora aguarde até que a imagem seja baixada).**\
Uma vez que a imagem esteja baixada, basta selecionar **`Next`** e **`Finish`**.
Então, selecione-a e, se não estiver baixada, clique no símbolo _**Download**_ ao lado do nome (**agora espere até que a imagem seja baixada).**\
Uma vez que a imagem esteja baixada, apenas selecione **`Next`** e **`Finish`**.
A máquina virtual será criada. Agora **toda vez que você acessar o AVD manager, ela estará presente**.
A máquina virtual será criada. Agora **toda vez que você acessar o AVD manager ela estará presente**.
### Executar Máquina Virtual
Para **executá-la**, basta pressionar o _**Start button**_.
Para **executá-la** basta pressionar o _**Start button**_.
![](<../../images/image (518).png>)
## Ferramenta de Linha de Comando
## Ferramenta de linha de comando
> [!WARNING]
> Para macOS, você pode encontrar a ferramenta `avdmanager` em `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` e o `emulator` em `/Users/<username>/Library/Android/sdk/emulator/emulator` se você os tiver instalados.
> Para macOS você pode encontrar a ferramenta `avdmanager` em `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` e o `emulator` em `/Users/<username>/Library/Android/sdk/emulator/emulator` se você os tiver instalados.
Primeiramente, você precisa **decidir qual telefone deseja usar**, para ver a lista de telefones possíveis, execute:
Antes de tudo você precisa **decidir qual telefone deseja usar**, para ver a lista de telefones possíveis execute:
```
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device
@ -95,16 +95,16 @@ Name: Nexus 10
OEM : Google
[...]
```
Uma vez que você tenha decidido o nome do dispositivo que deseja usar, você precisa **decidir qual imagem do Android deseja executar neste dispositivo.**\
Depois de decidir o nome do dispositivo que você quer usar, você precisa **decidir qual imagem Android você quer executar neste dispositivo.**\
Você pode listar todas as opções usando `sdkmanager`:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list
```
E **baixe** o que você deseja usar com:
E faça o **download** do(s) que você quer usar com:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"
```
Uma vez que você tenha baixado a imagem do Android que deseja usar, você pode **listar todas as imagens do Android baixadas** com:
Depois de ter baixado a imagem Android que deseja usar, você pode **listar todas as imagens Android baixadas** com:
```
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target
----------
@ -120,12 +120,12 @@ Type: Platform
API level: 29
Revision: 4
```
Neste momento, você decidiu qual dispositivo deseja usar e baixou a imagem do Android, então **você pode criar a máquina virtual usando**:
Neste momento você decidiu o dispositivo que quer usar e baixou a imagem do Android, então **você pode criar a máquina virtual usando**:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X"
```
No último comando **criei uma VM chamada** "_AVD9_" usando o **dispositivo** "_Nexus 5X_" e a **imagem do Android** "_system-images;android-28;google_apis;x86_64_".\
Agora você pode **listar as máquinas virtuais** que você criou com:
No último comando **criei uma VM chamada** "_AVD9_" usando o **dispositivo** "_Nexus 5X_" e a **imagem Android** "_system-images;android-28;google_apis;x86_64_".\
Agora você pode **listar as máquinas virtuais** que criou com:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd
@ -140,10 +140,10 @@ Name: Pixel_2_API_27
Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd
Error: Google pixel_2 no longer exists as a device
```
### Executar Máquina Virtual
### Run Virtual Machine
> [!WARNING]
> Para macOS, você pode encontrar a ferramenta `avdmanager` em `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` e o `emulator` em `/Users/<username>/Library/Android/sdk/emulator/emulator` se você os tiver instalados.
> For macOS you can find the `avdmanager` tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` and the `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` if you have them installed.
Já vimos como você pode listar as máquinas virtuais criadas, mas **você também pode listá-las usando**:
```bash
@ -156,59 +156,115 @@ Você pode simplesmente **executar qualquer máquina virtual criada** usando:
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9"
```
Ou usando opções mais avançadas, você pode executar uma máquina virtual como:
Ou, usando opções mais avançadas, você pode executar uma máquina virtual como:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
```
### Opções de linha de comando
No entanto, existem **muitas opções úteis de linha de comando** que você pode usar para iniciar uma máquina virtual. Abaixo, você pode encontrar algumas opções interessantes, mas pode [**encontrar uma lista completa aqui**](https://developer.android.com/studio/run/emulator-commandline)
No entanto, existem **muitas opções úteis de linha de comando diferentes** que você pode usar para iniciar uma máquina virtual. Abaixo você pode encontrar algumas opções interessantes mas pode [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline)
**Inicialização**
- `-snapshot name` : Iniciar snapshot da VM
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Listar todos os snapshots gravados
- `-snapshot name` : Iniciar um snapshot da VM
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Listar todos os snapshots registrados
**Rede**
- `-dns-server 192.0.2.0, 192.0.2.255` : Permitir indicar, separando por vírgula, os servidores DNS para a VM.
- **`-http-proxy 192.168.1.12:8080`** : Permitir indicar um proxy HTTP a ser usado (muito útil para capturar o tráfego usando Burp)
- Se as configurações do proxy não estiverem funcionando por algum motivo, tente configurá-las internamente ou usando um aplicativo como "Super Proxy" ou "ProxyDroid".
- `-netdelay 200` : Definir a emulação de latência de rede em milissegundos.
- `-port 5556` : Definir o número da porta TCP que é usado para o console e adb.
- `-ports 5556,5559` : Definir as portas TCP usadas para o console e adb.
- **`-tcpdump /path/dumpfile.cap`** : Capturar todo o tráfego em um arquivo
- `-dns-server 192.0.2.0, 192.0.2.255` : Permite indicar, separados por vírgula, os servidores DNS para a VM.
- **`-http-proxy 192.168.1.12:8080`** : Permite indicar um proxy HTTP a ser usado (muito útil para capturar o tráfego usando Burp)
- If the proxy settings aren't working for some reason, try to configure them internally or using an pplication like "Super Proxy" or "ProxyDroid".
- `-netdelay 200` : Define a emulação de latência de rede em milissegundos.
- `-port 5556` : Define o número da porta TCP usada para o console e o adb.
- `-ports 5556,5559` : Define as portas TCP usadas para o console e o adb.
- **`-tcpdump /path/dumpfile.cap`** : Captura todo o tráfego em um arquivo
**Sistema**
- `-selinux {disabled|permissive}` : Definir o módulo de segurança Security-Enhanced Linux para modo desativado ou permissivo em um sistema operacional Linux.
- `-timezone Europe/Paris` : Definir o fuso horário para o dispositivo virtual
- `-screen {touch(default)|multi-touch|o-touch}` : Definir o modo de tela sensível ao toque emulado.
- **`-writable-system`** : Use esta opção para ter uma imagem de sistema gravável durante sua sessão de emulação. Você também precisará executar `adb root; adb remount`. Isso é muito útil para instalar um novo certificado no sistema.
- `-selinux {disabled|permissive}` : Define o módulo de segurança Security-Enhanced Linux para o modo 'disabled' ou 'permissive' em um sistema operacional Linux.
- `-timezone Europe/Paris` : Define o fuso horário para o dispositivo virtual
- `-screen {touch(default)|multi-touch|o-touch}` : Define o modo de tela sensível ao toque emulado.
- **`-writable-system`** : Use esta opção para ter uma imagem do sistema gravável durante sua sessão de emulação. Você também precisará executar `adb root; adb remount`. Isso é muito útil para instalar um novo certificado no sistema.
## Rooting de um dispositivo da Play Store
## Configuração da CLI no Linux (SDK/AVD quickstart)
Se você baixou um dispositivo com a Play Store, não conseguirá obter root diretamente, e receberá esta mensagem de erro
As ferramentas oficiais de CLI facilitam a criação de emuladores rápidos e depuráveis sem o Android Studio.
```bash
# Directory layout
mkdir -p ~/Android/cmdline-tools/latest
# Download commandline tools (Linux)
wget https://dl.google.com/android/repository/commandlinetools-linux-13114758_latest.zip -O /tmp/cmdline-tools.zip
unzip /tmp/cmdline-tools.zip -d ~/Android/cmdline-tools/latest
rm /tmp/cmdline-tools.zip
# Env vars (add to ~/.bashrc or ~/.zshrc)
export ANDROID_HOME=$HOME/Android
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH
# Install core SDK components
sdkmanager --install "platform-tools" "emulator"
# Install a debuggable x86_64 system image (Android 11 / API 30)
sdkmanager --install "system-images;android-30;google_apis;x86_64"
# Create an AVD and run it with a writable /system & snapshot name
avdmanager create avd -n PixelRootX86 -k "system-images;android-30;google_apis;x86_64" -d "pixel"
emulator -avd PixelRootX86 -writable-system -snapshot PixelRootX86_snap
# Verify root (debuggable images allow `adb root`)
adb root
adb shell whoami # expect: root
```
Notas
- Variedades de imagem do sistema: google_apis (depurável, permite adb root), google_apis_playstore (não permite root), aosp/default (leve).
- Tipos de build: userdebug frequentemente permite `adb root` em imagens com suporte a depuração. As imagens Play Store são builds de produção e bloqueiam o root.
- Em hosts x86_64, a emulação de sistema completo ARM64 não é suportada a partir da API 28+. Para Android 11+ use imagens Google APIs/Play que incluem tradução por aplicativo de ARM para x86 para executar muitos apps apenas ARM rapidamente.
### Snapshots pelo CLI
```bash
# Save a clean snapshot from the running emulator
adb -s emulator-5554 emu avd snapshot save my_clean_setup
# Boot from a named snapshot (if it exists)
emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup
```
## ARM→x86 binary translation (Android 11+)
Google APIs e Play Store images no Android 11+ podem traduzir binários de apps ARM por processo enquanto mantêm o resto do sistema nativo x86/x86_64. Isso costuma ser rápido o suficiente para testar muitos apps ARM-only no desktop.
> Dica: Prefira imagens Google APIs x86/x86_64 durante pentests. Imagens Play são convenientes, mas bloqueiam `adb root`; use-as apenas quando você realmente precisar de Play services e aceitar a falta de root.
## Rooting a Play Store device
Se você baixou um dispositivo com Play Store, você não vai conseguir obter root diretamente, e você receberá esta mensagem de erro
```
$ adb root
adbd cannot run as root in production builds
```
Usando [rootAVD](https://github.com/newbit1/rootAVD) com [Magisk](https://github.com/topjohnwu/Magisk), consegui fazer root (siga por exemplo [**este vídeo**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **ou** [**este aqui**](https://www.youtube.com/watch?v=qQicUW0svB8)).
Using [rootAVD](https://github.com/newbit1/rootAVD) with [Magisk](https://github.com/topjohnwu/Magisk) consegui fazer root no dispositivo (siga por exemplo [**este vídeo**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **ou** [**este**](https://www.youtube.com/watch?v=qQicUW0svB8)).
## Instalar Certificado Burp
## Install Burp Certificate
Confira a página a seguir para aprender como instalar um certificado CA personalizado:
Verifique a página a seguir para aprender como instalar um certificado CA personalizado:
{{#ref}}
install-burp-certificate.md
{{#endref}}
## Opções AVD Interessantes
## Nice AVD Options
### Tirar um Snapshot
### Take a Snapshot
Você pode **usar a GUI** para tirar um snapshot da VM a qualquer momento:
![](<../../images/image (234).png>)
## Referências
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
- [Android Emulator command line](https://developer.android.com/studio/run/emulator-commandline)
- [Run ARM apps on the Android Emulator (x86 translation)](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)
{{#include ../../banners/hacktricks-training.md}}

106
src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md
View File

@ -1,7 +1,8 @@
# Frida Tutorial
# Tutorial de Frida
{{#include ../../../banners/hacktricks-training.md}}
## Instalação
Instale **frida tools**:
@ -9,8 +10,8 @@ Instale **frida tools**:
pip install frida-tools
pip install frida
```
**Baixe e instale** no Android o **frida server** ([Baixe a versão mais recente](https://github.com/frida/frida/releases)).\
Um comando para reiniciar o adb em modo root, conectar-se a ele, fazer upload do frida-server, conceder permissões de execução e executá-lo em segundo plano:
**Faça o download e instale** no Android o **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
Comando de uma linha para reiniciar o adb em modo root, conectar-se a ele, enviar o frida-server, dar permissões de execução e executá-lo em segundo plano:
```bash
adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &"
```
@ -19,35 +20,88 @@ adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local
frida-ps -U #List packages and processes
frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
```
## Tutoriais
## Frida server vs. Gadget (root vs. no-root)
Duas maneiras comuns de instrumentar aplicativos Android com Frida:
- Frida server (rooted devices): Envie e execute um daemon nativo que permite anexar-se a qualquer processo.
- Frida Gadget (no root): Empacote Frida como uma biblioteca compartilhada dentro do APK e carregue-a automaticamente no processo alvo.
Frida server (rooted)
```bash
# Download the matching frida-server binary for your device's arch
# https://github.com/frida/frida/releases
adb root
adb push frida-server-<ver>-android-<arch> /data/local/tmp/frida-server
adb shell chmod 755 /data/local/tmp/frida-server
adb shell /data/local/tmp/frida-server & # run at boot via init/magisk if desired
# From host, list processes and attach
frida-ps -Uai
frida -U -n com.example.app
```
Frida Gadget (no-root)
1) Descompacte o APK, adicione o .so do gadget e a configuração:
- Coloque libfrida-gadget.so em lib/<abi>/ (por exemplo: lib/arm64-v8a/)
- Crie assets/frida-gadget.config com as configurações de carregamento dos seus scripts
Exemplo frida-gadget.config
```json
{
"interaction": { "type": "script", "path": "/sdcard/ssl-bypass.js" },
"runtime": { "logFile": "/sdcard/frida-gadget.log" }
}
```
2) Referencie/carregue o gadget para que ele seja inicializado cedo:
- Mais fácil: Adicione um pequeno Java stub que chame System.loadLibrary("frida-gadget") em Application.onCreate(), ou use o carregamento de lib nativa já presente.
3) Reempacote e assine o APK, então instale:
```bash
apktool d app.apk -o app_m
# ... add gadget .so and config ...
apktool b app_m -o app_gadget.apk
uber-apk-signer -a app_gadget.apk -o out_signed
adb install -r out_signed/app_gadget-aligned-debugSigned.apk
```
4) Anexar do host ao processo do gadget:
```bash
frida-ps -Uai
frida -U -n com.example.app
```
Notas
- Gadget é detectado por algumas proteções; mantenha nomes/caminhos discretos e carregue tardiamente/condicionalmente se necessário.
- Em aplicativos reforçados, prefira testes em dispositivos com root com server + late attach, ou combine com ocultação Magisk/Zygisk.
## Tutorials
### [Tutorial 1](frida-tutorial-1.md)
**De**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
**Fonte**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
**APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\
**Código Fonte**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
**Código-fonte**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
**Siga o [link para ler](frida-tutorial-1.md).**
### [Tutorial 2](frida-tutorial-2.md)
**De**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Partes 2, 3 & 4)\
**APKs e Código fonte**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
**Fonte**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parts 2, 3 & 4)\
**APKs e código-fonte**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
**Siga o [link para ler.](frida-tutorial-2.md)**
**Siga o[ link para ler.](frida-tutorial-2.md)**
### [Tutorial 3](owaspuncrackable-1.md)
**De**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
**Fonte**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
**APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk)
**Siga o [link para ler](owaspuncrackable-1.md).**
**Você pode encontrar mais scripts incríveis do Frida aqui:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
**Você pode encontrar mais scripts Awesome Frida aqui:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
## Exemplos Rápidos
### Chamando o Frida a partir da linha de comando
### Chamando o Frida pela linha de comando
```bash
frida-ps -U
@ -60,7 +114,7 @@ frida -U --no-pause -l disableRoot.js -f owasp.mstg.uncrackable1
#frozen so that the instrumentation can occur, and the automatically
#continue execution with our modified code.
```
### Script Básico em Python
### Script Python Básico
```python
import frida, sys
@ -71,7 +125,7 @@ print('[ * ] Running Frida Demo application')
script.load()
sys.stdin.read()
```
### Hooking functions without parameters
### Hooking de funções sem parâmetros
Hook a função `a()` da classe `sg.vantagepoint.a.c`
```javascript
@ -90,7 +144,7 @@ sysexit.exit.overload("int").implementation = function (var_0) {
send("java.lang.System.exit(I)V // We avoid exiting the application :)")
}
```
Hook MainActivity `.onStart()` e `.onCreate()`
Hook MainActivity `.onStart()` & `.onCreate()`
```javascript
var mainactivity = Java.use("sg.vantagepoint.uncrackable1.MainActivity")
mainactivity.onStart.overload().implementation = function () {
@ -114,9 +168,9 @@ send("Activity HIT!!!")
var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0)
}
```
### Hooking functions with parameters and retrieving the value
### Hooking de funções com parâmetros e recuperando o valor
Hooking uma função de descriptografia. Imprima a entrada, chame a função original para descriptografar a entrada e, finalmente, imprima os dados em texto claro:
Hooking de uma função de descriptografia. Imprima a entrada, chame a função original para descriptografar a entrada e, finalmente, imprima os dados em claro:
```javascript
function getString(data) {
var ret = ""
@ -141,9 +195,9 @@ send("Decrypted flag: " + flag)
return ret //[B
}
```
### Hooking functions and calling them with our input
### Hooking de funções e chamando-as com nosso input
Hook uma função que recebe uma string e chame-a com outra string (de [aqui](https://11x256.github.io/Frida-hooking-android-part-2/))
Faça hook em uma função que recebe uma string e chame-a com outra string (a partir de [here](https://11x256.github.io/Frida-hooking-android-part-2/))
```javascript
var string_class = Java.use("java.lang.String") // get a JS wrapper for java's String class
@ -158,9 +212,9 @@ return ret
```
### Obtendo um objeto já criado de uma classe
Se você quiser extrair algum atributo de um objeto criado, pode usar isto.
Se quiser extrair um atributo de um objeto já criado, pode usar isto.
Neste exemplo, você verá como obter o objeto da classe my_activity e como chamar a função .secret() que imprimirá um atributo privado do objeto:
Neste exemplo você verá como obter o objeto da classe my_activity e como chamar a função .secret() que imprimirá um atributo privado do objeto:
```javascript
Java.choose("com.example.a11x256.frida_test.my_activity", {
onMatch: function (instance) {
@ -171,10 +225,16 @@ console.log("Result of secret func: " + instance.secret())
onComplete: function () {},
})
```
## Outros tutoriais Frida
## Outros tutoriais sobre Frida
- [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs)
- [Parte 1 da série de blogs sobre Uso Avançado do Frida: Bibliotecas de Criptografia IOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
- [Parte 1 da série de blogs Advanced Frida Usage: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
## Referências
- [Construa um laboratório Android de Bug Bounty repetível: Emulator vs Magisk, Burp, Frida e Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
- [Documentação do Frida Gadget](https://frida.re/docs/gadget/)
- [Releases do Frida (binários do servidor)](https://github.com/frida/frida/releases)
{{#include ../../../banners/hacktricks-training.md}}

63
src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md
View File

@ -1,20 +1,32 @@
# Instalar Certificado Burp
# Instalar certificado do Burp
{{#include ../../banners/hacktricks-training.md}}
## Proxy no sistema via ADB
Configure um proxy HTTP global para que todos os apps encaminhem o tráfego através do seu interceptor (Burp/mitmproxy):
```bash
# Set proxy (device/emulator must reach your host IP)
adb shell settings put global http_proxy 192.168.1.2:8080
# Clear proxy
adb shell settings put global http_proxy :0
```
Dica: In Burp, bind your listener to 0.0.0.0 so devices on the LAN can connect (Proxy -> Options -> Proxy Listeners).
## Em uma Máquina Virtual
Primeiro de tudo, você precisa baixar o certificado Der do Burp. Você pode fazer isso em _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
Primeiro, você precisa baixar o certificado Der do Burp. Você pode fazer isso em _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
![](<../../images/image (367).png>)
**Exporte o certificado no formato Der** e vamos **transformá-lo** em uma forma que o **Android** vai conseguir **entender.** Note que **para configurar o certificado burp na máquina Android no AVD** você precisa **executar** esta máquina **com** a opção **`-writable-system`**.\
**Exporte o certificado em formato Der** e vamos **transformá-lo** para uma forma que o **Android** consiga **entender.** Observe que **para configurar o certificado do Burp na máquina Android no AVD** você precisa **executar** esta máquina **com** a opção **`-writable-system`**.\
Por exemplo, você pode executá-la assim:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
```
Então, para **configurar o certificado do burp faça**:
Então, para **configurar o certificado do Burp**:
```bash
openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem
CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0"
@ -25,39 +37,43 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc
adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges
adb reboot #Now, reboot the machine
```
Uma vez que a **máquina terminar de reiniciar**, o certificado burp estará em uso por ela!
Once the **a máquina terminar de reiniciar** o certificado do Burp estará em uso!
## Usando Magisc
Se você **rootou seu dispositivo com Magisc** (talvez um emulador), e você **não consegue seguir** os **passos** anteriores para instalar o certificado Burp porque o **sistema de arquivos é somente leitura** e você não pode remontá-lo como gravável, há outra maneira.
Se você **rooted seu dispositivo com Magisc** (talvez um emulador), e você **não consegue seguir** os **passos** anteriores para instalar o certificado do Burp porque o **sistema de arquivos está em somente leitura** e você não pode remontá-lo como gravável, há outra maneira.
Explicado em [**este vídeo**](https://www.youtube.com/watch?v=qQicUW0svB8), você precisa:
Explicado em [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) você precisa:
1. **Instalar um certificado CA**: Basta **arrastar e soltar** o certificado DER Burp **mudando a extensão** para `.crt` no celular para que ele seja armazenado na pasta Downloads e ir para `Instalar um certificado` -> `Certificado CA`
1. **Instalar um certificado CA**: Basta **arrastar e soltar** o certificado DER do Burp **alterando a extensão** para `.crt` no celular para que seja armazenado na pasta Downloads e vá em `Install a certificate` -> `CA certificate`
<figure><img src="../../images/image (53).png" alt="" width="164"><figcaption></figcaption></figure>
- Verifique se o certificado foi armazenado corretamente indo para `Credenciais confiáveis` -> `USUÁRIO`
- Verifique que o certificado foi armazenado corretamente indo em `Trusted credentials` -> `USER`
<figure><img src="../../images/image (54).png" alt="" width="334"><figcaption></figcaption></figure>
2. **Torná-lo confiável pelo sistema**: Baixe o módulo Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (um arquivo .zip), **arraste e solte** no telefone, vá para o aplicativo **Magics** no telefone na seção **`Módulos`**, clique em **`Instalar do armazenamento`**, selecione o módulo `.zip` e, uma vez instalado, **reinicie** o telefone:
2. **Tornar confiável pelo sistema**: Baixe o módulo Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (um arquivo .zip), **arraste e solte** no telefone, vá ao **Magics app** no telefone para a seção **`Modules`**, clique em **`Install from storage`**, selecione o módulo `.zip` e uma vez instalado **reinicie** o telefone:
<figure><img src="../../images/image (55).png" alt="" width="345"><figcaption></figcaption></figure>
- Após reiniciar, vá para `Credenciais confiáveis` -> `SISTEMA` e verifique se o certificado Postswigger está lá
- Após reiniciar, vá em `Trusted credentials` -> `SYSTEM` e verifique que o Postswigger cert está lá
<figure><img src="../../images/image (56).png" alt="" width="314"><figcaption></figcaption></figure>
### Aprenda como criar um módulo Magisc
Veja [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
## Pós Android 14
Na última versão do Android 14, uma mudança significativa foi observada no manuseio de certificados de Autoridade Certificadora (CA) confiáveis pelo sistema. Anteriormente, esses certificados estavam armazenados em **`/system/etc/security/cacerts/`**, acessíveis e modificáveis por usuários com privilégios de root, o que permitia aplicação imediata em todo o sistema. No entanto, com o Android 14, o local de armazenamento foi movido para **`/apex/com.android.conscrypt/cacerts`**, um diretório dentro do caminho **`/apex`**, que é imutável por natureza.
No lançamento mais recente do Android 14, observou-se uma mudança significativa no tratamento dos certificados de Autoridade Certificadora (CA) confiáveis pelo sistema. Anteriormente, esses certificados ficavam em **`/system/etc/security/cacerts/`**, acessíveis e modificáveis por usuários com privilégios root, o que permitia sua aplicação imediata em todo o sistema. Contudo, com o Android 14, o local de armazenamento foi movido para **`/apex/com.android.conscrypt/cacerts`**, um diretório dentro do caminho **`/apex`**, que é imutável por natureza.
Tentativas de remontar o **caminho APEX cacerts** como gravável falham, pois o sistema não permite tais operações. Mesmo tentativas de desmontar ou sobrepor o diretório com um sistema de arquivos temporário (tmpfs) não contornam a imutabilidade; os aplicativos continuam a acessar os dados do certificado original, independentemente das mudanças no nível do sistema de arquivos. Essa resiliência se deve ao **montagem `/apex`** ser configurada com propagação PRIVADA, garantindo que quaisquer modificações dentro do diretório **`/apex`** não afetem outros processos.
Tentativas de remontar o **APEX cacerts path** como gravável falham, pois o sistema não permite tais operações. Mesmo tentativas de desmontar ou sobrepor o diretório com um sistema de arquivos temporário (tmpfs) não contornam a imutabilidade; as aplicações continuam acessando os dados originais dos certificados independentemente das mudanças no nível do sistema de arquivos. Essa resistência se deve ao fato de a montagem **`/apex`** estar configurada com propagação PRIVATE, garantindo que quaisquer modificações dentro do diretório **`/apex`** não afetem outros processos.
A inicialização do Android envolve o processo `init`, que, ao iniciar o sistema operacional, também inicia o processo Zygote. Este processo é responsável por lançar processos de aplicativos com um novo namespace de montagem que inclui uma montagem privada **`/apex`**, isolando assim as mudanças neste diretório de outros processos.
A inicialização do Android envolve o processo `init`, que, ao iniciar o sistema operacional, também inicia o processo Zygote. Esse processo é responsável por lançar os processos das aplicações com um novo namespace de montagem que inclui uma montagem privada **`/apex`**, isolando assim alterações a esse diretório de outros processos.
No entanto, existe uma solução para aqueles que precisam modificar os certificados CA confiáveis pelo sistema dentro do diretório **`/apex`**. Isso envolve remontar manualmente **`/apex`** para remover a propagação PRIVADA, tornando-o assim gravável. O processo inclui copiar o conteúdo de **`/apex/com.android.conscrypt`** para outro local, desmontar o diretório **`/apex/com.android.conscrypt`** para eliminar a restrição de somente leitura e, em seguida, restaurar o conteúdo ao seu local original dentro de **`/apex`**. Essa abordagem requer ação rápida para evitar falhas no sistema. Para garantir a aplicação em todo o sistema dessas mudanças, é recomendável reiniciar o `system_server`, que efetivamente reinicia todos os aplicativos e traz o sistema a um estado consistente.
Ainda assim, existe uma solução alternativa para quem precisa modificar os certificados CA confiáveis pelo sistema dentro do diretório **`/apex`**. Isso envolve remontar manualmente **`/apex`** para remover a propagação PRIVATE, tornando-o gravável. O processo inclui copiar o conteúdo de **`/apex/com.android.conscrypt`** para outro local, desmontar o diretório **`/apex/com.android.conscrypt`** para eliminar a restrição de somente leitura e então restaurar o conteúdo para seu local original dentro de **`/apex`**. Essa abordagem requer ação rápida para evitar travamentos do sistema. Para garantir que essas mudanças se apliquem em todo o sistema, recomenda-se reiniciar o `system_server`, o que efetivamente reinicia todas as aplicações e traz o sistema a um estado consistente.
```bash
# Create a separate temp directory, to hold the current certificates
# Otherwise, when we add the mount we can't read the current certs anymore.
@ -117,27 +133,26 @@ echo "System certificate injected"
```
### Bind-mounting through NSEnter
1. **Configurando um Diretório Gravável**: Inicialmente, um diretório gravável é estabelecido montando um `tmpfs` sobre o diretório de certificados do sistema não-APEX existente. Isso é alcançado com o seguinte comando:
1. **Configurando um diretório gravável**: Inicialmente, um diretório gravável é criado montando um `tmpfs` sobre o diretório de certificados do sistema non-APEX existente. Isso é feito com o seguinte comando:
```bash
mount -t tmpfs tmpfs /system/etc/security/cacerts
```
2. **Preparando Certificados CA**: Após a configuração do diretório gravável, os certificados CA que se pretende usar devem ser copiados para este diretório. Isso pode envolver a cópia dos certificados padrão de `/apex/com.android.conscrypt/cacerts/`. É essencial ajustar as permissões e os rótulos SELinux desses certificados de acordo.
3. **Montagem Bind para Zygote**: Utilizando `nsenter`, entra-se no namespace de montagem do Zygote. O Zygote, sendo o processo responsável por iniciar aplicativos Android, requer esta etapa para garantir que todos os aplicativos iniciados a partir de agora utilizem os novos certificados CA configurados. O comando utilizado é:
2. **Preparando Certificados CA**: Após a configuração do diretório gravável, os certificados CA que se pretende usar devem ser copiados para esse diretório. Isso pode envolver copiar os certificados padrão de `/apex/com.android.conscrypt/cacerts/`. É essencial ajustar as permissões e rótulos SELinux desses certificados adequadamente.
3. **Montagem bind para Zygote**: Usando `nsenter`, entra-se no namespace de montagem do Zygote. O Zygote, sendo o processo responsável por iniciar aplicações Android, requer este passo para garantir que todas as aplicações iniciadas a partir de então utilizem os certificados CA recém-configurados. O comando usado é:
```bash
nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
```
Isso garante que cada novo aplicativo iniciado seguirá a configuração atualizada dos certificados CA.
Isso garante que cada novo app iniciado seguirá a configuração atualizada dos certificados CA.
4. **Aplicando Mudanças em Aplicativos em Execução**: Para aplicar as mudanças em aplicativos já em execução, `nsenter` é novamente usado para entrar no namespace de cada aplicativo individualmente e realizar um bind mount semelhante. O comando necessário é:
4. **Aplicando alterações em apps em execução**: Para aplicar as alterações às aplicações já em execução, `nsenter` é novamente usado para entrar no namespace de cada app individualmente e executar um bind mount semelhante. O comando necessário é:
```bash
nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
```
5. **Abordagem Alternativa - Reinicialização Suave**: Um método alternativo envolve realizar o bind mount no processo `init` (PID 1) seguido por uma reinicialização suave do sistema operacional com os comandos `stop && start`. Essa abordagem propagaria as mudanças em todos os namespaces, evitando a necessidade de abordar individualmente cada aplicativo em execução. No entanto, esse método é geralmente menos preferido devido ao inconveniente de reiniciar.
5. **Abordagem alternativa - Reinício suave**: Um método alternativo envolve realizar o bind mount no processo `init` (PID 1) seguido por um reinício suave do sistema operacional com os comandos `stop && start`. Essa abordagem propagaria as mudanças por todos os namespaces, evitando a necessidade de tratar individualmente cada app em execução. No entanto, esse método geralmente é menos preferido devido ao inconveniente de reiniciar.
## Referências
- [https://httptoolkit.com/blog/android-14-install-system-ca-certificate/](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
- [Android 14: Install a system CA certificate on a rooted device](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
{{#include ../../banners/hacktricks-training.md}}