AVD - Android Virtual Device

Reading time: 11 minutes

Merci beaucoup à @offsecjay pour son aide lors de la création de ce contenu.

Qu'est-ce que c'est

Android Studio permet d'exécuter des machines virtuelles Android que vous pouvez utiliser pour tester des APK. Pour les utiliser, vous aurez besoin de :

• Les Android SDK tools - Download here.
• Ou Android Studio (avec Android SDK tools) - Download here.

Sous Windows (dans mon cas) après avoir installé Android Studio j'avais les SDK Tools installés dans : C:\Users\<UserName>\AppData\Local\Android\Sdk\tools

Sur mac vous pouvez download the SDK tools et les avoir dans le PATH en exécutant :

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

Ou depuis Android Studio GUI comme indiqué dans https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a qui les installera dans ~/Library/Android/sdk/cmdline-tools/latest/bin/ et ~/Library/Android/sdk/platform-tools/ et ~/Library/Android/sdk/emulator/

Pour les problèmes Java :

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

Interface graphique (GUI)

Préparer la machine virtuelle

If you installed Android Studio, you can just open the main project view and access: Tools --> AVD Manager.

Then, click on Create Virtual Device

sélectionnez le téléphone que vous voulez utiliser et cliquez sur Next.

warning

Si vous avez besoin d'un téléphone avec Play Store installé, sélectionnez-en un qui affiche l'icône Play Store !

Dans la vue actuelle, vous pourrez sélectionner et télécharger l'image Android que le téléphone va exécuter :

Donc, sélectionnez-la et, si elle n'est pas téléchargée, cliquez sur le symbole Download à côté du nom (attendez maintenant que l'image soit téléchargée).
Une fois l'image téléchargée, sélectionnez simplement Next et Finish.

La machine virtuelle sera créée. Désormais à chaque fois que vous accéderez à AVD Manager elle sera présente.

Lancer la machine virtuelle

Pour la lancer, appuyez simplement sur le Start button.

Outil en ligne de commande

Tout d'abord, vous devez décider quel téléphone vous voulez utiliser, afin de voir la liste des téléphones possibles exécutez :

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

Une fois que vous avez décidé du nom de l'appareil que vous souhaitez utiliser, vous devez choisir quelle image Android vous souhaitez exécuter sur cet appareil.
Vous pouvez lister toutes les options en utilisant sdkmanager :

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

Et téléchargez celui (ou ceux) que vous souhaitez utiliser avec :

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

Une fois que vous avez téléchargé l'image Android que vous souhaitez utiliser, vous pouvez lister toutes les images Android téléchargées avec :

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

À ce stade, vous avez choisi l'appareil que vous souhaitez utiliser et téléchargé l'image Android, donc vous pouvez créer la machine virtuelle en utilisant:

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"

Dans la dernière commande j'ai créé une VM nommée "AVD9" en utilisant le device "Nexus 5X" et l'Android image "system-images;android-28;google_apis;x86_64".
Vous pouvez maintenant lister les machines virtuelles que vous avez créées avec :

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

Exécuter une machine virtuelle

Nous avons déjà vu comment lister les machines virtuelles créées, mais vous pouvez aussi les lister en utilisant:

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

Vous pouvez simplement exécuter n'importe quelle machine virtuelle créée en utilisant :

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 en utilisant des options plus avancées, vous pouvez exécuter une machine virtuelle comme :

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

Options en ligne de commande

Cependant il existe beaucoup d'options utiles en ligne de commande que vous pouvez utiliser pour lancer une machine virtuelle. Ci‑dessous vous trouverez quelques options intéressantes mais vous pouvez consulter la liste complète ici

Démarrage

• -snapshot name : Démarrer un snapshot de la VM
• -snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img : Lister tous les snapshots enregistrés

Réseau

• -dns-server 192.0.2.0, 192.0.2.255 : Permet d'indiquer, séparés par des virgules, les serveurs DNS pour la VM.
• -http-proxy 192.168.1.12:8080 : Permet d'indiquer un HTTP proxy à utiliser (très utile pour capturer le trafic avec Burp)
• Si les paramètres de proxy ne fonctionnent pas pour une raison quelconque, essayez de les configurer en interne ou d'utiliser une application comme "Super Proxy" ou "ProxyDroid".
• -netdelay 200 : Configurer l'émulation de latence réseau en millisecondes.
• -port 5556 : Définir le numéro de port TCP utilisé pour la console et adb.
• -ports 5556,5559 : Définir les ports TCP utilisés pour la console et adb.
• -tcpdump /path/dumpfile.cap : Capturer tout le trafic dans un fichier

Système

• -selinux {disabled|permissive} : Définir le module de sécurité Security-Enhanced Linux en mode disabled ou permissive sur un système d'exploitation Linux.
• -timezone Europe/Paris : Définir le fuseau horaire pour l'appareil virtuel
• -screen {touch(default)|multi-touch|o-touch} : Définir le mode d'écran tactile émulé.
• -writable-system : Utilisez cette option pour disposer d'une image système en écriture pendant votre session d'émulation. Vous devrez aussi exécuter adb root; adb remount. Très utile pour installer un nouveau certificat dans le système.

Configuration CLI sous Linux (SDK/AVD démarrage rapide)

Les outils CLI officiels facilitent la création d'émulateurs rapides et débogables sans 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

Remarques

• Variantes d'images système : google_apis (débogable, autorise adb root), google_apis_playstore (non rootable), aosp/default (léger).
• Types de build : userdebug permet souvent adb root sur les images compatibles avec le débogage. Les images Play Store sont des builds de production et bloquent le root.
• Sur les hôtes x86_64, l'émulation système complète ARM64 n'est pas prise en charge à partir d'API 28+. Pour Android 11+ utilisez des images Google APIs/Play qui incluent une traduction par application ARM-to-x86 pour exécuter rapidement de nombreuses applications ARM-only.

Instantanés depuis la 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+)

Les images Google APIs et Play Store sur Android 11+ peuvent traduire les binaires d'app ARM par processus tout en conservant le reste du système natif x86/x86_64. C'est souvent assez rapide pour tester de nombreuses applications uniquement ARM sur un poste de travail.

Astuce : Préférez les images Google APIs x86/x86_64 lors des pentests. Les images Play sont pratiques mais bloquent adb root ; ne les utilisez que lorsque vous avez spécifiquement besoin de Play services et acceptez l'absence de root.

Obtenir le root sur un appareil Play Store

Si vous avez téléchargé un appareil avec Play Store, vous ne pourrez pas obtenir le root directement, et vous verrez ce message d'erreur

$ adb root
adbd cannot run as root in production builds

Using rootAVD with Magisk I was able to root it (suivez par exemple this video ou this one).

Installer le certificat Burp

Consultez la page suivante pour apprendre comment installer un certificat CA personnalisé :

Install Burp Certificate

Options AVD utiles

Prendre un snapshot

Vous pouvez utiliser la GUI pour prendre un snapshot de la VM à tout moment :

Références

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