<summary><strong>Aprenda a hackear a AWS do zero ao herói com</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* 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-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
É 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**:
Esta é a principal ferramenta que você precisa para se conectar a um dispositivo Android (emulado ou físico).\
Permite controlar seu dispositivo por **USB** ou **Rede** a partir de um computador, **copiar** arquivos de ida e volta, **instalar** e desinstalar aplicativos, executar comandos **shell**, realizar **backups**, ler **logs** e muito mais.
À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, **mantenha sempre em mente essa possibilidade**.
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).
Preste 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)
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**.\
* Primeiramente, verifique se **o aplicativo é depurável**. Um APK de produção não deve ser (ou outros poderão se conectar a ele). Você pode verificar se um aplicativo é 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 aplicativos depuráveis em um telefone e explorá-los
* **Backup**: O atributo **`android:allowBackup`** define se os dados do aplicativo podem ser salvos e restaurados por um usuário que habilitou a depuração USB. Se a flag de backup estiver definida como true, permite que um atacante faça o backup dos dados do aplicativo via adb mesmo que o dispositivo não esteja rooteado. Portanto, aplicativos que lidam e armazenam informações sensíveis como detalhes de cartão, senhas etc. devem ter essa configuração explicitamente definida como **false** porque por padrão é definida como **true** para evitar tais riscos.
* **NetworkSecurity:** A segurança de rede do aplicativo pode sobrescrever os valores padrão com **`android:networkSecurityConfig="@xml/network_security_config"`**. Um arquivo com esse nome pode ser colocado em _**res/xml.**_ Este arquivo configurará configurações de segurança importantes como pins 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:
* **Atividades Exportadas**: Verifique as atividades exportadas no manifesto, pois isso pode ser perigoso. Mais tarde 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 estiver 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).
* **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 em que o aplicativo será executado. É importante mantê-los 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.
**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 **cega o usuário de saber que está realmente realizando ações no aplicativo vítima**.
Uma **atividade** com o **`launchMode`** definido como **`singleTask` sem nenhuma `taskAffinity`** definida é vulnerável ao sequestro de tarefas. 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 real**).
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á **definido 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.
### Diretrizes para Gerenciar Arquivos no 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, certifique-se de 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.
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.
* **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.
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:
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.
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.
* É 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 está sendo usado um **emulador**.
* 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.
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**.
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.
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)
> 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 com root (emulado ou não) é extremamente recomendado.
Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io). Essa plataforma permite que você **faça upload** e **execute** APKs, sendo útil para ver como um APK está se comportando.
* [**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** versões **suportam bibliotecas ARM** sem precisar de um emulador ARM lento).
* [**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._)
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.
Além disso, observe que na **configuração da VM Android no Genymotion** você pode selecionar o **modo de rede Bridge** (isso será útil se você for conectar à VM Android de uma VM diferente com as ferramentas).
> 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.\
> 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.
Frequentemente, os desenvolvedores deixam informações de depuração publicamente. Portanto, qualquer aplicativo com permissão `READ_LOGS` pode **acessar esses logs** e obter informações sensíveis por meio deles.\
Ao navegar 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**.
Observe que a partir das **versões posteriores ao Android 4.0**, **os aplicativos só podem acessar seus próprios logs**. Portanto, os aplicativos não podem acessar os logs de outros aplicativos.\
O Android fornece um **framework baseado em área de transferência** para fornecer a função de cópia/colagem em aplicativos Android. Mas isso cria um problema sério quando algum **outro aplicativo** pode **acessar** a **área de transferência** que contém alguns dados sensíveis. A função de **cópia/colagem** deve ser **desativada** para a **parte sensível** do aplicativo. Por exemplo, desative a cópia de detalhes do cartão de crédito.
Se um aplicativo **falhar** durante a execução e salvar logs em algum lugar, esses logs podem ser úteis para um atacante, especialmente nos casos em que o aplicativo Android não pode ser engenhado reversamente. Em seguida, evite criar logs quando os aplicativos falham e, se os logs forem enviados pela rede, certifique-se de que sejam enviados por um canal SSL.\
Como testador de penetração, **tente dar uma olhada nesses logs**.
A maioria dos aplicativos usa outros serviços em seus aplicativos, como o Google AdSense, mas às vezes eles **vazam alguns dados sensíveis** ou dados que não precisam ser enviados para esse serviço. Isso pode acontecer porque o desenvolvedor não implementou o recurso corretamente. Você pode **verificando a interceptação do tráfego** do aplicativo e ver se algum dado sensível está sendo enviado para terceiros ou não.
A maioria dos aplicativos usará **bancos de dados SQLite internos** para salvar informações. Durante o teste de penetração, 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/bancos de dados`
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**.
**Drozer** permite que você **assuma o papel de um aplicativo Android** e interaja com outros aplicativos. Ele pode fazer **qualquer coisa que um aplicativo instalado possa fazer**, como fazer uso do mecanismo de Comunicação entre Processos (IPC) do Android e interagir com o sistema operacional subjacente. Do [Guia do 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 seções a seguir.
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.\
**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).
**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.
Se o tapjacking não for prevenido, você poderia 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).
[**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)
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)
Você pode procurar links profundos 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**:
Sempre que encontrar um deep link, 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 deep link e roubar esses dados!**
Você **também deve verificar se algum deep link 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 usada como nome de domínio), **assumir o controle da conta** (se puder modificar detalhes dos 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/).
* **Falta de Inspeção de Certificado:** O aplicativo Android falha em verificar 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 Aperto de Mão Fraca:** Aplicativo e servidor realizam um aperto de mão SSL/TLS, mas usam uma suíte de cifras insegura que é vulnerável a ataques MITM. Assim, qualquer atacante pode facilmente descriptografar essa conexão.
* **Vazamento de Informações de Privacidade:** Na maioria das vezes, acontece que os aplicativos fazem autenticação por meio de um canal seguro, mas todas as outras conexões por meio de um canal não seguro. Isso não adiciona segurança ao aplicativo, pois outros dados sensíveis, 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 do TLS** do servidor e se o **aplicativo envia dados não criptografados**. O testador deve verificar por conta própria a configuração do TLS do servidor ([aqui](../../network-services-pentesting/pentesting-web/#ssl-tls-vulnerabilites)) e detectar se alguma **informação confidencial é enviada por um canal não criptografado/vulnerável**.\
Mais informações sobre como descobrir e corrigir esse tipo de vulnerabilidades [**aqui**](https://manifestsecurity.com/android-application-security-part-10/).
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 até um certificado confiável (raiz) e corresponde ao nome do host solicitado. Isso leva ao problema de **Ataques Man-in-the-Middle (MITM)**.\
No Pinning de certificado, um aplicativo Android contém o certificado do servidor e só transmite dados se o mesmo certificado for apresentado.\
É recomendável **aplicar o SSL Pinning** para os sites onde informações sensíveis serão enviadas.
Antes de tudo, você deve (deve) **instalar o certificado** da **ferramenta de proxy** que você vai usar, provavelmente o Burp. Se você não instalar o certificado CA da ferramenta de proxy, provavelmente não 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 direcionados ao **Nível de API 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. Portanto, 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).
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 o verá.\
* **Modificar automaticamente** o **apk** para **contornar** o SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem dessa opção é que você não precisará de root para contornar o SSL Pinning, mas precisará excluir o aplicativo e reinstalar o novo, e isso nem sempre funcionará.
* Você pode usar o **Frida** (discutido abaixo) para contornar essa proteção. Aqui está um guia para usar Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
* 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)
Observe que nesta etapa você deve procurar por vulnerabilidades web comuns. Muitas informações sobre vulnerabilidades web podem ser encontradas neste livro, então não vou mencioná-las aqui.
Ferramenta 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 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.**
**Algum "GUI" para ações com o 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)\
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 poderia roubar esses dados.
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)
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:**
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 a ele poderá **roubar essas informações** (observe que é necessário ter acesso root para acessá-lo).
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.
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)
Essa vulnerabilidade se assemelha ao **Redirecionamento Aberto na segurança web**. Como a classe `Intent` é `Parcelable`, **objetos pertencentes a essa classe** podem ser **passados** como **dados extras** em outro objeto `Intent`.\
Muitos desenvolvedores fazem **uso** desse **recurso** e criam **componentes proxy** (atividades, receptores de transmissão e serviços) que **recebem um Intent incorporado e o passam para métodos perigosos** como `startActivity(...)`, `sendBroadcast(...)`, etc.\
Isso é perigoso porque **um atacante pode forçar o aplicativo a iniciar um componente não exportado que não pode ser iniciado diretamente por outro aplicativo**, ou conceder ao atacante acesso aos seus provedores de conteúdo. **`WebView`** às vezes também altera um **URL de uma string para um objeto `Intent`**, usando o método `Intent.parseUri(...)`, e o passa para `startActivity(...)`.
* **Injeção de SQL:** Ao lidar com consultas dinâmicas ou Content-Providers, 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:** Verifique se o Acesso ao Sistema de Arquivos está desativado para quaisquer WebViews (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)
**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).
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 do 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), o MobSF também poderá analisá-lo.
O MobSF também permite que você faça a **diferença/comparação** da análise 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.
O **MobSF** também pode ser muito útil para a **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). _Observação: Você precisa **iniciar primeiro uma VM no genymotion** e **depois o MobSF.**_\
* **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.
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** o teste dinâmico, 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 carregar 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**").
* **Enumerar Classes Carregadas**: Ele imprimirá todas as classes carregadas
* **Capturar Strings**: Ele imprimirá todas as strings capturadas ao usar o aplicativo (muito ruidoso)
* **Capturar Comparação de Strings**: 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**".
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:
Quando o tráfego http é capturado, você pode ver uma visualização feia do tráfego capturado no fundo "**HTTP(S) Traffic**" ou uma visualização mais agradável no fundo 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.
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:
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.
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.
StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, caçadores de bugs e hackers éticos na realização de [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.
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.\
[Releases para Windows](https://github.com/AndroBugs/AndroBugs\_Framework/releases)
**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...
**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.
**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.
**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.**
É 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 obfuscação usado.
APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muitos **compiladores**, **empacotadores**, **obfuscadores** e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
AndroL4b é uma máquina virtual de segurança Android baseada no ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e laboratórios de diferentes geeks de segurança e pesquisadores para engenharia reversa e análise de malware.
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* 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 [**The PEASS Family**](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 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.
