Comment créer un lab android pour analyser des applications android
Introduction
Créer un lab Android pour l'analyse dynamique et statique d'applications android est une étape cruciale pour les chercheurs en sécurité et les développeurs souhaitant analyser et améliorer la sécurité des applications mobiles. Ce guide vous fournira les étapes détaillées pour configurer un environnement de test sécurisé et efficace, en utilisant des outils comme Frida, Magisk, et d'autres ressources essentielles. Créer un lab Android pour l'analyse dynamique et statique d'applications android est une étape cruciale pour les chercheurs en sécurité et les développeurs souhaitant analyser et améliorer la sécurité des applications mobiles. Ce guide vous fournira les étapes détaillées pour configurer un environnement de test sécurisé et efficace, en utilisant des outils comme Frida, Magisk, et d'autres ressources essentielles.
Etape 1 : Créer notre émulateur
Afin de pouvoir analyser nos applications android de manière simple et sécurisée, il nous faut dans un premier temps créer notre émulateur android. Afin de pouvoir analyser nos applications android de manière simple et sécurisée, il nous faut dans un premier temps créer notre émulateur android.
Pour cela, nous aurons besoin du SDK Android, qui est téléchargeable depuis la page de téléchargement d'Android Studio (https://developer.android.com/studio?hl=fr)
Android studio est l'IDE fait par Google pour le développement d'applications mobiles. Il n'est pas nécessaire d'avoir l'IDE en soit, mais il est plus simple d'installer le SDK android depuis cette source
Une fois qu'android studio est installé, nous pouvons accéder au Virtual Device Manager :
Puis cliquer sur "Create Device" pour créer notre émulateur. Nous aurons le choix ensuite du hardware que nous voudrons émuler :
Je recommande de ne pas partir sur les derniers Pixel si le PC n'est pas assez puissant. A titre d'exemple, le pixel 6 fonctionne bien sur la configuration suivante :
- 8 coeurs / I7 8ème gen
- 16gb RAM / 2400Mhz
- SSD NVMe
Une fois le hardware choisi, il faudra choisir la version d'Android qui tournera sur le téléphone :
Il est tentant de choisir la version d'android la plus récente. Néanmoins, 2 facteurs sont a considérer :
-
Le minSDK défini dans le fichier AndroidManifest.xml. Ce dernier est la version la plus obsolète supporté par l'application, et est situé dans la racine de l'application décompilée
-
La distribuction globale des versions android :
En effet, notre lab se doit de répliquer l'expérience android d'un utilisateur lambda. Par conséquent, il est intéressant de voir la répartition globale des utilisateurs android dans le monde, et notamment la version d'android qu'ils utilisent.
Au 1er mai 2024, la répartition des utilisateurs était la suivante :
Ici, utiliser Android 11 permet de couvrir 50% des utilisateurs, en économisant des resources
Puis ensuite, cliquer sur créer l'émulateur. Le téléchargement de l'iso commence :
Enfin, nous pouvons démarrer l'émulateur android :
Pour la suite, il nous faut adb dans notre variable $PATH. Il faudra ajouter le chemin suivant :
C:\Users\<user>\AppData\Local\Android\Sdk\platform-tools
OU
%LOCALAPPDATA%\Android\Sdk\platform-tools
Etape 2 : Rooter notre émulateur
Nous avons notre émulateur qui fonctionne bien, mais nous sommes limités par le système android. Nous ne sommes par "root".
"Rooter" un Android signifie obtenir des droits d'administrateur sur le système, permettant ainsi de modifier des paramètres système, installer des applications nécessitant des permissions élevées, et personnaliser le téléphone de manière plus approfondie. On le fait généralement pour accéder à des fonctionnalités avancées, améliorer les performances, ou installer des versions personnalisées d'Android.
Par exemple, les autorités de certifications stockées sur android se situent dans le dossier /system/etc/security/cacerts/. Pour accéder à ce dossier et installer l'autorité de certification de Burp Suite, il nous faut les droits "root"
Pour rooter notre Android Virtual Device (AVD), nous utiliserons l'utilitaire "rootAVD" (https://gitlab.com/newbit/rootAVD)
git clone https://gitlab.com/newbit/rootAVD.git
- Windows
- Linux
./rootAVD.bat ListAllAVDs
./rootAVD.sh ListAllAVDs
Puis localiser la commande donnée par rootAVD, et l'exécuter :
[...]
./rootAVD.bat system-images\android-35\google_apis_playstore\x86_64\ramdisk.img
[...]
Le résultat devrait être le suivant, nous invitant à choisir une version magisk :
Magisk est une solution populaire pour rooter les appareils Android sans modifier le système de fichiers. Elle permet d'obtenir des droits d'administrateur tout en conservant la possibilité de passer les vérifications de sécurité comme SafetyNet de Google. Magisk est souvent utilisé pour personnaliser le système, installer des modules spécifiques, et gérer les permissions des applications de manière plus fine.
La version stable de magisk est recommandée, mais vous pouvez choisir les autres versions si besoin. L'AVD va redémarrer, et l'application "Magisk" sera installée. Une fois l'application Magisk lancée, un autre reboot sera nécessaire :
Une fois le reboot effectué, aller dans les paramètres de Magisk :
Puis scroller et cocher la case "Zygisk". Un reboot sera effectué pour appliquer les changements :
Une fois le reboot effectué, il est possible de vérifier que Magisk a bien été installé :
Pour vérifier que nous avons bien les droits root, nous pouvons lancer un shell adb afin de vérifier que nous pouvons bien avoir un shell en tant que root :
> adb root
restarting adbd as root
> adb devices
List of devices attached
emulator-5554 device
> adb shell
emulator64_x86_64_arm64:/ # id
uid=0(root) gid=0(root) groups=0(root),1004(input),1007(log),1011(adb),1015(sdcard_rw),1028(sdcard_r),1078(ext_data_rw),1079(ext_obb_rw),3001(net_bt_admin),3002(net_bt),3003(inet),3006(net_bw_stats),3009(readproc),3011(uhid) context=u:r:su:s0
emulator64_x86_64_arm64:/ # whoami
root
emulator64_x86_64_arm64:/ #
Nous sommes root !
Etape 3 : Installer le certificat de burp
Nous avons notre emulateur rooté, mais nous ne pouvons pas intercepter le trafic de quelquonque application. Cela est du au fait que les autorités de certifications installées par défaut ne font pas confiance à notre Burp Suite (ce qui est normal !).
Les autorités de certifications sur android se déclinent en 2 parties distinctes :
- Les certificats systèmes :
Les certificats systèmes sont des certificats installés par défaut à l'installation d'Android, et contiennent les autorités de certifications classiques et connues :
Ces certificats ne sont pas modifiables par l'utilisateur, à moins qu'il ait les droits superuser, ou root.
Ces certificats authentifient tous types de trafic internet, c'est à dire les trafics générés par les navigateurs mais aussi les applications.
- Les certificats utilisateurs
Par défaut il n'y a aucun certificat utilisateur. Ces derniers sont installables par l'utilisateur et authentifient les trafics générés par les navigateurs. Aucun trafic généré par une application ne peut être authentifié par un certificat utilisateur.
Pour rémédier à cela, nous allons d'abord configurer notre Burp Proxy pour écouter sur toutes les interfaces. Dans les options proxy, cocher "Toutes les interfaces" et spécifier un port :
Ensuite, dans l'émulateur android, aller dans les paramètres wifi, et noter l'ip de la passerelle par défaut :
Cette IP correspond a burp. Maintenant, nous pouvons vérifier via chrome que nous avons bien accès au burp proxy.
On peut en profiter pour télécharger l'autorité de certification interne a Burp en cliquant sur "CA Certificate" :
Puis aller dans Paramètres > Security > Encryption & Credentials > Install a Certificate > Ca Certificate > Install Anyway > cacert.der
Le certificat devrait être désormais sur les certificats utilisateurs :
Enfin, pour le passer en tant que Certificat systeme, nous allons utiliser le module Magisk "MagiskTrustUserCerts" (https://github.com/NVISOsecurity/MagiskTrustUserCerts)
Télécharger le .zip dans les releases : https://github.com/NVISOsecurity/MagiskTrustUserCerts/releases/tag/v0.4.1 et transférer l'archive sur l'émulateur via adb push
> adb push .\AlwaysTrustUserCerts.zip /sdcard/Downloads/AlwaystrustUserCerts.zip
.\AlwaysTrustUserCerts.zip: 1 file pushed, 0 skipped. 0.6 MB/s (3574 bytes in 0.006s)
Puis installer le module via Magisk, Modules puis "Install from storage" et sélectionner le .zip :
Le fichier sera dans la racine du téléphone, et non dans la carte SD émulée. C'est assez trompeur
Après un reboot, l'autorité de certification de Burp Suite devrait se situer dans les certificats systèmes :
Il ne nous reste plus qu'a spécifier Burp Suite en tant que Proxy sur la connexion wifi via les options avancées :
Les requêtes devraient arriver sur le proxy Burp :
Etape 4 : Installer frida server
Frida est un outil de reverse engineering et de sécurité qui permet d'injecter des scripts JavaScript dans des applications natives sur diverses plateformes, y compris Android et iOS. Il est utilisé pour analyser le comportement des applications, modifier leur fonctionnement en temps réel, et effectuer des tests de sécurité. Frida est particulièrement apprécié par les chercheurs en sécurité et les développeurs pour ses capacités avancées d'instrumentation dynamique.
Le fonctionnement de Frida implique d'avoir un "Serveur Frida" dans l'émulateur et un client Frida sur le host. Pour installer Frida server sur l'émulateur, nous pouvons nous appuyer sur le module Magisk "MagiskFrida" (https://github.com/ViRb3/magisk-frida)
Aller dans les releases (https://github.com/ViRb3/magisk-frida/releases) et télécharger le .zip
Répéter les mêmes étapes que l'installation du module Magisk expliquée dans l'étape 2 (adb push .zip, install du module Magisk) :
Notez bien la version de MagiskFrida installée, car la version du client doit être la même !
Pour installer frida sur l'hôte :
- Windows
- Linux
pip install frida-tools
Veillez bien à ce que le chemin "C:\Users\USER\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\LocalCache\local-packages\Python312\Scripts" ou "%LOCALAPPDATA%\Packages\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\LocalCache\local-packages\Python312\Scripts" est dans le PATH afin d'invoquer Frida simplement
pip install frida-tools
Pour vérifier que Frida client et Frida host fonctionnent bien, nous pouvons lister les process en cours dans l'émulateur avec cette commande :
> frida-ps -Uia
PID Name Identifier
---- ------------- ---------------------------------------
4790 Chrome com.android.chrome
5220 Drive com.google.android.apps.docs
5169 Files com.google.android.documentsui
3347 Gmail com.google.android.gm
1407 Google com.google.android.googlequicksearchbox
1407 Google com.google.android.googlequicksearchbox
4989 Magisk com.topjohnwu.magisk
1464 Messages com.google.android.apps.messaging
4040 Phone com.android.dialer
2981 Photos com.google.android.apps.photos
959 SIM Toolkit com.android.stk
967 Settings com.android.settings
4588 YouTube com.google.android.youtube
- Calendar com.google.android.calendar
- Camera com.android.camera2
- Clock com.google.android.deskclock
- Contacts com.android.contacts
- Maps com.google.android.apps.maps
- YouTube Music com.google.android.apps.youtube.music
Conclusion
Créer un laboratoire Android pour l'analyse dynamique et statique d'applications android est un processus qui demande une configuration minutieuse, mais les bénéfices sont considérables. En suivant les étapes décrites dans ce guide, vous avez appris à configurer un émulateur Android, à le rooter pour obtenir des droits administratifs, à installer des outils essentiels comme Burp Suite et Frida, et à préparer un environnement efficace pour analyser et tester des applications. Créer un laboratoire Android pour l'analyse dynamique et statique d'applications android est un processus qui demande une configuration minutieuse, mais les bénéfices sont considérables. En suivant les étapes décrites dans ce guide, vous avez appris à configurer un émulateur Android, à le rooter pour obtenir des droits administratifs, à installer des outils essentiels comme Burp Suite et Frida, et à préparer un environnement efficace pour analyser et tester des applications.