Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-19 01:24:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/mobile-pentesting/android-app-pentesting/README.md

836 lines
58 KiB
Markdown
Raw Blame History

# Teste de Penetração em Aplicativos Android
<details>
<summary><strong>Aprenda a hackear a AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Outras maneiras de apoiar o HackTricks:
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
</details>
<figure><img src="../../.gitbook/assets/image (380).png" alt=""><figcaption></figcaption></figure>
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
**Percepções de Hacking**\
Envolver-se com conteúdo que mergulha na emoção e desafios do hacking
**Notícias de Hacking em Tempo Real**\
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e percepções em tempo real
**Últimos Anúncios**\
Fique informado sobre os mais recentes programas de recompensas por bugs lançados e atualizações cruciais na plataforma
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
## Conceitos Básicos de Aplicativos Android
É altamente recomendável começar lendo esta página para saber sobre as **partes mais importantes relacionadas à segurança do Android e os componentes mais perigosos em um aplicativo Android**:
{% content-ref url="android-applications-basics.md" %}
[android-applications-basics.md](android-applications-basics.md)
{% endcontent-ref %}
## ADB (Android Debug Bridge)
Esta é a principal ferramenta que você precisa para se conectar a um dispositivo Android (emulado ou físico).\
**ADB** permite controlar dispositivos via **USB** ou **Rede** a partir de um computador. Este utilitário permite a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de aplicativos, **execução** de comandos de shell, **backup** de dados, **leitura** de logs, entre outras funções.
Dê uma olhada na seguinte lista de [**Comandos ADB**](adb-commands.md) para aprender como usar o adb.
## Smali
Às vezes é interessante **modificar o código do aplicativo** para acessar **informações ocultas** (talvez senhas bem ofuscadas ou flags). Então, pode ser interessante descompilar o apk, modificar o código e recompilá-lo.\
[Neste tutorial](smali-changes.md) você pode **aprender como descompilar um APK, modificar o código Smali e recompilar o APK** com a nova funcionalidade. Isso pode ser muito útil como uma **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Então, **sempre tenha em mente essa possibilidade**.
## Outros truques interessantes
* [Falsificar sua localização na Play Store](spoofing-your-location-in-play-store.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/)
* Extrair APK do dispositivo:
```bash
adb shell pm list packages
com.android.insecurebankv2
adb shell pm path com.android.insecurebankv2
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
```
* Junte todos os splits e apks base com o [APKEditor](https://github.com/REAndroid/APKEditor):
```bash
mkdir splits
adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 1 | xargs -n1 -i adb pull {} splits
java -jar ../APKEditor.jar m -i splits/ -o merged.apk
# after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
```
## Análise Estática
Primeiramente, para analisar um APK você deve **dar uma olhada no código Java** usando um decompilador.\
Por favor, [**leia aqui para encontrar informações sobre diferentes decompiladores disponíveis**](apk-decompilers.md).
### Procurando por Informações Interessantes
Apenas olhando para as **strings** do APK você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), chaves de **API**, **criptografia**, **UUIDs de bluetooth**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais de administrador codificadas no aplicativo).
**Firebase**
Dê atenção especial às **URLs do firebase** e verifique se estão mal configuradas. [Mais informações sobre o que é o Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Compreensão básica da aplicação - Manifest.xml, strings.xml
A **análise do arquivo \_Manifest.xml** e dos arquivos **strings.xml** de um aplicativo pode revelar vulnerabilidades de segurança potenciais. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do arquivo APK para .zip e descompactando-o.
As **vulnerabilidades** identificadas no **Manifest.xml** incluem:
* **Aplicativos Debugáveis**: Aplicativos definidos como debugáveis (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para entender melhor como explorar aplicativos debugáveis, consulte um tutorial sobre como encontrar e explorar aplicativos debugáveis em um dispositivo.
* **Configurações de Backup**: O atributo `android:allowBackup="false"` deve ser definido explicitamente para aplicativos que lidam com informações sensíveis para evitar backups não autorizados via adb, especialmente quando a depuração USB está ativada.
* **Segurança de Rede**: Configurações personalizadas de segurança de rede (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como pins de certificado e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
* **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise adicional durante os testes dinâmicos pode revelar como explorar esses componentes.
* **Provedores de Conteúdo e FileProviders**: Provedores de conteúdo expostos podem permitir acesso ou modificação não autorizados de dados. A configuração dos FileProviders também deve ser examinada.
* **Receptores de Broadcast e Esquemas de URL**: Esses componentes podem ser aproveitados para exploração, com atenção especial à forma como os esquemas de URL são gerenciados para vulnerabilidades de entrada.
* **Versões do SDK**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões antigas e vulneráveis do Android por motivos de segurança.
Do arquivo **strings.xml**, informações sensíveis como chaves de API, esquemas personalizados e outras notas de desenvolvedor podem ser descobertas, destacando a necessidade de uma revisão cuidadosa desses recursos.
### Tapjacking
**Tapjacking** é um ataque onde um **aplicativo malicioso** é lançado e **se posiciona sobre um aplicativo vítima**. Uma vez que obscurece visualmente o aplicativo vítima, sua interface de usuário é projetada de forma a enganar o usuário para interagir com ele, enquanto passa a interação para o aplicativo vítima.\
Na prática, ele **impede o usuário de saber que está realmente realizando ações no aplicativo vítima**.
Encontre mais informações em:
{% content-ref url="tapjacking.md" %}
[tapjacking.md](tapjacking.md)
{% endcontent-ref %}
### Sequestro de Tarefas
Uma **atividade** com o **`launchMode`** definido como **`singleTask` sem `taskAffinity`** definido é vulnerável ao sequestro de tarefas. Isso significa que um **aplicativo** pode ser instalado e, se lançado antes do aplicativo real, pode **sequestrar a tarefa do aplicativo real** (então o usuário estará interagindo com o **aplicativo malicioso pensando que está usando o real**).
Mais informações em:
{% content-ref url="android-task-hijacking.md" %}
[android-task-hijacking.md](android-task-hijacking.md)
{% endcontent-ref %}
### Armazenamento de Dados Inseguro
**Armazenamento Interno**
No Android, arquivos armazenados no **armazenamento interno** são **projetados** para serem **acessíveis** exclusivamente pelo **aplicativo** que os **criou**. Essa medida de segurança é **imposta** pelo sistema operacional Android e geralmente é adequada para as necessidades de segurança da maioria dos aplicativos. No entanto, os desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicativos. No entanto, esses modos **não restringem o acesso** a esses arquivos por outros aplicativos, incluindo possivelmente maliciosos.
1. **Análise Estática:**
* **Garanta** que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente examinado**. Esses modos **podem potencialmente expor** arquivos a **acessos não intencionais ou não autorizados**.
2. **Análise Dinâmica:**
* **Verifique** as **permissões** definidas nos arquivos criados pelo aplicativo. Especificamente, **verifique** se algum arquivo está **configurado para ser legível ou gravável globalmente**. Isso pode representar um risco significativo à segurança, pois permitiria que **qualquer aplicativo** instalado no dispositivo, independentemente de sua origem ou intenção, **leia ou modifique** esses arquivos.
**Armazenamento Externo**
Ao lidar com arquivos no **armazenamento externo**, como cartões SD, certas precauções devem ser tomadas:
1. **Acessibilidade**:
* Arquivos no armazenamento externo são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicativo 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 aplicativo, tornando-o menos seguro.
3. **Manuseio 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 seu aplicativo precisar recuperar arquivos executáveis do armazenamento externo, garanta que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Esta etapa é vital para manter a integridade de segurança do seu aplicativo.
O armazenamento externo pode ser **acessado** em `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
{% hint style="info" %}
A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretório que **limita o acesso de um aplicativo ao diretório especificamente para esse aplicativo**. Isso impede que aplicativos maliciosos obtenham acesso de leitura ou gravação aos arquivos de outro aplicativo.
{% endhint %}
**Dados sensíveis armazenados em texto claro**
* **Preferências compartilhadas**: O Android permite que cada aplicativo salve facilmente arquivos xml no caminho `/data/data/<nomedopacote>/shared_prefs/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta.
* **Bancos de Dados**: O Android permite que cada aplicativo salve bancos de dados sqlite facilmente no caminho `/data/data/<nomedopacote>/databases/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta.
### TLS Quebrado
**Aceitar Todos os Certificados**
Por algum motivo, às vezes os desenvolvedores aceitam todos os certificados, mesmo que, por exemplo, o nome do host não corresponda com linhas de código como a seguinte:
```java
SSLSocketFactory sf = new cc(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
```
### Criptografia Quebrada
**Processos de Gerenciamento de Chave Fracos**
Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave codificada/previsível no código. Isso não deve ser feito, pois a reversão pode permitir que os atacantes extraiam as informações confidenciais.
**Uso de Algoritmos Inseguros e/ou Obsoletos**
Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações** 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, hashes resistentes a ataques de força bruta devem ser usados com salt.
### Outras Verificações
* É recomendado **ofuscar o APK** para dificultar o trabalho de engenharia reversa para os atacantes.
* Se o aplicativo for sensível (como aplicativos bancários), ele deve realizar suas **próprias verificações para ver se o dispositivo móvel está rooteado** e agir em conformidade.
* Se o aplicativo for sensível (como aplicativos bancários), ele deve verificar se um **emulador** está sendo usado.
* Se o aplicativo for sensível (como aplicativos bancários), ele deve **verificar sua própria integridade antes de executá-lo** para verificar se foi modificado.
* Use [**APKiD**](https://github.com/rednaga/APKiD) para verificar qual compilador/packer/ofuscador foi usado para construir o APK.
### Aplicativo React Native
Leia a seguinte página para aprender como acessar facilmente o código JavaScript de aplicativos React:
{% content-ref url="react-native-application.md" %}
[react-native-application.md](react-native-application.md)
{% endcontent-ref %}
### Aplicativos Xamarin
Leia a seguinte página para aprender como acessar facilmente o código C# de aplicativos Xamarin:
{% content-ref url="../xamarin-apps.md" %}
[xamarin-apps.md](../xamarin-apps.md)
{% endcontent-ref %}
### Aplicativos Supercompactados
De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), supercompactado é um algoritmo Meta que comprime o conteúdo de um aplicativo em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descomprima esse tipo de aplicativo... e uma maneira mais rápida que envolve **executar o aplicativo e reunir os arquivos descompactados do sistema de arquivos**.
### Análise Estática Automatizada de Código
A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** escaneando o **código** do aplicativo. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam à ferramenta os **locais** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam à ferramenta **locais perigosos** onde a entrada maliciosa do usuário poderia causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indicam uma vulnerabilidade.
Com esse conhecimento, **mariana-trench revisará o código e encontrará possíveis vulnerabilidades nele**.
### Segredos Vazados
Um aplicativo pode conter segredos (chaves de API, senhas, URLs ocultas, subdomínios...) que você pode descobrir. Você pode usar uma ferramenta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
### Bypass na Autenticação Biométrica
{% content-ref url="bypass-biometric-authentication-android.md" %}
[bypass-biometric-authentication-android.md](bypass-biometric-authentication-android.md)
{% endcontent-ref %}
### Outras funções interessantes
* **Execução de Código**: `Runtime.exec(), ProcessBuilder(), código nativo:system()`
* **Enviar SMS**: `sendTextMessage, sendMultipartTestMessage`
* **Funções nativas** declaradas como `native`: `public native, System.loadLibrary, System.load`
* [Leia isso para aprender **como reverter funções nativas**](reversing-native-libraries.md)
### **Outros truques**
{% content-ref url="content-protocol.md" %}
[content-protocol.md](content-protocol.md)
{% endcontent-ref %}
***
<figure><img src="../../.gitbook/assets/image (380).png" alt=""><figcaption></figcaption></figure>
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs!
**Percepções de Hacking**\
Engaje-se com conteúdo que mergulha na emoção e desafios do hacking
**Notícias de Hacking em Tempo Real**\
Mantenha-se atualizado com o mundo acelerado do hacking por meio de notícias e insights em tempo real
**Últimos Anúncios**\
Fique informado sobre os mais novos programas de recompensas por bugs lançados e atualizações cruciais na plataforma
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
***
## Análise Dinâmica
> Primeiramente, você precisa de um ambiente onde possa instalar o aplicativo e todo o ambiente (certificado Burp CA, Drozer e Frida principalmente). Portanto, um dispositivo rooteado (emulado ou não) é extremamente recomendado.
### Análise Dinâmica Online
Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io). Esta plataforma permite que você **faça upload** e **execute** APKs, sendo útil para ver como um APK está se comportando.
Você pode até **ver os logs do seu aplicativo** na web e conectar-se por meio de **adb**.
![](<../../.gitbook/assets/image (831).png>)
Graças à conexão ADB, você pode usar **Drozer** e **Frida** nos emuladores.
### Análise Dinâmica Local
#### Usando um emulador
* [**Android Studio**](https://developer.android.com/studio) (Você pode criar dispositivos **x86** e **arm**, e de acordo com [**este** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**último x86**, as versões **suportam bibliotecas ARM** sem precisar de um emulador ARM lento).
* Aprenda a configurá-lo nesta página:
{% content-ref url="avd-android-virtual-device.md" %}
[avd-android-virtual-device.md](avd-android-virtual-device.md)
{% endcontent-ref %}
* [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Personal Edition, você precisa criar uma conta. _É recomendado **baixar** a versão **COM**_ _**VirtualBox** para evitar erros potenciais._)
* [**Nox**](https://es.bignox.com) (Gratuito, mas não suporta Frida ou Drozer).
{% hint style="info" %}
Ao criar um novo emulador em qualquer plataforma, lembre-se de que quanto maior a tela, mais lento o emulador funcionará. Portanto, selecione telas pequenas, se possível.
{% endhint %}
Para **instalar serviços do Google** (como a Play Store) no Genymotion, você precisa clicar no botão marcado de vermelho na seguinte imagem:
![](<../../.gitbook/assets/image (277).png>)
Além disso, observe que na **configuração da VM Android no Genymotion** você pode selecionar o modo **Bridge Network** (isso será útil se você for conectar-se à VM Android de uma VM diferente com as ferramentas).
#### Usar um dispositivo físico
Você precisa ativar as opções de **depuração** e será legal se você puder **rootear**:
1. **Configurações**.
2. (A partir do Android 8.0) Selecione **Sistema**.
3. Selecione **Sobre o telefone**.
4. Pressione **Número da versão** 7 vezes.
5. Volte e você encontrará as **Opções do desenvolvedor**.
> Depois de instalar o aplicativo, a primeira coisa que você deve fazer é testá-lo e investigar o que ele faz, como funciona e se familiarizar com ele.\
> Eu sugiro **realizar esta análise dinâmica inicial usando a análise dinâmica do MobSF + pidcat**, para que possamos **aprender como o aplicativo funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar posteriormente.
### Vazamento de Dados Não Intencional
**Registro**
Os desenvolvedores devem ter cuidado ao expor informações de **depuração** 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 do aplicativo a fim de identificar e proteger informações sensíveis. **Pidcat** é preferido por sua facilidade de uso e legibilidade.
{% hint style="warning" %}
Observe que a partir de **versões mais recentes do Android do que 4.0**, **aplicativos só podem acessar seus próprios logs**. Portanto, os aplicativos não podem acessar os logs de outros apps.\
De qualquer forma, ainda é recomendável **não registrar informações sensíveis**.
{% endhint %}
**Armazenamento em Cache do Buffer de Copiar/Colar**
O framework baseado em **clipboard** do Android permite a funcionalidade de copiar e colar em aplicativos, mas representa um risco, pois **outros aplicativos** podem **acessar** a área de transferência, expondo potencialmente dados sensíveis. É crucial **desativar as funções de copiar/colar** para seções sensíveis de um aplicativo, como detalhes de cartão de crédito, para evitar vazamentos de dados.
**Logs de Falhas**
Se um aplicativo **falhar** e **salvar logs**, esses logs podem ajudar os atacantes, especialmente quando o aplicativo não pode ser engenharia reversa. Para mitigar esse risco, evite registrar em caso de falhas e, se os logs precisarem ser transmitidos pela rede, certifique-se de que sejam enviados por meio de um canal SSL para segurança.
Como pentester, **tente dar uma olhada nesses logs**.
**Dados Analíticos Enviados a Terceiros**
Os aplicativos frequentemente integram serviços como o Google Adsense, que podem inadvertidamente **vazar dados sensíveis** devido a uma implementação inadequada pelos desenvolvedores. Para identificar possíveis vazamentos de dados, é aconselhável **interceptar o tráfego do aplicativo** e verificar se há envio de informações sensíveis para serviços de terceiros.
### Bancos de Dados SQLite
A maioria dos aplicativos usará **bancos de dados SQLite internos** para salvar informações. Durante o pentest, dê uma **olhada** nos **bancos de dados** criados, nos nomes das **tabelas** e **colunas** e em todos os **dados** salvos, pois você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\
Os bancos de dados devem estar localizados em `/data/data/o.nome.do.pacote/databases` como `/data/data/com.mwr.example.sieve/databases`
Se o banco de dados estiver salvando informações confidenciais e estiver **criptografado**, mas você pode **encontrar** a **senha** dentro do aplicativo, ainda é uma **vulnerabilidade**.
Enumere as tabelas usando `.tables` e enumere as colunas das tabelas fazendo `.schema <nome_da_tabela>`
### Drozer (Atividades de Exploração, Provedores de Conteúdo e Serviços)
Do [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um aplicativo Android** e interaja com outros aplicativos. Ele pode fazer **tudo o que um aplicativo instalado pode fazer**, como fazer uso do mecanismo de Comunicação entre Processos (IPC) do Android e interagir com o sistema operacional subjacente.\
Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Provedores de Conteúdo**, como você aprenderá nas seções a seguir.
### Explorando Atividades Exportadas
[**Leia isso se quiser relembrar o que é uma Atividade Android.**](android-applications-basics.md#launcher-activity-and-other-activities)\
Lembre-se também de que o código de uma atividade começa no método **`onCreate`**.
**Burla de Autorização**
Quando uma Atividade é exportada, você pode invocar sua tela a partir de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderia **burlar** os **mecanismos de autenticação** para acessá-la.
[**Aprenda como explorar atividades exportadas com o Drozer.**](drozer-tutorial/#activities)
Você também pode iniciar uma atividade exportada a partir do adb:
* PackageName é com.example.demo
* Nome da Atividade Exportada é com.example.test.MainActivity
```bash
adb shell am start -n com.example.demo/com.example.test.MainActivity
```
**NOTA**: O MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma atividade, mas devido a [este](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (versões de API < 21).
{% hint style="info" %}
Note que uma bypass de autorização nem sempre é uma vulnerabilidade, isso dependerá de como o bypass funciona e quais informações são expostas.
{% endhint %}
**Vazamento de informações sensíveis**
**As atividades também podem retornar resultados**. Se você conseguir encontrar uma atividade exportada e desprotegida chamando o método **`setResult`** e **retornando informações sensíveis**, há um vazamento de informações sensíveis.
#### Tapjacking
Se o tapjacking não for prevenido, você poderia abusar da atividade exportada para fazer com que o **usuário execute ações inesperadas**. Para mais informações sobre [**o que é Tapjacking siga o link**](./#tapjacking).
### Explorando Provedores de Conteúdo - Acessando e manipulando informações sensíveis
[**Leia isso se quiser relembrar o que é um Provedor de Conteúdo.**](android-applications-basics.md#content-provider)\
Os provedores de conteúdo são basicamente usados para **compartilhar dados**. Se um aplicativo tiver provedores de conteúdo disponíveis, você pode ser capaz de **extrair dados** sensíveis deles. Também é interessante testar possíveis **injeções de SQL** e **travessias de caminho** pois eles podem ser vulneráveis.
[**Aprenda como explorar Provedores de Conteúdo com o Drozer.**](drozer-tutorial/#content-providers)
### **Explorando Serviços**
[**Leia isso se quiser relembrar o que é um Serviço.**](android-applications-basics.md#services)\
Lembre-se que as ações de um Serviço começam no método `onStartCommand`.
Um serviço é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se um aplicativo estiver exportando alguns serviços, você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, burlar medidas de autenticação...\
[**Aprenda como explorar Serviços com o Drozer.**](drozer-tutorial/#services)
### **Explorando Receptores de Transmissão**
[**Leia isso se quiser relembrar o que é um Receptor de Transmissão.**](android-applications-basics.md#broadcast-receivers)\
Lembre-se que as ações de um Receptor de Transmissão começam no método `onReceive`.
Um receptor de transmissão estará aguardando por um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\
[**Aprenda como explorar Receptores de Transmissão com o Drozer.**](./#exploiting-broadcast-receivers)
### **Explorando Esquemas / Deep links**
Você pode procurar deep links manualmente, usando ferramentas como o MobSF ou scripts como [este](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
Você pode **abrir** um **esquema** declarado usando **adb** ou um **navegador**:
{% code overflow="wrap" %}
```bash
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
```
{% endcode %}
_Observe que você pode **omitir o nome do pacote** e o celular chamará automaticamente o aplicativo que deve abrir o link._
{% code overflow="wrap" %}
```markup
<!-- Browser regular link -->
<a href="scheme://hostname/path?param=value">Click me</a>
<!-- fallback in your url you could try the intent url -->
<a href="intent://hostname#Intent;scheme=scheme;package=your.package.name;S.browser_fallback_url=http%3A%2F%2Fwww.example.com;end">with alternative</a>
```
{% endcode %}
**Código executado**
Para encontrar o **código que será executado no aplicativo**, vá para a atividade chamada pelo deeplink e procure a função **`onNewIntent`**.
![](<../../.gitbook/assets/image (436) (1) (1) (1).png>)
**Informações sensíveis**
Sempre que encontrar um deeplink, verifique se **não está recebendo dados sensíveis (como senhas) por meio de parâmetros de URL**, pois qualquer outro aplicativo poderia **fingir ser o deeplink e roubar esses dados!**
**Parâmetros no caminho**
Você **também deve verificar se algum deeplink está usando um parâmetro dentro do caminho** do URL, como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar uma travessia de caminho acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
Observe que se você encontrar os endpoints corretos dentro do aplicativo, poderá causar um **Redirecionamento Aberto** (se parte do caminho for usado como nome de domínio), **assumir a conta** (se puder modificar detalhes de usuários sem token CSRF 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/).
**Mais exemplos**
Um [relatório interessante de recompensa por bugs](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_).
### Falhas na Inspeção e Verificação da Camada de Transporte
* **Certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum esses aplicativos ignorarem avisos e aceitarem certificados autoassinados ou, em alguns casos, voltarem a usar conexões HTTP.
* **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 de homem-no-meio (MITM), permitindo que invasores descriptografem os dados.
* **Vazamento de informações privadas** é um risco quando aplicativos 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 cookies de sessão ou detalhes do usuário, da interceptação por entidades maliciosas.
#### Verificação de Certificado
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 representar riscos significativos. Para etapas detalhadas sobre a verificação de certificados do servidor e a correção de vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientações abrangentes.
#### SSL Pinning
O SSL Pinning é uma medida de segurança em que o aplicativo verifica o certificado do servidor em relação a uma cópia conhecida armazenada dentro do próprio aplicativo. Este método é essencial para prevenir ataques MITM. Implementar o SSL Pinning é altamente recomendado para aplicativos que lidam com informações sensíveis.
#### Inspeção de Tráfego
Para inspecionar o tráfego HTTP, é necessário **instalar o certificado da ferramenta de 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 personalizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Aplicativos direcionados ao **Nível de API 24 e acima** requerem modificações na Configuração de Segurança de Rede para aceitar o certificado CA do proxy. Este passo é crucial para inspecionar o tráfego criptografado. Para instruções sobre como modificar a Configuração de Segurança de Rede, [**consulte este tutorial**](make-apk-accept-ca-certificate.md).
#### Bypass do SSL Pinning
Quando o SSL Pinning é implementado, torna-se necessário contorná-lo para inspecionar o tráfego HTTPS. Vários métodos estão disponíveis para esse fim:
* Modificar automaticamente o **apk** para **burlar** o SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem desta opção é que você não precisará de acesso root para burlar o SSL Pinning, mas precisará excluir o aplicativo e reinstalar o novo, e isso nem sempre funcionará.
* Você pode usar o **Frida** (discutido abaixo) para burlar essa proteção. Aqui está um guia para usar Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
* Você também pode tentar **burlar 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 **burlar automaticamente o SSL Pinning** usando **análise dinâmica do MobSF** (explicado abaixo)
* Se você ainda achar que há algum tráfego que não está capturando, pode tentar **encaminhar o tráfego para o burp usando iptables**. Leia este blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
#### Procurando por Vulnerabilidades Comuns na Web
Também é importante procurar por vulnerabilidades comuns na web dentro do aplicativo. Informações detalhadas sobre a identificação e mitigação dessas vulnerabilidades estão além do escopo deste resumo, mas são amplamente abordadas em outros lugares.
### Frida
[Frida](https://www.frida.re) é um kit de ferramentas de instrumentação dinâmica para desenvolvedores, engenheiros reversos e pesquisadores de segurança.\
**Você pode acessar o aplicativo em execução e enganchar métodos em tempo de execução para alterar o comportamento, alterar valores, extrair valores, executar código diferente...**\
Se você deseja fazer pentest em aplicativos Android, precisa saber como usar o Frida.
* Aprenda a usar o Frida: [**Tutorial do Frida**](frida-tutorial/)
* Algumas "GUI" para ações com o Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
* Ojection é ótimo para automatizar o uso do Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
* Você pode encontrar alguns scripts incríveis do Frida aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
* Tente burlar mecanismos anti-depuração / 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))
### **Despejo de Memória - Fridump**
Verifique se o aplicativo está armazenando informações sensíveis na memória que não deveria estar armazenando, como senhas ou mnemônicos.
Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode despejar a memória do aplicativo com:
```bash
# With PID
python3 fridump3.py -u <PID>
# With name
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
Isso irá despejar a memória na pasta ./dump e lá você poderá usar o grep com algo como:
{% code overflow="wrap" %}
```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]+$"
```
{% endcode %}
### **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 os aplicativos tendem a armazenar aqui **dados sensíveis em texto claro**, os testes de penetração devem verificar isso, pois um usuário root ou alguém com acesso físico ao dispositivo pode ser capaz de roubar esses dados.
Mesmo que um aplicativo armazene dados no keystore, os dados devem ser criptografados.
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
```
### **Bypass de Impressão Digital/Biometria**
Usando o seguinte script do Frida, poderia ser possível **burlar a autenticação por impressão digital** que aplicativos Android podem estar realizando para **proteger áreas sensíveis específicas:**
{% code overflow="wrap" %}
```bash
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
```
{% endcode %}
### **Imagens de Fundo**
Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando ele for recuperado para o primeiro plano, comece a carregar a imagem antes do aplicativo, fazendo com que pareça que o aplicativo foi carregado mais rapidamente.
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 é necessário ter acesso root para acessá-lo).
Os instantâneos geralmente são armazenados em: **`/data/system_ce/0/snapshots`**
O Android fornece uma maneira de **prevenir a captura de tela definindo o parâmetro de layout FLAG\_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que ele apareça em capturas de tela ou seja visualizado em displays não seguros.
```bash
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
```
### **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)
### Injeção de Intenção
Os desenvolvedores frequentemente criam componentes de proxy como atividades, serviços e receptores de transmissão que lidam com essas Intenções e as passam para métodos como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado.
O perigo está em permitir que atacantes acionem componentes de aplicativos não exportados ou acessem provedores de conteúdo sensíveis ao desviar essas Intenções. 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 maliciosas de Intenção.
### Pontos Essenciais
* **Injeção de Intenção** é semelhante ao problema de Redirecionamento Aberto na web.
* As explorações envolvem passar objetos `Intent` como extras, que podem ser redirecionados para executar operações inseguras.
* Pode expor componentes não exportados e provedores de conteúdo a atacantes.
* A conversão de URL do `WebView` para `Intent` pode facilitar ações não intencionais.
### Injeções do Lado do Cliente Android e outros
Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter cuidado especial com essas vulnerabilidades em um aplicativo Android:
* **Injeção de SQL:** Ao lidar com consultas dinâmicas ou Provedores de Conteúdo, certifique-se de estar usando consultas parametrizadas.
* **Injeção de JavaScript (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para quaisquer WebViews (desativado por padrão). [Mais informações aqui](webview-attacks.md#javascript-enabled).
* **Inclusão de Arquivo Local:** Os WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mais informações aqui](webview-attacks.md#javascript-enabled).
* **Cookies eternos:** Em vários casos, quando o aplicativo Android encerra a sessão, o cookie não é revogado ou pode até ser salvo no disco.
* [**Flag Segura** em cookies](../../pentesting-web/hacking-with-cookies/#cookies-flags)
***
<figure><img src="../../.gitbook/assets/image (380).png" alt=""><figcaption></figcaption></figure>
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs!
**Percepções de Hacking**\
Engaje-se com conteúdo que explora a emoção e os desafios do hacking
**Notícias de Hacking em Tempo Real**\
Mantenha-se atualizado com o mundo acelerado do hacking por meio de notícias e percepções em tempo real
**Últimos Anúncios**\
Fique informado sobre os mais novos programas de recompensas por bugs lançados e atualizações cruciais na plataforma
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
## Análise Automática
### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
**Análise estática**
![](<../../.gitbook/assets/image (866).png>)
**Avaliação de vulnerabilidades do aplicativo** usando uma interface web agradável. 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
```
Observe que o MobSF pode analisar aplicativos **Android**(apk), **IOS**(ipa) e **Windows**(apx) (_os aplicativos do Windows devem ser analisados a partir de um MobSF instalado em um host Windows_).\
Além disso, se você criar um arquivo **ZIP** com o código-fonte de um aplicativo **Android** ou **IOS** (vá até a pasta raiz do aplicativo, selecione tudo e crie um arquivo ZIP), ele também poderá analisá-lo.
O MobSF também permite que você faça a **diferença/comparação** de análises e integre o **VirusTotal** (você precisará configurar sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **enviado** em vez do arquivo.
### Análise dinâmica assistida com o MobSF
O **MobSF** também pode ser muito útil para **análise dinâmica** no **Android**, mas nesse caso você precisará instalar o MobSF e o **genymotion** em seu host (uma VM ou Docker não funcionarão). _Nota: Você precisa **iniciar primeiro uma VM no genymotion** e **depois o MobSF.**_\
O **analisador dinâmico do MobSF** pode:
* **Extrair dados do aplicativo** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas pelo "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando desejar uma captura de tela ou pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
* Capturar **tráfego HTTPS**
* Usar o **Frida** para obter **informações em tempo de execução**
A partir das versões do Android > 5, ele **iniciará automaticamente o Frida** e definirá as configurações globais de **proxy** para **capturar** o tráfego. Ele capturará apenas o tráfego do aplicativo testado.
**Frida**
Por padrão, ele também usará alguns Scripts do Frida para **burlar a verificação de SSL**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
O MobSF também pode **invocar atividades exportadas**, capturar **capturas de tela** delas e **salvá-las** para o relatório.
Para **iniciar** os testes dinâmicos, pressione o botão verde: "**Iniciar Instrumentação**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts do Frida e "**Monitor de API ao Vivo**" para ver todas as invocações aos métodos conectados, argumentos passados e valores retornados (isso aparecerá após pressionar "Iniciar Instrumentação").\
O MobSF também permite que você carregue seus próprios **scripts do Frida** (para enviar os resultados de seus scripts do Friday para o MobSF, use a função `send()`). Ele também possui **vários scripts pré-escritos** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Carregar**" e pressionar "**Iniciar Instrumentação**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**").
![](<../../.gitbook/assets/image (419).png>)
Além disso, você tem algumas funcionalidades auxiliares do Frida:
* **Enumerar Classes Carregadas**: Ele imprimirá todas as classes carregadas
* **Capturar Strings**: Ele imprimirá todas as strings capturadas ao usar o aplicativo (muito ruidoso)
* **Comparação de Strings Capturadas**: Pode ser muito útil. Ele **mostrará as 2 strings sendo comparadas** e se o resultado foi Verdadeiro ou Falso.
* **Enumerar Métodos de Classe**: Insira o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
* **Pesquisar Padrão de Classe**: Pesquisar classes por padrão
* **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que por padrão o MobSF rastreia vários métodos interessantes da API do Android.
Depois de selecionar o módulo auxiliar que deseja usar, você precisa pressionar "**Iniciar Instrumentação**" e verá todas as saídas em "**Frida Live Logs**".
**Shell**
O Mobsf também oferece um shell com alguns comandos **adb**, comandos do **MobSF** e comandos **shell** comuns na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
```bash
help
shell ls
activities
exported_activities
services
receivers
```
**Ferramentas HTTP**
Quando o tráfego http é capturado, você pode ver uma visualização feia do tráfego capturado no rodapé "**HTTP(S) Traffic**" ou uma visualização mais agradável no botão verde "**Start HTTPTools**". A partir da segunda opção, você pode **enviar** as **solicitações capturadas** para **proxies** como Burp ou Owasp ZAP.\
Para fazer isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a solicitação_ --> pressione "**Send to Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.1:8080)).
Após concluir a análise dinâmica com o MobSF, você pode pressionar "**Start Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
{% hint style="info" %}
Após realizar uma análise dinâmica com o MobSF, as configurações do proxy podem estar incorretas e você não poderá corrigi-las pela GUI. Você pode corrigir as configurações do proxy fazendo:
```
adb shell settings put global http_proxy :0
```
{% endhint %}
### Análise Dinâmica Assistida com Inspeckage
Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
Esta ferramenta usará alguns **Hooks** para informar **o que está acontecendo no aplicativo** enquanto você realiza uma **análise dinâmica**.
### [Yaazhini](https://www.vegabird.com/yaazhini/)
Esta é uma **ótima ferramenta para realizar análise estática com uma GUI**
![](<../../.gitbook/assets/image (741).png>)
### [Qark](https://github.com/linkedin/qark)
Esta ferramenta é projetada para procurar várias **vulnerabilidades de segurança relacionadas a aplicativos Android**, seja no **código-fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um APK implantável "Proof-of-Concept"** e **comandos ADB** para explorar algumas das vulnerabilidades encontradas (atividades expostas, intenções, tapjacking...). Assim como o Drozer, não é necessário fazer 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
qark --java path/to/parent/java/folder
qark --java path/to/specific/java/file.java
```
### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
* Mostra todos os arquivos extraídos para fácil referência
* Decompila automaticamente arquivos APK para formato Java e Smali
* Analisa AndroidManifest.xml em busca de vulnerabilidades e comportamentos comuns
* Análise estática de código-fonte em busca de vulnerabilidades e comportamentos comuns
* Informações do dispositivo
* e muito mais
```bash
reverse-apk relative/path/to/APP.apk
```
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
O 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. Ele faz isso descomprimindo os 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 precisam.
Baixe os binários mais recentes na [página de download](https://superanalyzer.rocks/download.html)
```
super-analyzer {apk_file}
```
### [StaCoAn](https://github.com/vincentcox/StaCoAn)
![](<../../.gitbook/assets/image (297).png>)
StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, caçadores de bugs e hackers éticos a realizar [análise de código estático](https://en.wikipedia.org/wiki/Static\_program\_analysis) em aplicativos móveis.
O conceito é que você arraste e solte o arquivo do seu 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 listas de palavras para obter uma experiência personalizada.
Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
```
./stacoan
```
### [AndroBugs](https://github.com/AndroBugs/AndroBugs\_Framework)
O AndroBugs Framework é um sistema de análise de vulnerabilidades do Android que ajuda desenvolvedores ou hackers a encontrar possíveis vulnerabilidades de segurança em aplicativos Android.\
[Windows releases](https://github.com/AndroBugs/AndroBugs\_Framework/releases)
```
python androbugs.py -f [APK file]
androbugs.exe -f [APK file]
```
### [Androwarn](https://github.com/maaaaz/androwarn)
**Androwarn** é uma ferramenta cujo principal objetivo é detectar e alertar o usuário sobre possíveis comportamentos maliciosos desenvolvidos por um aplicativo Android.
A detecção é realizada com a **análise estática** do bytecode Dalvik do aplicativo, representado como **Smali**, com a biblioteca [`androguard`](https://github.com/androguard/androguard).
Esta ferramenta procura por **comportamentos comuns de aplicativos "ruins"** como: exfiltração de identificadores de telefonia, interceptação de fluxo de áudio/vídeo, modificação de dados PIM, execução de código arbitrário...
```
python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
```
### [Framework MARA](https://github.com/xtiankisutsa/MARA_Framework)
![](<../../.gitbook/assets/image (595).png>)
**MARA** é um **F**ramework de **R**everse engineering e **A**nálise de **A**plicativos **M**óveis. É uma ferramenta que reúne ferramentas comumente usadas para reverse engineering e análise de aplicativos móveis, para auxiliar nos testes de aplicativos móveis contra as ameaças de segurança móvel da OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicativos móveis e profissionais de segurança.
Ele é capaz de:
* Extrair código Java e Smali usando diferentes ferramentas
* Analisar APKs usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
* Extrair informações privadas do APK usando regexps.
* Analisar o Manifest.
* Analisar domínios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) e [whatweb](https://github.com/urbanadventurer/WhatWeb)
* Desofuscar APK via [apk-deguard.com](http://www.apk-deguard.com)
### Koodous
Útil para detectar malware: [https://koodous.com/](https://koodous.com)
## Ofuscando/Desofuscando código
Observe que, dependendo do serviço e configuração que você usa para ofuscar o código, segredos podem ou não ser ofuscados.
### [ProGuard](https://en.wikipedia.org/wiki/ProGuard\_\(software\))
Do [Wikipedia](https://en.wikipedia.org/wiki/ProGuard\_\(software\)): **ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca o código Java. Ele é capaz de otimizar o bytecode, bem como detectar e remover instruções não utilizadas. O ProGuard é um software gratuito e é distribuído sob a Licença Pública Geral GNU, versão 2.
O ProGuard é distribuído como parte do Android SDK e é executado ao compilar o aplicativo no modo de lançamento.
### [DexGuard](https://www.guardsquare.com/dexguard)
Encontre um guia passo a passo para desofuscar o apk em [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:
* carregar um recurso como um InputStream;
* alimentar o resultado para uma classe herdando de FilterInputStream para descriptografá-lo;
* fazer alguma ofuscação inútil para desperdiçar alguns minutos de tempo de um reversor;
* alimentar o resultado descriptografado para um ZipInputStream para obter um arquivo DEX;
* finalmente carregar o DEX resultante como um Recurso usando o método `loadDex`.
### [DeGuard](http://apk-deguard.com)
**DeGuard reverte o processo de ofuscação realizado por ferramentas de obfuscação do Android. Isso permite inúmeras análises de segurança, incluindo inspeção de código e previsão de bibliotecas.**
Você pode fazer upload de um APK ofuscado para a plataforma deles.
### [Simplify](https://github.com/CalebFenton/simplify)
É um **desofuscador genérico para Android.** Simplify **executa virtualmente um aplicativo** 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 o tipo específico de ofuscação usado.
### [APKiD](https://github.com/rednaga/APKiD)
APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muitos **compiladores**, **empacotadores**, **ofuscadores** e outras coisas estranhas. É [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
### Manual
[Leia este tutorial para aprender alguns truques sobre **como reverter a ofuscação personalizada**](manual-deobfuscation.md)
## Laboratórios
### [Androl4b](https://github.com/sh4hin/Androl4b)
AndroL4b é uma máquina virtual de segurança Android baseada no ubuntu-mate que inclui a coleção mais recente de estruturas, tutoriais e laboratórios de diferentes geeks de segurança e pesquisadores para engenharia reversa e análise de malware.
## Referências
* [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
* [https://appsecwiki.com/#/](https://appsecwiki.com/#/) É uma ótima lista de recursos
* [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) 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)
## Ainda a ser testado
* [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
* [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)
<figure><img src="../../.gitbook/assets/image (380).png" alt=""><figcaption></figcaption></figure>
Junte-se ao [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server para se comunicar com hackers experientes e caçadores de bugs!
**Percepções de Hacking**\
Engaje-se com conteúdo que mergulha na emoção e desafios do hacking
**Notícias de Hacking em Tempo Real**\
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
**Últimos Anúncios**\
Fique informado sobre os mais novos programas de recompensas por bugs lançados e atualizações cruciais na plataforma
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
<details>
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Outras maneiras de apoiar o HackTricks:
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
Reference in a new issue View git blame Copy permalink