# Pentesting d'applications Android

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)! * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family) * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com) * **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** * **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

[**Suivez HackenProof**](https://bit.ly/3xrrDrL) **pour en savoir plus sur les bugs web3** 🐞 Lisez les tutoriels sur les bugs web3 🔔 Recevez des notifications sur les nouveaux programmes de primes pour bugs 💬 Participez aux discussions de la communauté ## Analyse statique Tout d'abord, pour analyser un APK, vous devriez **jeter un coup d'œil au code Java** en utilisant un décompilateur.\ S'il vous plaît, [**lisez ici pour trouver des informations sur les différents décompilateurs disponibles**](apk-decompilers.md). ### Recherche d'informations intéressantes En regardant simplement les **chaînes de caractères** de l'APK, vous pouvez rechercher des **mots de passe**, des **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des **clés API**, du **chiffrement**, des **UUID Bluetooth**, des **jetons** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administrateur codés en dur dans l'application). **Firebase** Faites particulièrement attention aux **URL Firebase** et vérifiez si elles sont mal configurées. [Plus d'informations sur ce qu'est Firebase et comment l'exploiter ici.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Compréhension de base de l'application - Manifest.xml, strings.xml En utilisant l'un des **décompilateurs** mentionnés [**ici**](apk-decompilers.md), vous pourrez lire le _Manifest.xml_. Vous pouvez également **renommer** l'extension de fichier **apk en .zip** et le **décompresser**.\ En lisant le **manifeste**, vous pouvez trouver des **vulnérabilités** : * Tout d'abord, vérifiez si **l'application est débogable**. Une APK de production ne devrait pas l'être (sinon d'autres pourront s'y connecter). Vous pouvez vérifier si une application est débogable en cherchant dans le manifeste l'attribut `debuggable="true"` à l'intérieur de la balise _\ formation-software.co.uk ` * **Activités exportées** : Vérifiez les activités exportées dans le manifeste car cela peut être dangereux. Plus tard, lors de l'analyse dynamique, il sera expliqué comment [vous pouvez exploiter ce comportement](./#exploiting-exported-activities-authorisation-bypass). * **Fournisseurs de contenu** : Si un fournisseur exporté est exposé, vous pourriez être en mesure d'accéder/modifier des informations intéressantes. Dans l'analyse dynamique, [vous apprendrez comment les exploiter](./#exploiting-content-providers-accessing-and-manipulating-sensitive-information). * Vérifiez les configurations des **FileProviders** à l'intérieur de l'attribut `android:name="android.support.FILE_PROVIDER_PATHS"`. [Lisez ici pour en savoir plus sur les FileProviders](./#fileprovider). * **Services exposés** : Selon ce que le service fait en interne, des vulnérabilités pourraient être exploitées. Dans l'analyse dynamique, [vous apprendrez comment les exploiter](./#exploiting-services). * **Récepteurs de diffusion** : [Vous apprendrez comment vous pouvez éventuellement les exploiter](./#exploiting-broadcast-receivers) lors de l'analyse dynamique. * **Schéma d'URL** : Lisez le code de l'activité gérant le schéma et recherchez des vulnérabilités gérant l'entrée de l'utilisateur. Plus d'informations sur [ce qu'est un schéma d'URL ici](./#url-schemes). * **minSdkVersion**, **targetSDKVersion**, **maxSdkVersion** : Ils indiquent les versions d'Android sur lesquelles l'application fonctionnera. Il est important de les garder à l'esprit car du point de vue de la sécurité, le support des anciennes versions permettra aux versions vulnérables connues d'Android de l'exécuter. En lisant **resources.arsc/strings.xml**, vous pouvez trouver des **informations intéressantes** : * Clés API * Schémas personnalisés * Autres informations intéressantes que les développeurs enregistrent dans ce fichier ### Tapjacking **Tapjacking** est une attaque où une **application malveillante** est lancée et **se positionne au-dessus d'une application victime**. Une fois qu'elle obscurcit visiblement l'application victime, son interface utilisateur est conçue de manière à tromper l'utilisateur pour qu'il interagisse avec elle, tout en passant l'interaction à l'application victime.\ En effet, cela **aveugle l'utilisateur en lui faisant croire qu'il effectue réellement des actions sur l'application victime**. Pour détecter les applications vulnérables à cette attaque, vous devriez rechercher des **activités exportées** dans le manifeste Android (notez qu'une activité avec un filtre d'intention est automatiquement exportée par défaut). Une fois que vous avez trouvé les activités exportées, **vérifiez si elles nécessitent une autorisation**. C'est parce que la **demande malveillante aura également besoin de cette autorisation**.\ Enfin, il est important de vérifier le code pour d'éventuelles configurations de **`setFilterTouchesWhenObscured`**. Si elle est définie sur **`true`**, un bouton peut être automatiquement désactivé s'il est obscurci : ```markup ``` Vous pouvez utiliser [**qark**](https://github.com/linkedin/qark) avec le paramètre `--exploit-apk` pour créer une application malveillante afin de tester les vulnérabilités potentielles de **Tapjacking**.\ Un projet d'exemple implémentant ce type de fonctionnalité peut être trouvé dans [**FloatingWindowApp**](https://github.com/aminography/FloatingWindowApp). La mitigation est relativement simple car le développeur peut choisir de ne pas recevoir les événements tactiles lorsqu'une vue est recouverte par une autre. En utilisant la [Référence du développeur Android](https://developer.android.com/reference/android/view/View#security): > Parfois, il est essentiel qu'une application puisse vérifier qu'une action est effectuée avec la pleine connaissance et le consentement de l'utilisateur, comme accorder une demande d'autorisation, effectuer un achat ou cliquer sur une publicité. Malheureusement, une application malveillante pourrait essayer de tromper l'utilisateur en effectuant ces actions, sans le savoir, en dissimulant l'objectif prévu de la vue. Pour remédier à cela, le framework offre un mécanisme de filtrage tactile qui peut être utilisé pour améliorer la sécurité des vues qui fournissent un accès à des fonctionnalités sensibles. > > Pour activer le filtrage tactile, appelez [`setFilterTouchesWhenObscured(boolean)`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured%28boolean%29) ou définissez l'attribut de mise en page android:filterTouchesWhenObscured sur true. Lorsqu'il est activé, le framework supprimera les touches reçues chaque fois que la fenêtre de la vue est masquée par une autre fenêtre visible. Par conséquent, la vue ne recevra pas de touches chaque fois qu'un toast, une boîte de dialogue ou une autre fenêtre apparaîtra au-dessus de la fenêtre de la vue. ### Détournement de tâche {% content-ref url="android-task-hijacking.md" %} [android-task-hijacking.md](android-task-hijacking.md) {% endcontent-ref %} ### Stockage de données non sécurisé **Stockage interne** Les fichiers **créés** sur le **stockage interne** sont **accessibles** uniquement par l'**application**. Cette protection est mise en œuvre par Android et est suffisante pour la plupart des applications. Mais les développeurs utilisent souvent `MODE_WORLD_READBALE` & `MODE_WORLD_WRITABLE` pour donner accès à ces fichiers à une autre application, mais cela ne limite pas les autres applications (malveillantes) à y accéder.\ Lors de l'**analyse statique**, vérifiez l'utilisation de ces **modes**, lors de l'**analyse dynamique**, vérifiez les **autorisations** des fichiers créés (peut-être que certains d'entre eux sont lisibles/inscriptibles dans le monde entier).\ [Plus d'informations sur cette vulnérabilité et comment la corriger ici.](https://manifestsecurity.com/android-application-security-part-8/) **Stockage externe** Les fichiers créés sur le **stockage externe**, tels que les cartes SD, sont **lisibles et inscriptibles à l'échelle mondiale**. Étant donné que le stockage externe peut être supprimé par l'utilisateur et également modifié par n'importe quelle application, vous ne devez **pas stocker d'informations sensibles en utilisant le stockage externe**.\ Comme pour les données provenant de toute source non fiable, vous devez **valider les entrées** lors de la manipulation des **données provenant du stockage externe**. Nous vous recommandons vivement de ne pas stocker d'exécutables ou de fichiers de classe sur le stockage externe avant le chargement dynamique. Si votre application récupère des fichiers exécutables à partir du stockage externe, les fichiers doivent être signés et vérifiés cryptographiquement avant le chargement dynamique.\ Informations prises à partir de [ici](https://manifestsecurity.com/android-application-security-part-8/). Le stockage externe peut être **accédé** dans `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` {% hint style="info" %} À partir d'Android 4.4 (**API 17**), la carte SD dispose d'une structure de répertoire qui **limite l'accès d'une application au répertoire spécifiquement destiné à cette application**. Cela empêche les applications malveillantes d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre application. {% endhint %} **Données sensibles stockées en clair** * **Préférences partagées**: Android permet à chaque application de facilement enregistrer des fichiers xml dans le chemin `/data/data//shared_prefs/` et parfois il est possible de trouver des informations sensibles en clair dans ce dossier. * **Bases de données**: Android permet à chaque application de facilement enregistrer des bases de données sqlite dans le chemin `/data/data//databases/` et parfois il est possible de trouver des informations sensibles en clair dans ce dossier. ### TLS cassé **Accepter tous les certificats** Pour une raison quelconque, parfois les développeurs acceptent tous les certificats même si, par exemple, le nom d'hôte ne correspond pas avec des lignes de code comme celle-ci: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` Une bonne façon de tester cela est d'essayer de capturer le trafic en utilisant un proxy comme Burp sans autoriser Burp CA à l'intérieur de l'appareil. De plus, vous pouvez générer avec Burp un certificat pour un nom d'hôte différent et l'utiliser. ### Cryptographie cassée **Mauvais processus de gestion de clés** Certains développeurs enregistrent des données sensibles dans le stockage local et les chiffrent avec une clé codée en dur/prévisible dans le code. Cela ne devrait pas être fait car une rétro-ingénierie pourrait permettre aux attaquants d'extraire les informations confidentielles. **Utilisation d'algorithmes non sécurisés et/ou obsolètes** Les développeurs ne devraient pas utiliser des **algorithmes obsolètes** pour effectuer des **vérifications** d'autorisation, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hachages** sont utilisés pour stocker des mots de passe par exemple, des hachages résistants à la force brute devraient être utilisés avec un sel. ### Autres vérifications * Il est recommandé d'**obfusquer l'APK** pour rendre plus difficile le travail de rétro-ingénierie des attaquants. * Si l'application est sensible (comme les applications bancaires), elle devrait effectuer ses **propres vérifications pour voir si le mobile est rooté** et agir en conséquence. * Si l'application est sensible (comme les applications bancaires), elle devrait vérifier si un **émulateur** est utilisé. * Si l'application est sensible (comme les applications bancaires), elle devrait **vérifier son intégrité avant de l'exécuter** pour vérifier si elle a été modifiée. * Utilisez [**APKiD**](https://github.com/rednaga/APKiD) pour vérifier quel compilateur/packer/obfuscateur a été utilisé pour construire l'APK. ### Application React Native Lisez la page suivante pour apprendre comment accéder facilement au code JavaScript des applications React : {% content-ref url="react-native-application.md" %} [react-native-application.md](react-native-application.md) {% endcontent-ref %} ### Applications Xamarin Les applications **Xamarin** sont écrites en **C#**, pour accéder au code C# **décompressé**, vous devez obtenir les fichiers de l'**apk** : ```bash 7z r app.apk #Or any other zip decompression cmd ``` Ensuite, décompressez tous les fichiers DLsL à l'aide de [**xamarin-decompress**](https://github.com/NickstaDB/xamarin-decompress)**:** ``` python3 xamarin-decompress.py -o /path/to/decompressed/apk ``` Et enfin, vous pouvez utiliser [**ces outils recommandés**](../../reversing/reversing-tools-basic-methods/#net-decompiler) pour **lire le code C#** des DLLs. ### Analyse de code statique automatisée L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), de **sinks** (qui indiquent à l'outil les **endroits dangereux** où une entrée utilisateur malveillante pourrait causer des dommages) et de **règles**. Ces règles indiquent la **combinaison** de **sources-sinks** qui indique une vulnérabilité. Avec cette connaissance, **mariana-trench examinera le code et trouvera les vulnérabilités possibles**. ### Fuites de secrets Une application peut contenir des secrets (clés API, mots de passe, URL cachées, sous-domaines...) à l'intérieur que vous pourriez être en mesure de découvrir. Vous pouvez utiliser un outil tel que [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Contourner l'authentification biométrique {% content-ref url="bypass-biometric-authentication-android.md" %} [bypass-biometric-authentication-android.md](bypass-biometric-authentication-android.md) {% endcontent-ref %} ### Autres fonctions intéressantes * **Exécution de code**: `Runtime.exec(), ProcessBuilder(), code natif:system()` * **Envoyer des SMS**: `sendTextMessage, sendMultipartTestMessage` * **Fonctions natives** déclarées comme `native`: `public native, System.loadLibrary, System.load` * [Lisez ceci pour apprendre **comment inverser les fonctions natives**](reversing-native-libraries.md) ### **Autres astuces** {% content-ref url="content-protocol.md" %} [content-protocol.md](content-protocol.md) {% endcontent-ref %}

[**Suivez HackenProof**](https://bit.ly/3xrrDrL) **pour en savoir plus sur les bugs web3** 🐞 Lire les tutoriels de bugs web3 🔔 Recevoir des notifications sur les nouveaux programmes de primes pour bugs 💬 Participer aux discussions de la communauté ## Analyse dynamique > Tout d'abord, vous avez besoin d'un environnement où vous pouvez installer l'application et tout l'environnement (certificat Burp CA, Drozer et Frida principalement). Par conséquent, un appareil enraciné (émulé ou non) est extrêmement recommandé. ### Analyse dynamique en ligne Vous pouvez créer un **compte gratuit** sur: [https://appetize.io/](https://appetize.io). Cette plateforme vous permet de **télécharger** et **exécuter** des APK, il est donc utile de voir comment un APK se comporte. Vous pouvez même **voir les journaux de votre application** sur le web et vous connecter via **adb**. ![](<../../.gitbook/assets/image (60).png>) Grâce à la connexion ADB, vous pouvez utiliser **Drozer** et **Frida** à l'intérieur des émulateurs. ### Analyse dynamique locale Vous pouvez utiliser un **émulateur** comme: * [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des appareils **x86** et **arm**, et selon [**ceci** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**les dernières versions x86** **supportent les bibliothèques ARM** sans avoir besoin d'un émulateur ARM lent). * Si vous voulez essayer d'**installer** une **image** et que vous voulez **la supprimer** ensuite, vous pouvez le faire sur Windows:`C:\Users\\AppData\Local\Android\sdk\system-images\` ou Mac: `/Users/myeongsic/Library/Android/sdk/system-image` * C'est l'**émulateur principal que je recommande d'utiliser et vous pouvez**[ **apprendre à le configurer sur cette page**](avd-android-virtual-device.md). * [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite:** Personal Edition, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC**_ _**VirtualBox** pour éviter les erreurs potentielles._) * [Nox](https://es.bignox.com) (Gratuit, mais ne prend pas en charge Frida ou Drozer). {% hint style="info" %} Lors de la création d'un nouvel émulateur sur n'importe quelle plateforme, rappelez-vous que plus l'écran est grand, plus l'émulateur sera lent. Choisissez donc des petits écrans si possible. {% endhint %} Comme la plupart des gens utiliseront **Genymotion**, notez cette astuce. Pour **installer les services Google** (comme AppStore), vous devez cliquer sur le bouton marqué en rouge de l'image suivante: ![](<../../.gitbook/assets/image (200) (1).png>) De plus, notez que dans la **configuration de la machine virtuelle Android dans Genymotion**, vous pouvez sélectionner le mode **Bridge Network** (ce sera utile si vous vous connectez à la machine virtuelle Android à partir d'une autre machine virtuelle avec les outils). Ou vous pouvez utiliser un **appareil physique** (vous devez activer les options de débogage et ce sera cool si vous pouvez le rooter): 1. **Paramètres**. 2. (À partir d'Android 8.0) Sélectionnez **Système**. 3. Sélectionnez **À propos du téléphone**. 4. Appuyez sur **Numéro de build** 7 fois. 5. Revenez en arrière et vous trouverez les **Options pour les développeurs**. > Une fois que vous avez installé l'application, la première chose à faire est de l'essayer et d'investiguer ce qu'elle fait, comment elle fonctionne et de vous familiariser avec elle.\ > Je vous suggère de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique MobSF + pidcat**, afin que vous puissiez **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pouvez examiner plus tard. ### Fuites de données involontaires **Journalisation** Souvent, les développeurs laissent des informations de débogage publiques. Ainsi, toute application avec l'autorisation `READ_LOGS` peut **accéder à ces journaux** et peut obtenir des informations sensibles à travers cela.\ Lors de la navigation dans l'application, utilisez [**pidcat**](https://github.com/JakeWharton/pidcat)_(Recommandé, il est plus facile à utiliser et à lire_) ou [adb logcat](adb-commands.md#logcat) pour lire les journaux créés et **rechercher des informations sensibles**. {% hint style="warning" %} Notez que depuis les versions ultérieures à Android 4.0, **les applications ne peuvent accéder qu'à leurs propres journaux**. ``` adb shell am start -n com.example.demo/com.example.test.MainActivity ``` **REMARQUE**: MobSF détectera comme malveillante l'utilisation de _**singleTask/singleInstance**_ en tant que `android:launchMode` dans une activité, mais en raison de [ceci](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), cela ne serait apparemment dangereux que sur les anciennes versions (versions API < 21). {% hint style="info" %} Notez qu'une violation d'autorisation n'est pas toujours une vulnérabilité, cela dépendrait de la façon dont la violation fonctionne et des informations exposées. {% endhint %} **Fuite d'informations sensibles** **Les activités peuvent également renvoyer des résultats**. Si vous parvenez à trouver une activité exportée et non protégée appelant la méthode **`setResult`** et **renvoyant des informations sensibles**, il y a une fuite d'informations sensibles. ### Exploitation des fournisseurs de contenu - Accès et manipulation d'informations sensibles [**Lisez ceci si vous voulez vous rappeler ce qu'est un fournisseur de contenu.**](android-applications-basics.md#content-provider)\ Les fournisseurs de contenu sont essentiellement utilisés pour **partager des données**. Si une application dispose de fournisseurs de contenu disponibles, vous pourrez peut-être **extraire des données sensibles** à partir de ceux-ci. Il est également intéressant de tester les **injections SQL** et les **traversées de chemin** possibles car ils pourraient être vulnérables.\ [**Apprenez à exploiter les fournisseurs de contenu avec Drozer.**](drozer-tutorial/#content-providers) ### **Exploitation des services** [**Lisez ceci si vous voulez vous rappeler ce qu'est un service.**](android-applications-basics.md#services)\ Rappelez-vous que les actions d'un service commencent dans la méthode `onStartCommand`. Un service est essentiellement quelque chose qui **peut recevoir des données**, les **traiter** et **renvoyer** (ou non) une réponse. Ensuite, si une application exporte certains services, vous devez **vérifier** le **code** pour comprendre ce qu'il fait et le **tester** **dynamiquement** pour extraire des informations confidentielles, contourner les mesures d'authentification...\ [**Apprenez à exploiter les services avec Drozer.**](drozer-tutorial/#services) ### **Exploitation des récepteurs de diffusion** [**Lisez ceci si vous voulez vous rappeler ce qu'est un récepteur de diffusion.**](android-applications-basics.md#broadcast-receivers)\ Rappelez-vous que les actions d'un récepteur de diffusion commencent dans la méthode `onReceive`. Un récepteur de diffusion attendra un type de message. Selon la manière dont le récepteur gère le message, il pourrait être vulnérable.\ [**Apprenez à exploiter les récepteurs de diffusion avec Drozer.**](./#exploiting-broadcast-receivers) ### **Exploitation des schémas / liens profonds** Vous pouvez rechercher des liens profonds manuellement, en utilisant des outils comme MobSF ou des scripts comme [celui-ci](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ Vous pouvez **ouvrir** un **schéma** déclaré en utilisant **adb** ou un **navigateur** : ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` _Notez que vous pouvez **omettre le nom du package** et le mobile appellera automatiquement l'application qui devrait ouvrir ce lien._ ```markup Click me with alternative ``` **Code exécuté** Pour trouver le **code qui sera exécuté dans l'application**, allez dans l'activité appelée par le lien profond et recherchez la fonction **`onNewIntent`**. ![](<../../.gitbook/assets/image (436) (1) (1) (1).png>) **Informations sensibles** Chaque fois que vous trouvez un lien profond, vérifiez qu'il ne reçoit pas de données sensibles (comme des mots de passe) via des paramètres d'URL, car toute autre application pourrait **usurper le lien profond et voler ces données !** **Paramètres dans le chemin** Vous **devez également vérifier si un lien profond utilise un paramètre à l'intérieur du chemin** de l'URL comme : `https://api.example.com/v1/users/{username}`, dans ce cas, vous pouvez forcer une traversée de chemin en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\ Notez que si vous trouvez les points d'extrémité corrects à l'intérieur de l'application, vous pourriez être en mesure de causer une **redirection ouverte** (si une partie du chemin est utilisée comme nom de domaine), une **prise de contrôle de compte** (si vous pouvez modifier les détails des utilisateurs sans jeton CSRF et que le point d'extrémité vulnérable utilise la méthode correcte) et toute autre vulnérabilité. Plus d'informations à ce sujet [ici](http://dphoeniixx.com/2020/12/13-2/). **Plus d'exemples** Un [rapport de prime de bug intéressant](https://hackerone.com/reports/855618) sur les liens (_/.well-known/assetlinks.json_). ### Protection insuffisante de la couche de transport * **Manque d'inspection de certificat :** L'application Android ne vérifie pas l'identité du certificat qui lui est présenté. La plupart des applications ignorent les avertissements et acceptent tout certificat auto-signé présenté. Certaines applications passent plutôt le trafic par une connexion HTTP. * **Négociation de poignée de main faible :** L'application et le serveur effectuent une poignée de main SSL/TLS mais utilisent une suite de chiffrement non sécurisée qui est vulnérable aux attaques MITM. Ainsi, tout attaquant peut facilement décrypter cette connexion. * **Fuite d'informations de confidentialité :** La plupart du temps, il arrive que les applications effectuent une authentification via un canal sécurisé mais que toutes les autres connexions se fassent via un canal non sécurisé. Cela n'ajoute pas de sécurité à l'application car les données sensibles restantes telles que le cookie de session ou les données utilisateur peuvent être interceptées par un utilisateur malveillant. Des 3 scénarios présentés, nous allons discuter de **comment vérifier l'identité du certificat**. Les 2 autres scénarios dépendent de la **configuration TLS** du serveur et si l'**application envoie des données non chiffrées**. Le testeur de pénétration doit vérifier par lui-même la configuration TLS du serveur ([ici](../../network-services-pentesting/pentesting-web/#ssl-tls-vulnerabilites)) et détecter si des **informations confidentielles sont envoyées par un canal non chiffré/vulnérable**.\ Plus d'informations sur la façon de découvrir et de corriger ce type de vulnérabilités [**ici**](https://manifestsecurity.com/android-application-security-part-10/). **Épinglage SSL** Par défaut, lorsqu'une connexion SSL est établie, le client (application Android) vérifie que le certificat du serveur a une chaîne de confiance vérifiable remontant à un certificat de confiance (racine) et correspond au nom d'hôte demandé. Cela conduit au problème des **attaques de l'homme du milieu (MITM)**.\ Dans l'épinglage de certificat, une application Android contient elle-même le certificat du serveur et ne transmet les données que si le même certificat est présenté.\ Il est recommandé d'**appliquer l'épinglage SSL** pour les sites où des informations sensibles vont être envoyées. ### Inspection du trafic HTTP Tout d'abord, vous devez (devez) **installer le certificat** de l'**outil proxy** que vous allez utiliser, probablement Burp. Si vous n'installez pas le certificat CA de l'outil proxy, vous ne verrez probablement pas le trafic chiffré dans le proxy.\ **S'il vous plaît,** [**lisez ce guide pour apprendre comment installer un certificat CA personnalisé**](android-burp-suite-settings.md)**.** Pour les applications ciblant **API Level 24+ il ne suffit pas d'installer le certificat Burp** sur l'appareil. Pour contourner cette nouvelle protection, vous devez modifier le fichier de configuration de sécurité réseau. Ainsi, vous pouvez modifier ce fichier pour autoriser votre certificat CA ou vous pouvez [**lire cette page pour un tutoriel sur la façon de forcer l'application à accepter à nouveau tous les certificats installés sur l'appareil**](make-apk-accept-ca-certificate.md). **Épinglage SSL** Nous avons déjà discuté de ce qu'est l'épinglage SSL juste 2 paragraphes avant. Lorsqu'il est implémenté dans une application, vous devrez le contourner pour inspecter le trafic HTTPS ou vous ne le verrez pas.\ Ici, je vais présenter quelques options que j'ai utilisées pour contourner cette protection : * **Modifier automatiquement** l'**apk** pour **contourner** l'**épinglage SSL** avec [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Le meilleur avantage de cette option est que vous n'aurez pas besoin de root pour contourner l'épinglage SSL, mais vous devrez supprimer l'application et réinstaller la nouvelle, et cela ne fonctionnera pas toujours. * Vous pouvez utiliser **Frida** (discuté ci-dessous) pour contourner cette protection. Voici un guide pour utiliser Burp+Frida+Genymotion : [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) * Vous pouvez également essayer de **contourner automatiquement l'épinglage SSL** en utilisant [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` * Vous pouvez également essayer de **contourner automatiquement l'épinglage SSL** en utilisant **MobSF dynamic analysis** (expliqué ci-dessous) * Si vous pensez toujours qu'il y a du trafic que vous ne capturez pas, vous pouvez essayer de **rediriger le trafic vers burp en utilisant iptables**. Lisez ce blog : [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with ``` docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` Notez que MobSF peut analyser les applications **Android** (apk), **IOS** (ipa) et **Windows** (apx) (_les applications Windows doivent être analysées à partir d'un MobSF installé sur un hôte Windows_).\ De plus, si vous créez un fichier **ZIP** avec le code source d'une application **Android** ou **IOS** (allez dans le dossier racine de l'application, sélectionnez tout et créez un fichier ZIP), il sera également possible de l'analyser. MobSF vous permet également de **comparer/différencier** les analyses et d'intégrer **VirusTotal** (vous devrez définir votre clé API dans _MobSF/settings.py_ et l'activer : `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Vous pouvez également définir `VT_UPLOAD` sur `False`, alors le **hash** sera **téléchargé** au lieu du fichier. ### Analyse dynamique assistée avec MobSF **MobSF** peut également être très utile pour l'**analyse dynamique** sur **Android**, mais dans ce cas, vous devrez installer MobSF et **genymotion** sur votre hôte (une VM ou Docker ne fonctionnera pas). _Note : Vous devez **d'abord démarrer une VM dans genymotion** et **ensuite MobSF.**_\ L'analyseur dynamique de **MobSF** peut : * **Extraire les données de l'application** (URL, logs, presse-papiers, captures d'écran réalisées par vous, captures d'écran réalisées par "**Exported Activity Tester**", e-mails, bases de données SQLite, fichiers XML et autres fichiers créés). Tout cela est fait automatiquement sauf pour les captures d'écran, vous devez appuyer lorsque vous voulez une capture d'écran ou vous devez appuyer sur "**Exported Activity Tester**" pour obtenir des captures d'écran de toutes les activités exportées. * Capturer le **trafic HTTPS** * Utiliser **Frida** pour obtenir des **informations d'exécution** À partir des versions **> 5** d'Android, il démarrera **automatiquement Frida** et définira les paramètres de **proxy** globaux pour **capturer** le trafic. Il ne capturera que le trafic de l'application testée. **Frida** Par défaut, il utilisera également certains scripts Frida pour **contourner la vérification de l'empreinte SSL**, la **détection de root** et la **détection de débogueur** et pour **surveiller les API intéressantes**.\ MobSF peut également **appeler des activités exportées**, capturer des **captures d'écran** et les **enregistrer** pour le rapport. Pour **démarrer** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les journaux générés par les scripts Frida et "**Live API Monitor**" pour voir toutes les invocations des méthodes accrochées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\ MobSF vous permet également de charger vos propres **scripts Frida** (pour envoyer les résultats de vos scripts Frida à MobSF, utilisez la fonction `send()`). Il dispose également de **plusieurs scripts pré-écrits** que vous pouvez charger (vous pouvez en ajouter d'autres dans `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), il vous suffit de les **sélectionner**, d'appuyer sur "**Load**" et d'appuyer sur "**Start Instrumentation**" (vous pourrez voir les journaux de ces scripts dans "**Frida Live Logs**"). ![](<../../.gitbook/assets/image (215).png>) De plus, vous disposez de certaines fonctionnalités auxiliaires de Frida : * **Énumérer les classes chargées** : il affichera toutes les classes chargées * **Capturer les chaînes de caractères** : il affichera toutes les chaînes de caractères capturées lors de l'utilisation de l'application (très bruyant) * **Capturer les comparaisons de chaînes de caractères** : pourrait être très utile. Il **affichera les 2 chaînes de caractères comparées** et si le résultat était vrai ou faux. * **Énumérer les méthodes de classe** : mettez le nom de la classe (comme "java.io.File") et il affichera toutes les méthodes de la classe. * **Rechercher un modèle de classe** : recherche de classes par modèle * **Tracer les méthodes de classe** : **tracer** une **classe entière** (voir les entrées et sorties de toutes les méthodes de la classe). N'oubliez pas que par défaut, MobSF trace plusieurs méthodes Android Api intéressantes. Une fois que vous avez sélectionné le module auxiliaire que vous souhaitez utiliser, vous devez appuyer sur "**Start Intrumentation**" et vous verrez toutes les sorties dans "**Frida Live Logs**". **Shell** Mobsf vous offre également une shell avec quelques commandes **adb**, des commandes **MobSF** et des commandes **shell** courantes en bas de la page d'analyse dynamique. Quelques commandes intéressantes : ``` help shell ls activities exported_activities services receivers ``` **Outils HTTP** Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur "**HTTP(S) Traffic**" en bas ou une vue plus agréable sur "**Start HTTPTools**" en bas vert. À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxys** tels que Burp ou Owasp ZAP.\ Pour ce faire, _allumez Burp -->_ _désactivez Intercept --> dans MobSB HTTPTools sélectionnez la requête_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer sur "**Start Web API Fuzzer**" pour **fuzzer les requêtes http** et rechercher des vulnérabilités. {% hint style="info" %} Après avoir effectué une analyse dynamique avec MobSF, les paramètres de proxy peuvent être mal configurés et vous ne pourrez pas les corriger à partir de l'interface graphique. Vous pouvez corriger les paramètres de proxy en faisant: ``` adb shell settings put global http_proxy :0 ``` {% endhint %} ### Analyse Dynamique Assistée avec Inspeckage Vous pouvez obtenir l'outil à partir de [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ Cet outil utilise des **Hooks** pour vous informer de **ce qui se passe dans l'application** pendant que vous effectuez une **analyse dynamique**. {% content-ref url="inspeckage-tutorial.md" %} [inspeckage-tutorial.md](inspeckage-tutorial.md) {% endcontent-ref %} ### [Yaazhini](https://www.vegabird.com/yaazhini/) C'est un **excellent outil pour effectuer une analyse statique avec une interface graphique** ![](<../../.gitbook/assets/image (527).png>) ### [Qark](https://github.com/linkedin/qark) Cet outil est conçu pour rechercher plusieurs **vulnérabilités de sécurité liées aux applications Android**, soit dans le **code source** soit dans les **APK empaquetés**. L'outil est également **capable de créer un APK déployable "Proof-of-Concept"** et des **commandes ADB** pour exploiter certaines des vulnérabilités trouvées (activités exposées, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk qark --java path/to/parent/java/folder qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) * Affiche tous les fichiers extraits pour une référence facile * Décompile automatiquement les fichiers APK en format Java et Smali * Analyse AndroidManifest.xml pour les vulnérabilités et comportements courants * Analyse de code source statique pour les vulnérabilités et comportements courants * Informations sur l'appareil * Intents * Exécution de commandes * Références SQLite * Références de journalisation * Fournisseurs de contenu * Récepteurs de diffusion * Références de service * Références de fichiers * Références de cryptographie * Secrets codés en dur * URL * Connexions réseau * Références SSL * Références WebView ``` reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) SUPER est une application en ligne de commande qui peut être utilisée sur Windows, MacOS X et Linux, pour analyser les fichiers _.apk_ à la recherche de vulnérabilités. Elle le fait en décompressant les APKs et en appliquant une série de règles pour détecter ces vulnérabilités. Toutes les règles sont centrées dans un fichier `rules.json`, et chaque entreprise ou testeur peut créer ses propres règles pour analyser ce dont il a besoin. Téléchargez les derniers binaires sur la [page de téléchargement](https://superanalyzer.rocks/download.html). ``` super-analyzer {apk_file} ``` ### [StaCoAn](https://github.com/vincentcox/StaCoAn) ![](<../../.gitbook/assets/image (62).png>) StaCoAn est un outil **multiplateforme** qui aide les développeurs, les chasseurs de primes et les hackers éthiques à effectuer une [analyse de code statique](https://en.wikipedia.org/wiki/Static\_program\_analysis) sur les applications mobiles\*. Le concept est que vous faites glisser et déposez votre fichier d'application mobile (un fichier .apk ou .ipa) sur l'application StaCoAn et elle générera un rapport visuel et portable pour vous. Vous pouvez ajuster les paramètres et les listes de mots pour obtenir une expérience personnalisée. Téléchargez la [dernière version](https://github.com/vincentcox/StaCoAn/releases) : ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs\_Framework) AndroBugs Framework est un système d'analyse de vulnérabilités Android qui aide les développeurs ou les hackers à trouver des vulnérabilités de sécurité potentielles dans les applications Android.\ [Versions pour Windows](https://github.com/AndroBugs/AndroBugs\_Framework/releases) ``` python androbugs.py -f [APK file] androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) **Androwarn** est un outil dont le but principal est de détecter et d'avertir l'utilisateur des comportements malveillants potentiels développés par une application Android. La détection est effectuée avec l'**analyse statique** du bytecode Dalvik de l'application, représenté sous forme de **Smali**, avec la bibliothèque [`androguard`](https://github.com/androguard/androguard). Cet outil recherche les **comportements courants des "mauvaises" applications** tels que : l'exfiltration d'identifiants de téléphonie, l'interception de flux audio/vidéo, la modification de données PIM, l'exécution de code arbitraire... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` ### [MARA Framework](https://github.com/xtiankisutsa/MARA\_Framework) ![](<../../.gitbook/assets/image (81).png>) **MARA** est un **F**ramework d'**A**nalyse et de **R**étro-ingénierie d'**A**pplications **M**obiles. C'est un outil qui rassemble des outils couramment utilisés pour la rétro-ingénierie et l'analyse d'applications mobiles, pour aider à tester les applications mobiles contre les menaces de sécurité mobiles OWASP. Son objectif est de rendre cette tâche plus facile et plus conviviale pour les développeurs d'applications mobiles et les professionnels de la sécurité. Il est capable de : * Extraire du code Java et Smali en utilisant différents outils * Analyser les APK en utilisant : [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs\_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) * Extraire des informations privées de l'APK en utilisant des expressions régulières. * Analyser le Manifeste. * Analyser les domaines trouvés en utilisant : [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) et [whatweb](https://github.com/urbanadventurer/WhatWeb) * Déobfusquer l'APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous Utile pour détecter les malwares : [https://koodous.com/](https://koodous.com)

[**Suivez HackenProof**](https://bit.ly/3xrrDrL) **pour en savoir plus sur les bugs web3** 🐞 Lisez les tutoriels sur les bugs web3 🔔 Soyez informé des nouveaux programmes de primes pour bugs 💬 Participez aux discussions de la communauté ## Obfuscation/Déobfuscation de code Notez que selon le service et la configuration que vous utilisez pour obfusquer le code, les secrets peuvent être obfusqués ou non. ### [ProGuard](https://en.wikipedia.org/wiki/ProGuard\_\(software\)) **ProGuard** est un outil en ligne de commande open source qui réduit la taille, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et supprimer les instructions inutilisées. ProGuard est un logiciel gratuit distribué sous la licence publique générale GNU, version 2. ProGuard est distribué dans le cadre du kit de développement Android et s'exécute lors de la construction de l'application en mode release. À partir de : [https://en.wikipedia.org/wiki/ProGuard\_(software)](https://en.wikipedia.org/wiki/ProGuard\_\(software\)) ### [DexGuard](https://www.guardsquare.com/dexguard) Trouvez un guide étape par étape pour déobfusquer l'APK dans [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) (Dans ce guide) La dernière fois que nous avons vérifié, le mode de fonctionnement de Dexguard était : * charger une ressource en tant que InputStream ; * alimenter le résultat dans une classe héritant de FilterInputStream pour le décrypter ; * faire une obfuscation inutile pour faire perdre quelques minutes de temps à un réverseur ; * alimenter le résultat décrypté dans un ZipInputStream pour obtenir un fichier DEX ; * enfin, charger le DEX résultant en tant que ressource en utilisant la méthode `loadDex`. ### [DeGuard](http://apk-deguard.com) **DeGuard inverse le processus d'obfuscation effectué par les outils d'obfuscation Android. Cela permet de nombreuses analyses de sécurité, notamment l'inspection du code et la prédiction des bibliothèques.** Vous pouvez télécharger un APK obfusqué sur leur plateforme. ### [Simplify](https://github.com/CalebFenton/simplify) C'est un **déobfuscateur générique pour Android.** Simplify **exécute virtuellement une application** pour comprendre son comportement, puis **essaie d'optimiser le code** pour qu'il se comporte de manière identique mais soit plus facile à comprendre pour un humain. Chaque type d'optimisation est simple et générique, donc peu importe le type spécifique d'obfuscation utilisé. ### [APKiD](https://github.com/rednaga/APKiD) APKiD vous donne des informations sur **comment un APK a été créé**. Il identifie de nombreux **compilateurs**, **packers**, **obfuscateurs** et autres choses étranges. C'est [_PEiD_](https://www.aldeid.com/wiki/PEiD) pour Android. ### Manuel [Lisez ce tutoriel pour apprendre quelques astuces sur **comment inverser l'obfuscation personnalisée**](manual-deobfuscation.md) ## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui comprend la collection des derniers frameworks, tutoriels et laboratoires de différents geeks et chercheurs en sécurité pour la rétro-ingénierie et l'analyse de malwares. ### OWASP {% embed url="https://github.com/OWASP/owasp-mstg%0Ahttps://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06g-testing-network-communication" %} ### Dépôts Git [https://github.com/riddhi-shree/nullCommunity/tree/master/Android](https://github.com/riddhi-shree/nullCommunity/tree/master/Android)\ [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab\_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab\_channel=B3nacSec) ## Références Pour plus d'informations, visitez : * [https://appsecwiki.com/#/](https://appsecwiki.com/#/) C'est une excellente liste de ressources * [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Cours rapide sur Android * [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) * [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) ## À tester * [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) * [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

* Travaillez-vous