AVD - Android Virtual Device

Reading time: 11 minutes

Muito obrigado a @offsecjay pela ajuda na criação deste conteúdo.

O que é

Android Studio permite executar máquinas virtuais do Android que você pode usar para testar APKs. Para usá-las você vai precisar:

• Os Android SDK tools - Download here.
• Ou Android Studio (com Android SDK tools) - Download here.

No Windows (no meu caso) após instalar o Android Studio eu tinha as SDK Tools instaladas em: C:\Users\<UserName>\AppData\Local\Android\Sdk\tools

No mac você pode baixar os SDK tools e colocá-los no PATH executando:

brew tap homebrew/cask
brew install --cask android-sdk

Ou a partir da GUI do Android Studio como indicado em https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a que irá instalá-los em ~/Library/Android/sdk/cmdline-tools/latest/bin/ and ~/Library/Android/sdk/platform-tools/ and ~/Library/Android/sdk/emulator/

Para os problemas com Java:

export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home

GUI

Preparar Máquina Virtual

Se você instalou o Android Studio, pode simplesmente abrir a vista principal do projeto e acessar: Tools --> AVD Manager.

Então, clique em Create Virtual Device

selecione o telefone que deseja usar e clique em Next.

warning

Se você precisa de um telefone com Play Store instalado, selecione um que tenha o ícone do Play Store!

Na vista atual você poderá selecionar e baixar a imagem Android que o telefone irá executar:

Então, selecione-a e, se não estiver baixada, clique no símbolo Download ao lado do nome (agora espere até que a imagem seja baixada).
Uma vez que a imagem esteja baixada, apenas selecione Next e Finish.

A máquina virtual será criada. Agora toda vez que você acessar o AVD manager ela estará presente.

Executar Máquina Virtual

Para executá-la basta pressionar o Start button.

Ferramenta de linha de comando

Antes de tudo você precisa decidir qual telefone deseja usar, para ver a lista de telefones possíveis execute:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device

d: 0 or "automotive_1024p_landscape"
Name: Automotive (1024p landscape)
OEM : Google
Tag : android-automotive-playstore
---------
id: 1 or "Galaxy Nexus"
Name: Galaxy Nexus
OEM : Google
---------
id: 2 or "desktop_large"
Name: Large Desktop
OEM : Google
Tag : android-desktop
---------
id: 3 or "desktop_medium"
Name: Medium Desktop
OEM : Google
Tag : android-desktop
---------
id: 4 or "Nexus 10"
Name: Nexus 10
OEM : Google
[...]

Depois de decidir o nome do dispositivo que você quer usar, você precisa decidir qual imagem Android você quer executar neste dispositivo.
Você pode listar todas as opções usando sdkmanager:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list

E faça o download do(s) que você quer usar com:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"

Depois de ter baixado a imagem Android que deseja usar, você pode listar todas as imagens Android baixadas com:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target
----------
id: 1 or "android-28"
Name: Android API 28
Type: Platform
API level: 28
Revision: 6
----------
id: 2 or "android-29"
Name: Android API 29
Type: Platform
API level: 29
Revision: 4

Neste momento você decidiu o dispositivo que quer usar e baixou a imagem do Android, então você pode criar a máquina virtual usando:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X"

No último comando criei uma VM chamada "AVD9" usando o dispositivo "Nexus 5X" e a imagem Android "system-images;android-28;google_apis;x86_64".
Agora você pode listar as máquinas virtuais que criou com:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd

Name: AVD9
Device: Nexus 5X (Google)
Path: C:\Users\cpolo\.android\avd\AVD9.avd
Target: Google APIs (Google Inc.)
Based on: Android API 28 Tag/ABI: google_apis/x86_64

The following Android Virtual Devices could not be loaded:
Name: Pixel_2_API_27
Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd
Error: Google pixel_2 no longer exists as a device

Run Virtual Machine

Já vimos como você pode listar as máquinas virtuais criadas, mas você também pode listá-las usando:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds
AVD9
Pixel_2_API_27

Você pode simplesmente executar qualquer máquina virtual criada usando:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9"

Ou, usando opções mais avançadas, você pode executar uma máquina virtual como:

C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system

Opções de linha de comando

No entanto, existem muitas opções úteis de linha de comando diferentes que você pode usar para iniciar uma máquina virtual. Abaixo você pode encontrar algumas opções interessantes mas pode find a complete list here

Inicialização

• -snapshot name : Iniciar um snapshot da VM
• -snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img : Listar todos os snapshots registrados

Rede

• -dns-server 192.0.2.0, 192.0.2.255 : Permite indicar, separados por vírgula, os servidores DNS para a VM.
• -http-proxy 192.168.1.12:8080 : Permite indicar um proxy HTTP a ser usado (muito útil para capturar o tráfego usando Burp)
• If the proxy settings aren't working for some reason, try to configure them internally or using an pplication like "Super Proxy" or "ProxyDroid".
• -netdelay 200 : Define a emulação de latência de rede em milissegundos.
• -port 5556 : Define o número da porta TCP usada para o console e o adb.
• -ports 5556,5559 : Define as portas TCP usadas para o console e o adb.
• -tcpdump /path/dumpfile.cap : Captura todo o tráfego em um arquivo

Sistema

• -selinux {disabled|permissive} : Define o módulo de segurança Security-Enhanced Linux para o modo 'disabled' ou 'permissive' em um sistema operacional Linux.
• -timezone Europe/Paris : Define o fuso horário para o dispositivo virtual
• -screen {touch(default)|multi-touch|o-touch} : Define o modo de tela sensível ao toque emulado.
• -writable-system : Use esta opção para ter uma imagem do sistema gravável durante sua sessão de emulação. Você também precisará executar adb root; adb remount. Isso é muito útil para instalar um novo certificado no sistema.

Configuração da CLI no Linux (SDK/AVD quickstart)

As ferramentas oficiais de CLI facilitam a criação de emuladores rápidos e depuráveis sem o Android Studio.

# Directory layout
mkdir -p ~/Android/cmdline-tools/latest

# Download commandline tools (Linux)
wget https://dl.google.com/android/repository/commandlinetools-linux-13114758_latest.zip -O /tmp/cmdline-tools.zip
unzip /tmp/cmdline-tools.zip -d ~/Android/cmdline-tools/latest
rm /tmp/cmdline-tools.zip

# Env vars (add to ~/.bashrc or ~/.zshrc)
export ANDROID_HOME=$HOME/Android
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH

# Install core SDK components
sdkmanager --install "platform-tools" "emulator"

# Install a debuggable x86_64 system image (Android 11 / API 30)
sdkmanager --install "system-images;android-30;google_apis;x86_64"

# Create an AVD and run it with a writable /system & snapshot name
avdmanager create avd -n PixelRootX86 -k "system-images;android-30;google_apis;x86_64" -d "pixel"
emulator -avd PixelRootX86 -writable-system -snapshot PixelRootX86_snap

# Verify root (debuggable images allow `adb root`)
adb root
adb shell whoami  # expect: root

Notas

• Variedades de imagem do sistema: google_apis (depurável, permite adb root), google_apis_playstore (não permite root), aosp/default (leve).
• Tipos de build: userdebug frequentemente permite adb root em imagens com suporte a depuração. As imagens Play Store são builds de produção e bloqueiam o root.
• Em hosts x86_64, a emulação de sistema completo ARM64 não é suportada a partir da API 28+. Para Android 11+ use imagens Google APIs/Play que incluem tradução por aplicativo de ARM para x86 para executar muitos apps apenas ARM rapidamente.

Snapshots pelo CLI

# Save a clean snapshot from the running emulator
adb -s emulator-5554 emu avd snapshot save my_clean_setup

# Boot from a named snapshot (if it exists)
emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup

ARM→x86 binary translation (Android 11+)

Google APIs e Play Store images no Android 11+ podem traduzir binários de apps ARM por processo enquanto mantêm o resto do sistema nativo x86/x86_64. Isso costuma ser rápido o suficiente para testar muitos apps ARM-only no desktop.

Dica: Prefira imagens Google APIs x86/x86_64 durante pentests. Imagens Play são convenientes, mas bloqueiam adb root; use-as apenas quando você realmente precisar de Play services e aceitar a falta de root.

Rooting a Play Store device

Se você baixou um dispositivo com Play Store, você não vai conseguir obter root diretamente, e você receberá esta mensagem de erro

$ adb root
adbd cannot run as root in production builds

Using rootAVD with Magisk consegui fazer root no dispositivo (siga por exemplo este vídeo ou este).

Install Burp Certificate

Confira a página a seguir para aprender como instalar um certificado CA personalizado:

Install Burp Certificate

Nice AVD Options

Take a Snapshot

Você pode usar a GUI para tirar um snapshot da VM a qualquer momento:

Referências

• Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa
• Android Emulator command line
• Run ARM apps on the Android Emulator (x86 translation)