mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-21 18:43:29 +00:00
845 lines
60 KiB
Markdown
845 lines
60 KiB
Markdown
# Teste de Penetração em Aplicações Android
|
|
|
|
<details>
|
|
|
|
<summary><strong>Aprenda hacking no 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 formas de apoiar o HackTricks:
|
|
|
|
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* Adquira o [**material 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-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
|
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (3) (1).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!
|
|
|
|
**Insights 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 através de notícias e insights em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado sobre os mais novos programas de bug bounty e atualizações importantes da plataforma
|
|
|
|
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
|
|
|
|
## Fundamentos de Aplicações Android
|
|
|
|
É altamente recomendável começar lendo esta página para saber sobre as **partes mais importantes relacionadas à segurança Android e os componentes mais perigosos em uma aplicação 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).\
|
|
Ela permite controlar seu dispositivo via **USB** ou **Rede** a partir de um computador, **copiar** arquivos para frente e para trás, **instalar** e desinstalar apps, executar comandos **shell**, realizar **backups**, ler **logs** e mais.
|
|
|
|
Dê uma olhada na seguinte lista de [**Comandos ADB**](adb-commands.md) para aprender a usar o adb.
|
|
|
|
## Smali
|
|
|
|
Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas bem ofuscadas ou flags). Então, pode ser interessante descompilar o apk, modificar o código e recompilá-lo.\
|
|
[**Neste tutorial** você pode **aprender como descompilar e modificar o código Smali e recompilar o APK** com a nova funcionalidade](smali-changes.md). Isso pode ser muito útil como uma **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Então, **sempre tenha em mente essa possibilidade**.
|
|
|
|
## Outras dicas interessantes
|
|
|
|
* [Falsificando 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
|
|
```
|
|
## Análise Estática
|
|
|
|
Primeiro de tudo, para analisar um APK você deve **olhar para o 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 bluetooth**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais de admin codificadas na aplicação).
|
|
|
|
**Firebase**
|
|
|
|
Preste atenção especial às **URLs do firebase** 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)
|
|
|
|
### Entendimento Básico da Aplicação - Manifest.xml, strings.xml
|
|
|
|
Usando qualquer um dos **decompiladores** mencionados [**aqui**](apk-decompilers.md) você poderá ler o _Manifest.xml_. Você também pode **renomear** a extensão do arquivo **apk para .zip** e **descompactá-lo**.\
|
|
Lendo o **manifesto** você pode encontrar **vulnerabilidades**:
|
|
|
|
* Primeiro de tudo, verifique se **a aplicação é depurável**. Um APK de produção não deveria ser (ou outros poderão se conectar a ele). Você pode verificar se uma aplicação é depurável procurando no manifesto pelo atributo `debuggable="true"` dentro da tag _\<application_ Exemplo: `<application theme="@2131296387" debuggable="true"`
|
|
* [Aprenda aqui](drozer-tutorial/#is-debuggeable) como encontrar aplicações depuráveis em um telefone e explorá-las
|
|
* **Backup**: O atributo **`android:allowBackup`** define se os dados da aplicação podem ser salvos e restaurados por um usuário que habilitou a depuração usb. Se a flag de backup estiver definida como verdadeira, permite que um atacante faça o backup dos dados da aplicação via adb mesmo se o dispositivo não estiver rooteado. Portanto, aplicações que lidam e armazenam informações sensíveis, como detalhes de cartões, senhas etc., devem ter essa configuração explicitamente definida como **false** porque por padrão está definida como **true** para evitar tais riscos.
|
|
* `<application android:allowBackup="false"`
|
|
* **NetworkSecurity:** A segurança de rede da aplicação pode sobrescrever os valores padrões com **`android:networkSecurityConfig="@xml/network_security_config"`**. Um arquivo com esse nome pode ser colocado em _**res/xml.**_ Esse arquivo configurará configurações de segurança importantes como pinos de certificado ou se permite tráfego HTTP. Você pode ler aqui mais informações sobre todas as coisas que podem ser configuradas, mas verifique este exemplo sobre como configurar o tráfego HTTP para alguns domínios:
|
|
* `<domain-config cleartextTrafficPermitted="true"> <domain includeSubdomains="true">formation-software.co.uk </domain></domain-config>`
|
|
* **Atividades Exportadas**: Verifique as atividades exportadas dentro do manifesto, pois isso pode ser perigoso. Mais adiante na análise dinâmica será explicado como [você pode abusar desse comportamento](./#exploiting-exported-activities-authorisation-bypass).
|
|
* **Provedores de Conteúdo**: Se um provedor exportado está sendo exposto, você poderá acessar/modificar informações interessantes. Na análise dinâmica [você aprenderá como abusar deles](./#exploiting-content-providers-accessing-and-manipulating-sensitive-information).
|
|
* Verifique as configurações de **FileProviders** dentro do atributo `android:name="android.support.FILE_PROVIDER_PATHS"`. [Leia aqui para aprender mais sobre FileProviders](./#fileprovider).
|
|
* **Serviços Expostos**: Dependendo do que o serviço está fazendo internamente, vulnerabilidades podem ser exploradas. Na análise dinâmica [você aprenderá como abusar deles](./#exploiting-services).
|
|
* **Receptores de Broadcast**: [Você aprenderá como você pode possivelmente explorá-los](./#exploiting-broadcast-receivers) durante a análise dinâmica.
|
|
* **Esquema de URL**: Leia o código da atividade que gerencia o esquema e procure por vulnerabilidades no gerenciamento da entrada do usuário. Mais informações sobre [o que é um esquema de URL aqui](./#url-schemes).
|
|
* **minSdkVersion**, **targetSDKVersion**, **maxSdkVersion**: Eles indicam as versões do Android nas quais o aplicativo funcionará. É importante ter isso em mente porque, do ponto de vista da segurança, suportar versões antigas permitirá que versões vulneráveis conhecidas do Android o executem.
|
|
|
|
Lendo **resources.arsc/strings.xml** você pode encontrar algumas **informações interessantes**:
|
|
|
|
* Chaves de API
|
|
* Esquemas personalizados
|
|
* Outras informações interessantes que os desenvolvedores salvam neste arquivo
|
|
|
|
### Tapjacking
|
|
|
|
**Tapjacking** é um ataque onde um **aplicativo malicioso** é lançado e **se posiciona em cima de um aplicativo vítima**. Uma vez que ele obscurece visivelmente o aplicativo vítima, sua interface de usuário é projetada de tal forma a enganar o usuário para interagir com ela, enquanto passa a interação para o aplicativo vítima.\
|
|
Na prática, está **cegando 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 Tarefa
|
|
|
|
Uma **atividade** com o **`launchMode`** definido como **`singleTask` sem nenhuma `taskAffinity`** definida é vulnerável ao sequestro de tarefa. Isso significa que um **aplicativo** pode ser instalado e, se lançado antes do aplicativo real, poderia **sequestrar a tarefa do aplicativo real** (então o usuário estará interagindo com o **aplicativo malicioso pensando que está usando o verdadeiro**).
|
|
|
|
Mais informações em:
|
|
|
|
{% content-ref url="android-task-hijacking.md" %}
|
|
[android-task-hijacking.md](android-task-hijacking.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Armazenamento Inseguro de Dados
|
|
|
|
**Armazenamento Interno**
|
|
|
|
Arquivos **criados** no **armazenamento interno** são **acessíveis** apenas pelo **aplicativo**. Essa proteção é implementada pelo Android e é suficiente para a maioria das aplicações. Mas os desenvolvedores frequentemente usam `MODE_WORLD_READBALE` & `MODE_WORLD_WRITABLE` para dar acesso a esses arquivos a um aplicativo diferente, mas isso não limita outros aplicativos (maliciosos) de acessá-los.\
|
|
Durante a **análise estática** **verifique** o uso desses **modos**, durante a **análise dinâmica** **verifique** as **permissões** dos arquivos criados (talvez alguns deles sejam legíveis/graváveis mundialmente).\
|
|
[Mais informações sobre essa vulnerabilidade e como corrigi-la aqui.](https://manifestsecurity.com/android-application-security-part-8/)
|
|
|
|
**Armazenamento Externo**
|
|
|
|
Arquivos criados no **armazenamento externo**, como cartões SD, são **globalmente legíveis e graváveis**. Como o armazenamento externo pode ser removido pelo usuário e também modificado por qualquer aplicativo, você não deve **armazenar informações sensíveis usando armazenamento externo**.\
|
|
Como com dados de qualquer fonte não confiável, você deve **realizar validação de entrada** ao lidar com **dados de armazenamento externo**. Recomendamos fortemente que você não armazene arquivos executáveis ou arquivos de classe no armazenamento externo antes do carregamento dinâmico. Se o seu aplicativo recuperar arquivos executáveis do armazenamento externo, os arquivos devem ser assinados e verificados criptograficamente antes do carregamento dinâmico.\
|
|
Informações tiradas de [aqui](https://manifestsecurity.com/android-application-security-part-8/).
|
|
|
|
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 tem uma estrutura de diretórios que **limita o acesso de um aplicativo ao diretório que é especificamente para aquele aplicativo**. Isso impede que aplicativos maliciosos ganhem acesso de leitura ou escrita 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/<packagename>/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 facilmente bancos de dados sqlite no caminho `/data/data/<packagename>/databases/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta.
|
|
|
|
### TLS Quebrado
|
|
|
|
**Aceitar Todos os Certificados**
|
|
|
|
Por alguma razão, à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);
|
|
```
|
|
```markdown
|
|
Uma boa maneira de testar isso é tentar capturar o tráfego usando algum proxy como o Burp sem autorizar o CA do Burp dentro do dispositivo. Além disso, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo.
|
|
|
|
### Criptografia Quebrada
|
|
|
|
**Processos de Gerenciamento de Chaves Pobres**
|
|
|
|
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 algum processo de engenharia reversa poderia permitir que atacantes extraíssem as informações confidenciais.
|
|
|
|
**Uso de Algoritmos Inseguros e/ou Obsoletos**
|
|
|
|
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** são usados para armazenar senhas, por exemplo, devem ser usados hashes **resistentes** à força bruta com sal.
|
|
|
|
### Outras verificações
|
|
|
|
* É recomendado **ofuscar o APK** para dificultar o trabalho de engenharia reversa por atacantes.
|
|
* Se o aplicativo for sensível (como apps bancários), deve realizar **suas próprias verificações para ver se o celular está rooteado** e agir em consequência.
|
|
* Se o aplicativo for sensível (como apps bancários), deve verificar se um **emulador** está sendo usado.
|
|
* Se o aplicativo for sensível (como apps bancários), deve **verificar sua própria integridade antes de executar** para checar 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 aplicações React:
|
|
|
|
{% content-ref url="react-native-application.md" %}
|
|
[react-native-application.md](react-native-application.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Aplicações Xamarin
|
|
|
|
Leia a seguinte página para aprender como acessar facilmente o código C# de aplicações xamarin:
|
|
|
|
{% content-ref url="../xamarin-apps.md" %}
|
|
[xamarin-apps.md](../xamarin-apps.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Aplicações Superpacked
|
|
|
|
De acordo com este [**post do blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo da Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descomprima esses tipos de apps... e uma maneira mais rápida que envolve **executar o aplicativo e coletar os arquivos descomprimidos 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** ao **analisar** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indica à ferramenta os **locais** onde a **entrada** é **controlada pelo usuário**), **pontos de entrada** (que indica à ferramenta **locais perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-pontos de entrada** que sinaliza 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...) dentro dele que você pode ser capaz de descobrir. Você poderia usar uma ferramenta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
|
|
|
### Bypass de 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 SMSs**: `sendTextMessage, sendMultipartTestMessage`
|
|
* **Funções nativas** declaradas como `native`: `public native, System.loadLibrary, System.load`
|
|
* [Leia isto 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 (1) (3) (1).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!
|
|
|
|
**Insights 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 através de notícias e insights em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado com os mais novos bounties de bugs lançados e atualizações cruciais da 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
|
|
|
|
> Primeiro de tudo, você precisa de um ambiente onde possa instalar o aplicativo e todo o ambiente (certificado CA do Burp, 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, por isso é útil para ver como um apk se comporta.
|
|
|
|
Você pode até **ver os logs do seu aplicativo** na web e se conectar através do **adb**.
|
|
|
|
.png>)
|
|
|
|
Graças à conexão ADB, você pode usar **Drozer** e **Frida** dentro dos 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) **últimas versões x86** 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. _É recomendável **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 AppStore) no Genymotion, você precisa clicar no botão marcado em vermelho da seguinte imagem:
|
|
|
|
 (1).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ê estiver se conectando à VM Android de uma VM diferente com as ferramentas).
|
|
|
|
#### Use um dispositivo físico
|
|
|
|
Você precisa ativar as opções de **depuração** e seria bom se você pudesse **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 de desenvolvedor**.
|
|
|
|
> Uma vez que você tenha instalado o aplicativo, a primeira coisa que você deve fazer é experimentá-lo e investigar o que ele faz, como funciona e se familiarizar com ele.\
|
|
> Eu sugeriria **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 mais tarde.
|
|
|
|
### Vazamento de Dados Não Intencionais
|
|
|
|
**Logging**
|
|
|
|
Muitas vezes, os desenvolvedores deixam informações de depuração publicamente. Assim, qualquer aplicativo com permissão `READ_LOGS` pode **acessar esses logs** e obter informações sensíveis por meio deles.\
|
|
Enquanto navega pelo aplicativo, use [**pidcat**](https://github.com/JakeWharton/pidcat)_(Recomendado, é mais fácil de usar e ler)_ ou [adb logcat](adb-commands.md#logcat) para ler os logs criados e **procurar por informações sensíveis**.
|
|
|
|
{% hint style="warning" %}
|
|
Observe que a partir de versões **posteriores ao Android 4.0**, **aplicativos só podem acessar seus próprios logs**. Então, aplicativos não podem acessar logs de outros apps.\
|
|
De qualquer forma, ainda é recomendado **não registrar informações sensíveis**.
|
|
{% endhint %}
|
|
|
|
**Cópia/Colagem de Cache do Buffer**
|
|
|
|
O Android fornece uma estrutura baseada em **clipboard** para fornecer a função de copiar-colar em aplicativos Android. Mas isso cria um problema sério quando algum **outro aplicativo** pode **acessar** o **clipboard** que contém alguns dados sensíveis. A função **Copiar/Colar** deve ser **desativada** para a **parte sensível** do aplicativo. Por exemplo, desative a cópia dos detalhes do cartão de crédito.
|
|
|
|
**Logs de Falhas**
|
|
|
|
Se um aplicativo **falha** durante a execução e **salva logs** em algum lugar, esses logs podem ser úteis para um atacante, especialmente em casos em que o aplicativo Android não pode ser engenharia reversa. Então, evite criar logs quando os aplicativos falharem e, se os logs forem enviados pela rede, garanta que sejam enviados por um canal SSL.\
|
|
Como pentester, **tente dar uma olhada nesses logs**.
|
|
|
|
**Dados de Análise Enviados a Terceiros**
|
|
|
|
A maioria dos aplicativos usa outros serviços em seu aplicativo, como o Google Adsense, mas às vezes eles **vazam alguns dados sensíveis** ou dados que não são necessários para serem enviados a esse serviço. Isso pode acontecer devido ao desenvolvedor não implementar o recurso corretamente. Você pode **verificar interceptando o tráfego** do aplicativo e ver se algum dado sensível é enviado a terceiros ou não.
|
|
|
|
### 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/bancos de dados` 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 (Explorar Atividades, Provedores de Conteúdo e Serviços)
|
|
|
|
**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 Inter-Processos (IPC) do Android e interagir com o sistema operacional subjacente. Do [Guia Drozer](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf).\
|
|
Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Provedores de Conteúdo** como você aprenderá nas próximas seções.
|
|
|
|
### Explorando Atividades Exportadas
|
|
|
|
[**Leia isto se você quiser relembrar o que é uma Atividade Android.**](android-applications-basics.md#launcher-activity-and-other-activities)\
|
|
Também lembre-se de que o código de uma atividade começa com o método `onCreate`.
|
|
|
|
**Bypass de Autorização**
|
|
|
|
Quando uma Atividade é exportada, você pode invocar sua tela 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 Drozer.**](drozer-tutorial/#activities)
|
|
|
|
Você também pode iniciar uma atividade exportada a partir do adb:
|
|
|
|
* Nome do Pacote é 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 [isto](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso só é perigoso em versões antigas (versões da API < 21).
|
|
|
|
{% hint style="info" %}
|
|
Observe que uma falha de autorização nem sempre é uma vulnerabilidade, isso dependerá de como a falha funciona e quais informações são expostas.
|
|
{% endhint %}
|
|
|
|
**Vazamento de informações sensíveis**
|
|
|
|
**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ê poderá abusar da atividade exportada para fazer o **usuário realizar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking, siga o link**](./#tapjacking).
|
|
|
|
### Explorando Content Providers - Acessando e manipulando informações sensíveis
|
|
|
|
[**Leia isto se você quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\
|
|
Os content providers são basicamente usados para **compartilhar dados**. Se um aplicativo tem content providers disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois eles podem ser vulneráveis.\
|
|
[**Aprenda a explorar Content Providers com Drozer.**](drozer-tutorial/#content-providers)
|
|
|
|
### **Explorando Serviços**
|
|
|
|
[**Leia isto se você quiser relembrar o que é um Serviço.**](android-applications-basics.md#services)\
|
|
Lembre-se de 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 está 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 a explorar Serviços com Drozer.**](drozer-tutorial/#services)
|
|
|
|
### **Explorando Broadcast Receivers**
|
|
|
|
[**Leia isto se você quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
|
|
Lembre-se de que as ações de um Broadcast Receiver começam no método `onReceive`.
|
|
|
|
Um broadcast receiver estará esperando por um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\
|
|
[**Aprenda a explorar Broadcast Receivers com Drozer.**](./#exploiting-broadcast-receivers)
|
|
|
|
### **Explorando Schemes / Deep links**
|
|
|
|
Você pode procurar por deep links manualmente, usando ferramentas como MobSF ou scripts como [este](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
|
|
Você pode **abrir** um **scheme** 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]
|
|
```
|
|
_Note que você pode **omitir o nome do pacote** e o celular irá automaticamente chamar o aplicativo que deve abrir aquele 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 App**, vá até a atividade chamada pelo deeplink e procure a função **`onNewIntent`**.
|
|
|
|
 (1) (1) (1).png>)
|
|
|
|
**Informações sensíveis**
|
|
|
|
Sempre que encontrar um deep link, verifique se **não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, pois qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!**
|
|
|
|
**Parâmetros no caminho**
|
|
|
|
Você **deve verificar também se algum deep link está usando um parâmetro dentro do caminho** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
|
|
Note que se você encontrar os endpoints corretos dentro da aplicação, você pode ser capaz de causar um **Open Redirect** (se parte do caminho for usada como nome de domínio), **tomada de conta** (se você puder modificar detalhes de usuários sem token CSRF e o endpoint vulnerável usou 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 de bug bounty interessante](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_).
|
|
|
|
### Proteção Insuficiente da Camada de Transporte
|
|
|
|
* **Falta de Inspeção de Certificado:** Aplicativo Android não verifica a identidade do certificado apresentado a ele. A maioria dos aplicativos ignora os avisos e aceita qualquer certificado autoassinado apresentado. Alguns aplicativos, em vez disso, passam o tráfego por uma conexão HTTP.
|
|
* **Negociação de Handshake Fraca:** Aplicativo e servidor realizam um handshake SSL/TLS, mas usam um conjunto de cifras inseguro, vulnerável a ataques MITM. Assim, qualquer atacante pode facilmente descriptografar essa conexão.
|
|
* **Vazamento de Informações Privadas:** Na maioria das vezes, acontece que os aplicativos fazem autenticação por um canal seguro, mas todas as outras conexões por um canal não seguro. Isso não contribui para a segurança do aplicativo porque dados sensíveis restantes, como cookie de sessão ou dados do usuário, podem ser interceptados por um usuário malicioso.
|
|
|
|
Dos 3 cenários apresentados, vamos discutir **como verificar a identidade do certificado**. Os outros 2 cenários dependem da **configuração TLS** do servidor e se o **aplicativo envia dados não criptografados**. O pentester deve verificar por conta própria a configuração TLS do servidor ([aqui](../../network-services-pentesting/pentesting-web/#ssl-tls-vulnerabilites)) e detectar se qualquer **informação confidencial é enviada por um canal desprotegido/vulnerável**.\
|
|
Mais informações sobre como descobrir e corrigir esses tipos de vulnerabilidades [**aqui**](https://manifestsecurity.com/android-application-security-part-10/).
|
|
|
|
**SSL Pinning**
|
|
|
|
Por padrão, ao fazer uma conexão SSL, o cliente (aplicativo android) verifica se o certificado do servidor tem uma cadeia de confiança verificável de volta a um certificado confiável (raiz) e corresponde ao nome do host solicitado. Isso leva ao problema de **Ataques de Intermediário (MITM)**.\
|
|
No SSL Pinning, um Aplicativo Android contém o certificado do servidor e só transmite dados se o mesmo certificado for apresentado.\
|
|
É recomendado **aplicar SSL Pinning** para os sites onde informações sensíveis serão enviadas.
|
|
|
|
### Inspeção do tráfego HTTP
|
|
|
|
Primeiramente, você deve (obrigatoriamente) **instalar o certificado** da **ferramenta proxy** que você vai usar, provavelmente o Burp. Se você não instalar o certificado CA da ferramenta proxy, provavelmente não conseguirá ver o tráfego criptografado no proxy.\
|
|
**Por favor,** [**leia este guia para aprender como instalar um certificado CA personalizado**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine)**.**
|
|
|
|
Para aplicativos que visam **API Level 24+ não é suficiente instalar o certificado CA do Burp** no dispositivo. Para contornar essa nova proteção, você precisa modificar o arquivo de Configuração de Segurança de Rede. Assim, você pode modificar este arquivo para autorizar seu certificado CA ou pode [**ler esta página para um tutorial sobre como forçar o aplicativo a aceitar novamente todos os certificados instalados no dispositivo**](make-apk-accept-ca-certificate.md).
|
|
|
|
**SSL Pinning**
|
|
|
|
Já discutimos o que é SSL Pinning apenas 2 parágrafos antes. Quando implementado em um aplicativo, você precisará contorná-lo para inspecionar o tráfego HTTPS ou não conseguirá vê-lo.\
|
|
Aqui vou apresentar algumas opções que usei para contornar essa proteção:
|
|
|
|
* Modificar automaticamente o **apk** para **contornar** o SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A melhor vantagem dessa opção é que você não precisará de root para contornar o SSL Pinning, mas precisará deletar o aplicativo e reinstalar o novo, e isso nem sempre funciona.
|
|
* Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui você tem 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 **análise dinâmica do MobSF** (explicado abaixo)
|
|
* Se você ainda acha 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)
|
|
|
|
**Vulnerabilidades Comuns da Web**
|
|
|
|
Note que nesta etapa você deve procurar por vulnerabilidades comuns da web. Muitas informações sobre vulnerabilidades da web podem ser encontradas neste livro, então não vou mencioná-las aqui.
|
|
|
|
### Frida
|
|
|
|
Kit de ferramentas de instrumentação dinâmica para desenvolvedores, engenheiros reversos e pesquisadores de segurança. Saiba mais em [www.frida.re](https://www.frida.re).\
|
|
**É incrível, você pode acessar aplicativos em execução e enganchar métodos em tempo de execução para alterar o comportamento, mudar valores, extrair valores, executar códigos diferentes...**\
|
|
**Se você quer 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 Frida:** [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)\
|
|
**Algumas outras abstrações baseadas no 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 Frida incríveis aqui:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
|
|
|
### **Dump 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 fazer o dump da memória do app com:
|
|
```bash
|
|
# With PID
|
|
python3 fridump3.py -u <PID>
|
|
|
|
# With name
|
|
frida-ps -Uai
|
|
python3 fridump3.py -u "<Name>"
|
|
```
|
|
Este comando irá despejar a memória na pasta ./dump, e lá você poderá usar 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]+$"
|
|
```
|
|
### **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 **dados sensíveis em texto claro**, os pentests devem verificar isso como usuário root ou alguém com acesso físico ao dispositivo poderia ser capaz de roubar esses dados.
|
|
|
|
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/Biométricos**
|
|
|
|
Utilizando o seguinte script Frida, pode ser possível **bypassar a autenticação por impressão digital** que aplicações Android podem estar realizando para **proteger certas áreas sensíveis:**
|
|
|
|
{% code overflow="wrap" %}
|
|
```bash
|
|
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
|
```
|
|
### **Imagens de Fundo**
|
|
|
|
Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando ele for recuperado para o primeiro plano, comece a carregar a imagem antes do aplicativo para parecer que o aplicativo foi carregado mais rapidamente.
|
|
|
|
No entanto, se este instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essas informações** (note que você precisa de root para acessá-lo).
|
|
|
|
Os instantâneos geralmente são armazenados em torno de: **`/data/system_ce/0/snapshots`**
|
|
|
|
O Android oferece 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 exibições não seguras.
|
|
```bash
|
|
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
|
```
|
|
### **Analisador de Aplicações 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 Intent
|
|
|
|
Esta vulnerabilidade se assemelha ao **Open Redirect em segurança web**. Como a classe `Intent` é `Parcelable`, **objetos pertencentes a esta classe** podem ser **passados** como **dados extras** em outro objeto `Intent`.\
|
|
Muitos desenvolvedores fazem **uso** desta **funcionalidade** e criam **componentes proxy** (atividades, receptores de transmissão e serviços) que **recebem um Intent embutido e o passam para métodos perigosos** como `startActivity(...)`, `sendBroadcast(...)`, etc.\
|
|
Isso é perigoso porque **um atacante pode forçar o aplicativo a lançar um componente não-exportado que não pode ser iniciado diretamente de outro aplicativo**, ou conceder ao atacante acesso aos seus provedores de conteúdo. **`WebView`** também às vezes converte uma **URL de uma string para um objeto `Intent`**, usando o método `Intent.parseUri(...)`, e o passa para `startActivity(...)`.
|
|
|
|
### Injeções no Lado do Cliente Android e outros
|
|
|
|
Provavelmente você já conhece esse tipo de vulnerabilidades da Web. Você tem que ter um cuidado especial com essas vulnerabilidades em um aplicativo Android:
|
|
|
|
* **SQL Injection:** Ao lidar com consultas dinâmicas ou Content-Providers, certifique-se de que está usando consultas parametrizadas.
|
|
* **JavaScript Injection (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para qualquer WebView (desativado por padrão). [Mais informações aqui](webview-attacks.md#javascript-enabled).
|
|
* **Local File Inclusion:** Verifique se o Acesso ao Sistema de Arquivos está desativado para qualquer WebView (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 termina a sessão, o cookie não é revogado ou pode até ser salvo no disco
|
|
* [**Secure Flag** em cookies](../../pentesting-web/hacking-with-cookies/#cookies-flags)
|
|
|
|
***
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (3) (1).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!
|
|
|
|
**Insights 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 através de notícias e insights em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado com os mais novos bounties de bugs lançados e atualizações cruciais da 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**
|
|
|
|
.png>)
|
|
|
|
**Avaliação de vulnerabilidade da aplicação** usando uma interface web amigá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) (aplicações do Windows devem ser analisadas 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á para a pasta raiz do aplicativo, selecione tudo e crie um arquivo ZIP), ele também será capaz de analisá-lo.
|
|
|
|
O MobSF também permite que você **diff/Compare** análises e integre o **VirusTotal** (você precisará configurar sua chave de API em _MobSF/settings.py_ e ativá-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á **upload** em vez do arquivo.
|
|
|
|
### Análise Dinâmica Assistida com MobSF
|
|
|
|
O **MobSF** também pode ser muito útil para **análise dinâmica** em **Android**, mas nesse caso você precisará instalar o MobSF e o **genymotion** em seu host (uma VM ou Docker não funcionará). _Nota: Você precisa **iniciar primeiro uma VM no genymotion** e **depois o MobSF.**_
|
|
O **analisador dinâmico MobSF** pode:
|
|
|
|
* **Dump de dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas pelo "**Exported Activity Tester**", emails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
|
|
* Capturar tráfego **HTTPS**
|
|
* Usar **Frida** para obter **informações em tempo de execução**
|
|
|
|
A partir das **versões do Android > 5**, ele **iniciará automaticamente o Frida** e configurará as definições de **proxy** globais para **capturar** tráfego. Ele só capturará tráfego do aplicativo testado.
|
|
|
|
**Frida**
|
|
|
|
Por padrão, ele também usará alguns Scripts Frida para **bypass SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
|
|
O MobSF também pode **invocar atividades exportadas**, capturar **screenshots** delas e **salvar** para o relatório.
|
|
|
|
Para **iniciar** o teste dinâmico, pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts Frida e "**Live API Monitor**" para ver todas as invocações de métodos enganchados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
|
|
O MobSF também permite que você carregue seus próprios **scripts Frida** (para enviar os resultados dos seus scripts Frida 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 "**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**: Ele imprimirá todas as classes carregadas
|
|
* **Capture Strings**: Ele imprimirá todas as strings capturadas enquanto usa o aplicativo (muito barulhento)
|
|
* **Capture String Comparisons**: Pode ser muito útil. Ele **mostrará as 2 strings sendo comparadas** e se o resultado foi Verdadeiro ou Falso.
|
|
* **Enumerate Class Methods**: Coloque o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
|
|
* **Search Class Pattern**: Pesquisar classes por padrão
|
|
* **Trace Class Methods**: **Trace** uma **classe inteira** (veja 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 Android.
|
|
|
|
Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Instrumentation**" e verá todas as saídas em "**Frida Live Logs**".
|
|
|
|
**Shell**
|
|
|
|
O MobSF também oferece um shell com alguns comandos **adb**, comandos **MobSF** e comandos comuns de **shell** 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 visão desagradável do tráfego capturado em "**HTTP(S) Traffic**" na parte inferior ou uma visão mais agradável em "**Start HTTPTools**" no botão verde. A partir da segunda opção, você pode **enviar** as **solicitações capturadas** para **proxies** como Burp ou Owasp ZAP.\
|
|
Para fazer isso, _ative 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.0.1:8080)).
|
|
|
|
Uma vez que você terminar a análise dinâmica com o MobSF, você pode pressionar em "**Start Web API Fuzzer**" para **fuzzar solicitações http** e procurar por vulnerabilidades.
|
|
|
|
{% hint style="info" %}
|
|
Após realizar uma análise dinâmica com o MobSF, as configurações de proxy podem estar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações de proxy fazendo:
|
|
```
|
|
adb shell settings put global http_proxy :0
|
|
```
|
|
{% endhint %}
|
|
|
|
### Análise Dinâmica Assistida com Inspeckage
|
|
|
|
Você pode obter a ferramenta de [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
|
Esta ferramenta usa alguns **Hooks** para informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**.
|
|
|
|
{% content-ref url="inspeckage-tutorial.md" %}
|
|
[inspeckage-tutorial.md](inspeckage-tutorial.md)
|
|
{% endcontent-ref %}
|
|
|
|
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
|
|
|
Esta é uma **ótima ferramenta para realizar análise estática com uma GUI**
|
|
|
|
.png>)
|
|
|
|
### [Qark](https://github.com/linkedin/qark)
|
|
|
|
Esta ferramenta é projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **código-fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um APK "Prova-de-Conceito" implantável** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Atividades expostas, intents, tapjacking...). Assim como com Drozer, não é necessário ter 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)
|
|
|
|
* Exibe todos os arquivos extraídos para fácil referência
|
|
* Decompila automaticamente arquivos APK para os formatos Java e Smali
|
|
* Analisa AndroidManifest.xml para vulnerabilidades comuns e comportamento
|
|
* Análise estática do código-fonte para vulnerabilidades comuns e comportamento
|
|
* Informações do dispositivo
|
|
* Intents
|
|
* Execução de comandos
|
|
* Referências SQLite
|
|
* Referências de logs
|
|
* Provedores de conteúdo
|
|
* Receptores de transmissão
|
|
* Referências de serviços
|
|
* Referências de arquivos
|
|
* Referências criptográficas
|
|
* Segredos codificados
|
|
* URL's
|
|
* Conexões de rede
|
|
* Referências SSL
|
|
* Referências WebView
|
|
```
|
|
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 no Windows, MacOS X e Linux, que analisa arquivos _.apk_ em busca de vulnerabilidades. Ele faz isso descomprimindo APKs e aplicando uma série de regras para detectar essas vulnerabilidades.
|
|
|
|
Todas as regras estão centradas em um arquivo `rules.json`, e cada empresa ou testador poderia criar suas próprias regras para analisar o que precisam.
|
|
|
|
Baixe os últimos binários na [página de download](https://superanalyzer.rocks/download.html)
|
|
```
|
|
super-analyzer {apk_file}
|
|
```
|
|
### [StaCoAn](https://github.com/vincentcox/StaCoAn)
|
|
|
|
.png>)
|
|
|
|
StaCoAn é uma ferramenta **crossplatform** que auxilia desenvolvedores, caçadores de recompensas por bugs e hackers éticos a realizar [análise de código estático](https://en.wikipedia.org/wiki/Static\_program\_analysis) em aplicações móveis\*.
|
|
|
|
O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela 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)
|
|
|
|
AndroBugs Framework é um sistema de análise de vulnerabilidades Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
|
|
[Lançamentos para Windows](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 comportamentos potencialmente 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 aplicações "ruins"** como: Exfiltração de identificadores de telefonia, Intercepçã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
|
|
```
|
|
### [MARA Framework](https://github.com/xtiankisutsa/MARA_Framework)
|
|
|
|
.png>)
|
|
|
|
**MARA** é um **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para engenharia reversa e análise de aplicações móveis, para auxiliar no teste de aplicações 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 aplicações 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 Manifesto.
|
|
* 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)
|
|
|
|
## Ofuscação/Desofuscação de código
|
|
|
|
Note que, dependendo do serviço e configuração que você usar para ofuscar o código, os segredos podem ou não acabar ofuscados.
|
|
|
|
### [ProGuard](https://en.wikipedia.org/wiki/ProGuard_(software))
|
|
|
|
**ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode, bem como detectar e remover instruções não utilizadas. ProGuard é um software livre e é 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 no modo de lançamento.
|
|
|
|
De: [https://en.wikipedia.org/wiki/ProGuard_(software)](https://en.wikipedia.org/wiki/ProGuard_(software))
|
|
|
|
### [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)
|
|
|
|
(Desse guia) A última vez que verificamos, o modo de operação do Dexguard era:
|
|
|
|
* carregar um recurso como um InputStream;
|
|
* alimentar o resultado a uma classe que herda de FilterInputStream para descriptografá-lo;
|
|
* fazer alguma ofuscação inútil para desperdiçar alguns minutos do tempo de um reversor;
|
|
* alimentar o resultado descriptografado a 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 ofuscação Android. Isso permite várias 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 se comporte de forma idêntica, mas seja mais fácil de entender por um humano. 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**. Identifica muitos **compiladores**, **empacotadores**, **ofuscadores** e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
|
|
|
|
### Manual
|
|
|
|
[Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação personalizada**](manual-deobfuscation.md)
|
|
|
|
## Laboratórios
|
|
|
|
### [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 laboratórios de diferentes geeks de segurança e pesquisadores para engenharia reversa e análise de malware.
|
|
|
|
### OWASP
|
|
|
|
{% embed url="https://github.com/OWASP/owasp-mstg%0Ahttps://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06g-testing-network-communication" %}
|
|
|
|
### Repositórios Git
|
|
|
|
[https://github.com/riddhi-shree/nullCommunity/tree/master/Android](https://github.com/riddhi-shree/nullCommunity/tree/master/Android)\
|
|
[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)
|
|
|
|
## Referências
|
|
|
|
Para mais informações, visite:
|
|
|
|
* [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)
|
|
|
|
## Para Testar
|
|
|
|
* [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 (1) (3) (1).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!
|
|
|
|
**Insights 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 através de notícias e insights em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado com os mais novos lançamentos de recompensas por bugs e atualizações cruciais da 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 no 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ê quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
|
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
|
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|