AVD - Wirtualne urządzenie Androida

Reading time: 10 minutes

Bardzo dziękuję @offsecjay za pomoc przy tworzeniu tej treści.

Czym jest

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

• Pakiet Android SDK tools - Download here.
• Lub Android Studio (z Android SDK tools) - Download here.

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

Na macu możesz pobrać SDK tools i mieć je w PATH uruchamiając:

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

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

W przypadku problemów z Java:

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

GUI

Przygotowanie maszyny wirtualnej

Jeśli zainstalowałeś Android Studio, otwórz widok główny projektu i przejdź: Tools --> AVD Manager.

Następnie kliknij Create Virtual Device

select 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 tym widoku będziesz mógł wybrać i pobrać obraz Androida, na którym telefon będzie działał:

Więc wybierz go, a jeśli nie jest pobrany kliknij na symbol Download obok nazwy (now wait until the image is downloaded).
Po pobraniu obrazu po prostu wybierz Next i Finish.

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

Uruchamianie maszyny wirtualnej

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

Narzędzie wiersza poleceń

Przede wszystkim musisz zdecydować, którego telefonu chcesz użyć, aby zobaczyć listę dostępnych 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
[...]

Po wybraniu nazwy urządzenia, którego chcesz użyć, musisz zdecydować, który 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

I pobierz ten (lub wszystkie), które 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"

Po pobraniu obrazu Android, którego chcesz użyć, możesz wypisać wszystkie pobrane obrazy 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órego chcesz użyć i pobrałeś obraz Androida, więc możesz utworzyć maszynę wirtualną przy użyciu:

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 maszynę wirtualną nazwaną "AVD9" używając urządzenia "Nexus 5X" i obrazu Androida "system-images;android-28;google_apis;x86_64".\ Teraz możesz wypisać maszyny wirtualne które utworzyłeś poleceniem:

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

Uruchamianie maszyny wirtualnej

Widzieliśmy już, jak wyświetlić utworzone maszyny wirtualne, ale można je także wylistować za pomocą:

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ą używając:

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

Lub 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 różnych przydatnych opcji wiersza poleceń, których możesz użyć do uruchomienia maszyny wirtualnej. Poniżej znajdziesz kilka interesujących opcji, a pełną listę możesz znaleźć tutaj

Rozruch

• -snapshot name : Uruchom snapshot VM
• -snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img : Wyświetl wszystkie zarejestrowane snapshoty

Sieć

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

System

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

Konfiguracja CLI na Linuxie (SDK/AVD quickstart)

Oficjalne narzędzia CLI ułatwiają tworzenie szybkich, debugowalnych 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 (z możliwością debugowania, pozwala na adb root), google_apis_playstore (nie da się uzyskać roota), 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ą roota.
• Na hostach x86_64 pełna emulacja systemu ARM64 nie jest obsługiwana od API 28+. Dla Androida 11+ użyj obrazów Google APIs/Play, które zawierają per-app ARM-to-x86 translation, aby szybko uruchamiać wiele aplikacji przeznaczonych tylko dla ARM.

Migawki 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 tłumaczenie binarne (Android 11+)

Obrazy Google APIs i Play Store na Android 11+ potrafią tłumaczyć binaria aplikacji ARM dla każdego procesu, zachowując resztę systemu natywną (x86/x86_64). Zwykle jest to wystarczająco szybkie, by testować wiele aplikacji przeznaczonych wyłącznie dla ARM na desktopie.

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

Rootowanie urządzenia z Play Store

Jeśli pobrałeś urządzenie z Play Store, nie będziesz w stanie bezpośrednio uzyskać root 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 (na przykład obejrzyj this video or this one).

Zainstaluj certyfikat Burp

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

Install Burp Certificate

Przydatne opcje AVD

Wykonaj snapshot

Możesz użyć GUI, aby wykonać snapshot VM w dowolnym momencie:

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