AVD - Android Virtual Device

Reading time: 10 minutes

Dziękuję bardzo @offsecjay za jego pomoc przy tworzeniu tej zawartości.

Co to jest

Android Studio pozwala uruchamiać wirtualne maszyny Androida, których możesz użyć do testowania APK. Aby z nich korzystać będziesz potrzebować:

• The Android SDK tools - Download here.
• Or Android Studio (with Android SDK tools) - Download here.

Na Windowsie (w moim przypadku) po zainstalowaniu Android Studio miałem SDK Tools zainstalowane w: C:\Users\<UserName>\AppData\Local\Android\Sdk\tools

Na macOS możesz pobrać SDK tools i dodać je do PATH uruchamiając:

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

Lub z Android Studio GUI, jak wskazano w https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a, które zainstaluje je w ~/Library/Android/sdk/cmdline-tools/latest/bin/ i ~/Library/Android/sdk/platform-tools/ i ~/Library/Android/sdk/emulator/

Dla problemów z Java:

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

GUI

Przygotowanie maszyny wirtualnej

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

Then, click on Create Virtual Device

wybierz telefon, którego chcesz użyć i kliknij Next.

warning

Jeśli potrzebujesz telefonu z zainstalowanym Play Store wybierz taki, który ma ikonę Play Store!

W bieżącym widoku będziesz mógł wybrać i pobrać obraz Androida, na którym telefon będzie działać:

Wybierz go, a jeśli nie jest pobrany, kliknij symbol Download obok nazwy (poczekaj, aż obraz zostanie pobrany).
Po pobraniu obrazu po prostu wybierz Next i Finish.

Maszyna wirtualna zostanie utworzona. Teraz za każdym razem, gdy otworzysz AVD Manager, będzie ona dostępna.

Uruchamianie maszyny wirtualnej

Aby ją uruchomić, po prostu naciśnij Start button.

Narzędzie wiersza poleceń

Przede wszystkim musisz zdecydować, którego telefonu chcesz użyć; aby zobaczyć listę możliwych telefonów, wykonaj:

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

Gdy już wybierzesz nazwę urządzenia, którego chcesz użyć, musisz zdecydować, jaki obraz Androida chcesz uruchomić na tym urządzeniu.
Możesz wyświetlić wszystkie opcje za pomocą sdkmanager:

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

Następnie pobierz ten (lub wszystkie), których chcesz użyć za pomocą:

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

Gdy pobierzesz obraz Androida, którego chcesz użyć, możesz wyświetlić listę wszystkich pobranych obrazów Androida za pomocą:

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

W tym momencie wybrałeś urządzenie, które chcesz użyć, i pobrałeś obraz Androida, więc możesz utworzyć maszynę wirtualną za pomocą:

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"

W ostatnim poleceniu utworzyłem VM o nazwie "AVD9" używając urządzenia "Nexus 5X" i obrazu Android "system-images;android-28;google_apis;x86_64".
Teraz możesz wyświetlić listę maszyn wirtualnych które utworzyłeś za pomocą:

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

Uruchom maszynę wirtualną

Widzieliśmy już, jak wypisać utworzone maszyny wirtualne, ale możesz je także wypisać używając:

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

Możesz po prostu uruchomić dowolną utworzoną maszynę wirtualną za pomocą:

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

Albo używając bardziej zaawansowanych opcji, możesz uruchomić maszynę wirtualną, taką jak:

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

Opcje wiersza poleceń

Jednak istnieje wiele przydatnych opcji wiersza poleceń, których możesz użyć do uruchomienia maszyny wirtualnej. Poniżej znajdziesz kilka interesujących opcji, ale możesz find a complete list here

Boot

• -snapshot name : Uruchom snapshot VM
• -snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img : Wyświetl listę wszystkich zapisanych snapshotów

Network

• -dns-server 192.0.2.0, 192.0.2.255 : Pozwala wskazać serwery DNS dla VM, rozdzielone przecinkami.
• -http-proxy 192.168.1.12:8080 : Pozwala wskazać HTTP proxy do użycia (bardzo przydatne do przechwytywania ruchu za pomocą Burp)
• Jeśli ustawienia proxy z jakiegoś powodu nie działają, spróbuj skonfigurować je wewnętrznie lub użyć aplikacji takiej jak "Super Proxy" lub "ProxyDroid".
• -netdelay 200 : Ustawia emulowaną latencję sieciową w milisekundach.
• -port 5556 : Ustawia numer portu TCP używanego przez konsolę i adb.
• -ports 5556,5559 : Ustawia porty TCP używane przez konsolę i adb.
• -tcpdump /path/dumpfile.cap : Zapisuje cały ruch do pliku

System

• -selinux {disabled|permissive} : Ustawia moduł bezpieczeństwa Security-Enhanced Linux na disabled lub permissive na systemie Linux.
• -timezone Europe/Paris : Ustawia strefę czasową dla urządzenia wirtualnego
• -screen {touch(default)|multi-touch|o-touch} : Ustawia emulowany tryb ekranu dotykowego.
• -writable-system : Użyj tej opcji, aby mieć zapisywalny obraz systemu podczas sesji emulacji. Będziesz też musiał uruchomić adb root; adb remount. To bardzo przydatne do zainstalowania nowego certyfikatu w systemie.

Linux CLI setup (SDK/AVD quickstart)

Oficjalne narzędzia CLI ułatwiają tworzenie szybkich, możliwych do debugowania emulatorów bez 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

Notatki

• Warianty obrazów systemu: google_apis (debuggable, pozwala na adb root), google_apis_playstore (not rootable), aosp/default (lekki).
• Typy buildów: userdebug często pozwala na adb root na obrazach z możliwością debugowania. Obrazy Play Store to buildy produkcyjne i blokują root.
• Na hostach x86_64 pełna emulacja systemu ARM64 jest nieobsługiwana od API 28+. Dla Android 11+ użyj Google APIs/Play images, które zawierają tłumaczenie ARM→x86 na poziomie aplikacji, aby szybko uruchamiać wiele aplikacji przeznaczonych wyłącznie dla ARM.

Snapshoty z 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 translacja binarna (Android 11+)

Google APIs i obrazy Play Store na Android 11+ mogą translować binaria aplikacji ARM per process, pozostawiając resztę systemu natywną x86/x86_64. Często jest to wystarczająco szybkie, by testować wiele aplikacji dostępnych tylko na ARM na komputerze stacjonarnym.

Wskazówka: Preferuj obrazy Google APIs x86/x86_64 podczas pentests. Obrazy Play są wygodne, ale blokują adb root; używaj ich tylko wtedy, gdy konkretnie potrzebujesz Play services i akceptujesz brak root.

Rooting urządzenia z Play Store

Jeśli pobrałeś urządzenie z Play Store, nie będziesz w stanie uzyskać root bezpośrednio i otrzymasz ten komunikat o błędzie

$ adb root
adbd cannot run as root in production builds

Używając rootAVD z Magisk udało mi się uzyskać root (np. obejrzyj this video lub this one).

Zainstaluj certyfikat Burp

Sprawdź następującą stronę, aby dowiedzieć się, jak zainstalować niestandardowy certyfikat CA:

Install Burp Certificate

Przydatne opcje AVD

Zrób snapshot

Możesz skorzystać z GUI, aby w dowolnym momencie wykonać snapshot maszyny wirtualnej (VM):

Źródła

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