Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-24 13:43:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md

14 KiB
Raw Blame History

Explorando uma aplicação depurável

Aprenda hacking no AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras formas de apoiar o HackTricks:

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

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"

captura de tela 9

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

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“.

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.
apktool d <vulnerableapp>.apk
  • Inspecione o arquivo Androidmanifest.xml para a seguinte linha.
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.

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.

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.

Figura 4

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

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”

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.

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.

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)”

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.

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.

Figura 10

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

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.

Figura 12

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

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.

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.

Figura 15

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

Figura 16

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

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.

Figura 18

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

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.

Aprenda AWS hacking do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks: