AVD - Dispositivo Virtual de Android

Reading time: 11 minutes

Muchas gracias a @offsecjay por su ayuda al crear este contenido.

¿Qué es

Android Studio permite ejecutar máquinas virtuales de Android que puedes usar para probar APKs. Para usarlas necesitarás:

• Las Android SDK tools - Download here.
• O Android Studio (with Android SDK tools) - Download here.

En Windows (en mi caso) después de instalar Android Studio tuve las SDK Tools instaladas en: C:\Users\<UserName>\AppData\Local\Android\Sdk\tools

En mac puedes descargar los SDK tools y tenerlos en el PATH ejecutando:

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

O desde Android Studio GUI como se indica en https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a que los instalará en ~/Library/Android/sdk/cmdline-tools/latest/bin/ y ~/Library/Android/sdk/platform-tools/ y ~/Library/Android/sdk/emulator/

Para los problemas de Java:

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

GUI

Preparar Máquina Virtual

Si instalaste Android Studio, solo abre la vista principal del proyecto y accede a: Tools --> AVD Manager.

Luego, haz clic en Create Virtual Device

selecciona el teléfono que quieres usar y haz clic en Next.

warning

Si necesitas un teléfono con Play Store instalado, selecciona uno con el icono de Play Store en él!

En la vista actual podrás seleccionar y descargar la imagen de Android que va a ejecutar el teléfono:

Así que, selecciónala y si no está descargada haz clic en el símbolo Download junto al nombre (espera hasta que la imagen se descargue).
Una vez la imagen esté descargada, simplemente selecciona Next y Finish.

La máquina virtual será creada. Ahora cada vez que accedas al AVD Manager estará presente.

Ejecutar Máquina Virtual

Para ejecutarla solo presiona el Start button.

Herramienta de línea de comandos

Primero necesitas decidir qué teléfono quieres usar, para ver la lista de posibles teléfonos ejecuta:

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
[...]

Una vez que hayas decidido el nombre del dispositivo que quieres usar, necesitas decidir qué imagen de Android quieres ejecutar en este dispositivo.
Puedes listar todas las opciones usando sdkmanager:

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

Y descarga el que (o todos) quieras usar con:

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

Una vez que hayas descargado la imagen de Android que quieras usar, puedes listar todas las imágenes de Android descargadas con:

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

En este momento has decidido el dispositivo que quieres usar y has descargado la imagen de Android, por lo que puedes crear la 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"

En el último comando creé una VM llamada "AVD9" usando el dispositivo "Nexus 5X" y la imagen de Android "system-images;android-28;google_apis;x86_64".
Ahora puedes listar las máquinas virtuales que has creado con:

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

Ejecutar máquina virtual

Ya hemos visto cómo puedes listar las máquinas virtuales creadas, pero también puedes listarlas usando:

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

Puedes simplemente ejecutar cualquier máquina virtual creada 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"

O usando opciones más avanzadas puedes ejecutar una 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

Opciones de línea de comandos

Sin embargo, hay muchas opciones útiles de línea de comandos que puedes usar para iniciar una máquina virtual. A continuación puedes encontrar algunas opciones interesantes pero puedes find a complete list here

Arranque

• -snapshot name : Inicia un snapshot de la VM
• -snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img : Lista todos los snapshots registrados

Red

• -dns-server 192.0.2.0, 192.0.2.255 : Permite indicar servidores DNS separados por comas para la VM.
• -http-proxy 192.168.1.12:8080 : Permite indicar un proxy HTTP a usar (muy útil para capturar el tráfico con Burp)
• Si la configuración del proxy no funciona por alguna razón, intenta configurarlos internamente o usando una aplicación como "Super Proxy" o "ProxyDroid".
• -netdelay 200 : Establece la emulación de latencia de red en milisegundos.
• -port 5556 : Establece el número de puerto TCP que se usa para la consola y adb.
• -ports 5556,5559 : Establece los puertos TCP usados para la consola y adb.
• -tcpdump /path/dumpfile.cap : Captura todo el tráfico en un archivo

Sistema

• -selinux {disabled|permissive} : Configura el módulo de seguridad Security-Enhanced Linux (SELinux) en modo disabled o permissive en un sistema Linux.
• -timezone Europe/Paris : Establece la zona horaria para el dispositivo virtual
• -screen {touch(default)|multi-touch|o-touch} : Configura el modo de pantalla táctil emulado.
• -writable-system : Usa esta opción para tener una imagen del sistema escribible durante tu sesión de emulación. También necesitarás ejecutar adb root; adb remount. Esto es muy útil para instalar un certificado nuevo en el sistema.

Configuración CLI en Linux (SDK/AVD quickstart)

Las herramientas CLI oficiales facilitan crear emuladores rápidos y depurables sin 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 (no rootable), aosp/default (ligera).
• Build types: userdebug suele permitir adb root en imágenes con capacidad de debug. Las imágenes Play Store son builds de producción y bloquean el root.
• En hosts x86_64, la emulación de sistema completo ARM64 no es compatible desde API 28+. Para Android 11+ usa imágenes Google APIs/Play que incluyen traducción ARM-to-x86 por aplicación para ejecutar rápidamente muchas aplicaciones exclusivas de ARM.

Snapshots from 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 traducción de binarios (Android 11+)

Las imágenes Google APIs y Play Store en Android 11+ pueden traducir binarios de apps ARM por proceso manteniendo el resto del sistema nativo x86/x86_64. Esto suele ser lo suficientemente rápido para probar muchas apps solo ARM en el escritorio.

Consejo: Prefiere imágenes Google APIs x86/x86_64 durante pentests. Las imágenes Play son convenientes pero bloquean adb root; úsalas solo cuando requieras específicamente Play services y aceptes la falta de root.

Obtener root en un dispositivo Play Store

Si descargaste un dispositivo con Play Store no vas a poder obtener root directamente, y recibirás este mensaje de error

$ adb root
adbd cannot run as root in production builds

Using rootAVD with Magisk I was able to root it (follow for example this video or this one).

Instalar el certificado de Burp

Consulta la siguiente página para aprender cómo instalar un certificado CA personalizado:

Install Burp Certificate

Buenas opciones de AVD

Tomar una instantánea

Puedes usar la GUI para tomar una instantánea de la VM en cualquier momento:

Referencias

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