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ê precisará:

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

No Windows (no meu caso) após instalar o Android Studio eu tive os SDK Tools instalados 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 os instalará em ~/Library/Android/sdk/cmdline-tools/latest/bin/ e ~/Library/Android/sdk/platform-tools/ e ~/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 visualização principal do projeto e acessar: Tools --> AVD Manager.

Em seguida, clique em Create Virtual Device

selecione o telefone que deseja usar e clique em Next.

warning

Se precisar de um telefone com Play Store instalado selecione um que tenha o ícone do Play Store!

Na visualização atual você poderá selecionar e baixar a imagem do Android que o telefone vai executar:

Então, selecione-a e, se não estiver baixada, clique no símbolo Download ao lado do nome (agora aguarde até que a image seja baixada).
Uma vez que a image 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 possíveis telefones 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 baixe o(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 do Android que você quer 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ê já decidiu qual dispositivo quer usar e já baixou a imagem 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

Executar Máquina Virtual

Já vimos como 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 que você pode usar para iniciar uma máquina virtual. Abaixo você encontra algumas opções interessantes, mas pode encontrar a lista completa aqui

Inicialização

• -snapshot name : Inicia snapshot da VM
• -snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img : Lista todos os snapshots gravados

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)
• Se as configurações de proxy não estiverem funcionando por algum motivo, tente configurá-las internamente ou usando um aplicativo como "Super Proxy" ou "ProxyDroid".
• -netdelay 200 : Define a emulação de latência de rede em milissegundos.
• -port 5556 : Define o número da porta TCP usado para o console e adb.
• -ports 5556,5559 : Define as portas TCP usadas para o console e 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 de sistema gravável durante sua sessão de emulação. Você também precisará executar adb root; adb remount. Isto é muito útil para instalar um novo certificado no sistema.

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

As ferramentas CLI oficiais facilitam criar 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

• System image flavors: google_apis (debuggable, permite adb root), google_apis_playstore (not rootable), aosp/default (leve).
• Build types: userdebug frequentemente permite adb root em imagens com capacidade de depuração. Play Store images são builds de produção e bloqueiam root.
• Em hosts x86_64, a emulação ARM64 de sistema completo não é suportada a partir da API 28+. Para Android 11+ use imagens Google APIs/Play que incluem tradução por app ARM-to-x86 para executar rapidamente muitos apps apenas para ARM.

Snapshots do 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 tradução binária (Android 11+)

Google APIs and Play Store images on Android 11+ can translate ARM app binaries per process while keeping the rest of the system native x86/x86_64. Isso costuma ser rápido o suficiente para testar muitos apps apenas para ARM no desktop.

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

Rooting de um dispositivo com Play Store

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

$ adb root
adbd cannot run as root in production builds

Usando rootAVD com Magisk consegui acesso root (siga, por exemplo, este vídeo ou este).

Instalar certificado do Burp

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

Install Burp Certificate

Opções úteis do AVD

Tirar um 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)