hacktricks/mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md

# Explorando uma aplicação depurável

<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 do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

## **Burlando verificações de root e depurável**

**Esta seção do post é um resumo do post** [**https://medium.com/@shubhamsonani/hacking-with-precision-bypass-techniques-via-debugger-in-android-apps-27fd562b2cc0**](https://medium.com/@shubhamsonani/hacking-with-precision-bypass-techniques-via-debugger-in-android-apps-27fd562b2cc0)

### Tornar o app depurável e executá-lo aguardando um depurador

Passo 1 — Decompilar o APK usando a ferramenta APK-GUI. Editar o arquivo _android-manifest_ e adicionar _**android:debuggable=true**,_ para tornar a aplicação depurável. Recompilar, assinar e alinhar o aplicativo com zipalign.

Passo 2 — Instalar a aplicação via -

_**adb install \<nome_da_aplicação>**._

Passo 3 — Obter o nome do pacote usando _-_

_**adb shell pm list packages –3**_ (para listar as aplicações de terceiros).

Passo 4 — Agora faça a aplicação aguardar pelo depurador através deste comando — _**adb shell am setup-debug-app –w \<nome_do_pacote>**_.

**Nota —** Você precisará executar este comando todas as vezes, antes de iniciar a aplicação, para que a aplicação aguarde pelo depurador.

Para torná-lo persistente, você pode usar –

_**adb shell am setup-debug-app –w -–persistent \<nome_do_pacote>**._

Para limpar todas as flags –

_**adb shell am clear-debug-app \<nome_do_pacote>**._

Passo 5 — Abrir o _**Android Studio -> File -> Open Profile or APK**_ -> Abrir o APK recompilado.

Passo 6 — Adicionar pontos de interrupção aos arquivos java

* _**MainActivity.java — método onCreate, b.java, ContextWrapper.java**_

### Burlar verificações

Em algum momento, o app obterá informações sobre o app para verificar se é depurável e também procurará por alguns binários para ver se o celular está com root. Usando o depurador, é possível alterar as informações do app para desmarcar o bit depurável e também mudar os nomes dos binários procurados, de modo que essas verificações sejam burladas. Por exemplo, para a verificação de depurável:

Passo 1 — Na seção de variáveis do console do depurador, navegue até "_**this mLoadedAPK -> mApplicationInfo -> flags = 814267974**_"

<figure><img src="https://miro.medium.com/v2/resize:fit:1400/1*-ckiSbWGSoc1beuxxpKbow.png" alt="" height="192" width="700"><figcaption><p>captura de tela 9</p></figcaption></figure>

_**Nota: flags = 814267974 em bits binários é 11000011100111011110. Isso significa que “Flag_debuggable” está definido.**_

Passo 2 — Alterar o valor da flag para 814267972. Conversão de bits binários — 110000101101000000100010100.

## **Explorando uma vulnerabilidade**

**A parte seguinte do post foi copiada de** [**https://resources.infosecinstitute.com/android-hacking-security-part-6-exploiting-debuggable-android-applications/#article**](https://resources.infosecinstitute.com/android-hacking-security-part-6-exploiting-debuggable-android-applications/#article)

Para tornar este artigo mais interessante, desenvolvi uma aplicação vulnerável para fins de demonstração, que possui um “**botão**” e um “**textview**“.

Preencha o formulário abaixo para baixar o código associado a este artigo.

Se lançarmos a aplicação, ela mostra a mensagem “**Crack Me**“.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack1.png)

Figura 1

Se clicarmos no botão, ele diz “**Tente Novamente**“. Agora, nosso objetivo é mudar a mensagem “Tente Novamente” para “Hackeado” sem modificar o código-fonte da aplicação. Para ser preciso, temos que mudá-lo em tempo de execução.

### **Ferramentas necessárias**

* Emulador
* adb – Android Debug Bridge
* jdb – Java Debugger

No meu caso, para facilitar as instalações, estou usando o Android Tamer, pois todas as ferramentas acima necessárias já estão pré-instaladas.

### **Tópicos envolvidos**

* Verificação de Vulnerabilidade.
* Preparando-se com a Configuração.
* Injeção de Código em Tempo de Execução.

Vamos começar o jogo.

### **Verificação de vulnerabilidade**

Na verdade, esta é a parte mais fácil de todo o artigo.

* Decompilar a aplicação usando `apktool` para obter o arquivo `AndroidManifest.xml` usando o seguinte comando.
```bash
apktool d <vulnerableapp>.apk
```
* Inspecione o arquivo `Androidmanifest.xml` para a seguinte linha.
```bash
android_debuggable="true"
```
Se você encontrar a linha acima no arquivo AndroidManifest.xml, a aplicação é depurável e pode ser explorada.

**Nota:** Usamos `apktool` para verificar se o aplicativo é depurável ou não. Não vamos tocar ou modificar nenhum trecho de código, como mencionado anteriormente.

### **Preparando o ambiente**

Nesta etapa, vamos configurar tudo o que é necessário para injetar código no aplicativo durante sua execução. Como mencionado no artigo anterior, usaremos depuração remota neste artigo.

* Inicie seu Emulador
* Instale o aplicativo vulnerável
* Abra seu terminal e execute o seguinte comando para ver as portas da Dalvik VM que estão ouvindo no emulador.

_**adb jdwp**_

O comando acima exibe todas as portas nas quais podemos conectar e depurar, conforme mostrado abaixo.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack2.png)

Figura 2

**Nota:** JDWP significa Java Debug Wire Protocol. Se um aplicativo em execução em sua VM é depurável, ele expõe uma porta única na qual podemos nos conectar usando JDB. Isso é possível em Máquinas Virtuais Dalvik com suporte de JDWP.

* Agora, inicie nosso aplicativo alvo e execute o mesmo comando para ver a porta de escuta associada ao nosso aplicativo alvo. Parece como mostrado abaixo.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack3.png)

Figura 2

Se observarmos a diferença entre a Figura 2 e a Figura 3, há uma porta extra 543 ouvindo após o lançamento do aplicativo alvo na Figura 3. Vamos anexar o JDB ao aplicativo usando esta porta, já que este é nosso alvo.

* Antes de anexar ao aplicativo, precisamos encaminhar a porta usando adb, pois estamos usando depuração remota. Isso é mostrado na Figura 4.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack4.png)

Figura 4

* Agora, vamos anexar o JDB ao aplicativo conforme mostrado na figura a seguir.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack5.png)

Figura 5

### **Injeção de código em tempo de execução**

Nesta etapa, vamos realmente explorar o aplicativo vulnerável modificando seu comportamento em tempo de execução.

Para modificar o comportamento do aplicativo em tempo de execução, precisamos configurar pontos de interrupção e controlar o fluxo. Mas, não sabemos quais classes e métodos são usados no aplicativo. Então, vamos usar os seguintes comandos para descobrir as classes e métodos usados no aplicativo.

Para encontrar as classes: “**classes**”

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack6.png)

Figura 6.1

Como tenho muitas classes listadas, estou listando apenas algumas. Mas se você continuar rolando para baixo, verá algumas classes definidas pelo usuário interessantes, conforme mostrado na figura abaixo.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack7.png)

Figura 6.2

Agora, vamos ver os métodos associados à classe MainActivity$1 usando o seguinte comando.

“_**methods com.example.debug.MainActivity$1**_”

Isso é mostrado na figura 7.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack8.png)

Figura 7

Agora, vamos configurar um ponto de interrupção no método onClick e controlar a execução do aplicativo, conforme mostrado na Figura 8.

_**“stop in com.example.debug.MainActivity$1.onClick(android.view.View)”**_

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack9.png)

Figura 8

Para atingir o ponto de interrupção, teremos que clicar manualmente no botão no aplicativo. Uma vez após clicar no botão, o ponto de interrupção será atingido e aparecerá conforme mostrado na Figura 9.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack10.png)

Figura 9

A partir daqui, poderemos controlar e ver os valores sensíveis, argumentos de métodos, etc., usando vários comandos.

Apenas para entender o que está acontecendo nos bastidores, estou seguindo o código associado ao método onClick, que é mostrado na Figura 10.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack11.png)

Figura 10

Antes de prosseguir, vamos ver se há alguma variável local neste ponto usando o comando “**locals**“.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack12.png)

Figura 11

Como podemos ver, não há informações interessantes para nós.

Então, vamos executar a próxima linha usando o comando “**next**”, conforme mostrado abaixo.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack13.png)

Figura 12

Vamos tentar executar o comando “**locals**” novamente para ver o que aconteceu no comando anterior.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack14.png)

Figura 13

Está bastante claro que TextView foi carregado nos argumentos do método. Se olharmos para o código-fonte fornecido na Figura 10, a linha associada à instanciação do TextView foi executada.

Vamos agora executar as próximas linhas executando o comando “**next**” e verificar as variáveis locais, conforme mostrado na figura abaixo.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack15.png)

Figura 14

Como podemos ver, todas as variáveis locais foram exibidas. A string “**secret**” parece interessante. O valor “Try Again” é o que vai ser impresso quando clicarmos no botão.

Da Figura 10, está muito claro que o método **setText** está sendo executado para imprimir o valor “**Try Again**“. Então, vamos usar o comando “**step**” para entrar na definição do método “**setText**” e modificar dinamicamente o texto a ser impresso.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack16.png)

Figura 15

Vamos ver as variáveis locais dentro da definição usando “**locals**“.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack17.png)

Figura 16

Agora, vamos mudar o valor de “**text**” de “**Try Again**” para “**Hacked**” usando o comando “**set**”.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack18.png)

Figura 17

Não podemos ver nenhuma mudança no aplicativo, pois ainda não executamos o código modificado.

Então, vamos executar o aplicativo usando o comando “**run**”, conforme mostrado abaixo, e ver a saída do aplicativo em sua tela.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack19.png)

Figura 18

Vamos olhar para o aplicativo em execução no emulador.

![](https://resources.infosecinstitute.com/wp-content/uploads/052314_1204_AndroidHack20.png)

Figura 19

Modificamos com sucesso a saída do aplicativo em tempo de execução. Este é apenas um exemplo para mostrar como o comportamento de um aplicativo pode ser modificado se o aplicativo for depurável. Podemos realizar várias outras coisas, incluindo “**Obter um shell**” no dispositivo no contexto do aplicativo vulnerável.

<details>

<summary><strong>Aprenda AWS hacking 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ê quiser 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 de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**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** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.

</details>