<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des pirates expérimentés et des chasseurs de primes !
Il est fortement recommandé de commencer par lire cette page pour en savoir plus sur les **parties les plus importantes liées à la sécurité Android et les composants les plus dangereux dans une application Android** :
Il vous permet de contrôler votre appareil via **USB** ou **Réseau** depuis un ordinateur, **copier** des fichiers dans les deux sens, **installer** et désinstaller des applications, exécuter des commandes **shell**, effectuer des **sauvegardes**, lire des **logs** et plus encore.
Parfois, il est intéressant de **modifier le code de l'application** pour accéder à des **informations cachées** (peut-être des mots de passe bien obfusqués ou des indicateurs). Ensuite, il pourrait être intéressant de décompiler l'APK, modifier le code et le recompiler.\
[Dans ce tutoriel](smali-changes.md), vous pouvez **apprendre à décompiler un APK, modifier le code Smali et recompiler l'APK** avec la nouvelle fonctionnalité. Cela pourrait être très utile comme **alternative pour plusieurs tests pendant l'analyse dynamique** qui vont être présentés. Ensuite, **gardez toujours à l'esprit cette possibilité**.
En examinant 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).
Portez une attention particulière 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)
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 du fichier **apk en .zip** et le **dézipper**.\
En lisant le **manifest**, vous pouvez trouver des **vulnérabilités** :
* Tout d'abord, vérifiez si **l'application est débogable**. Un 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 manifest l'attribut `debuggable="true"` à l'intérieur de la balise _\<application_ Exemple : `<application theme="@2131296387" debuggable="true"`
* [Apprenez ici](drozer-tutorial/#is-debuggeable) comment trouver des applications débogables sur un téléphone et les exploiter
* **Sauvegarde** : L'attribut **`android:allowBackup`** définit si les données de l'application peuvent être sauvegardées et restaurées par un utilisateur ayant activé le débogage USB. Si le drapeau de sauvegarde est défini sur true, cela permet à un attaquant de sauvegarder les données de l'application via adb même si l'appareil n'est pas rooté. Par conséquent, les applications qui gèrent et stockent des informations sensibles telles que les détails de carte, les mots de passe, etc. devraient avoir ce paramètre explicitement défini sur **false** car par défaut il est défini sur **true** pour éviter de tels risques.
* **Sécurité réseau** : La sécurité réseau de l'application peut écraser les valeurs par défaut avec **`android:networkSecurityConfig="@xml/network_security_config"`**. Un fichier portant ce nom peut être placé dans _**res/xml.**_ Ce fichier configurera des paramètres de sécurité importants comme les épingles de certificat ou s'il autorise le trafic HTTP. Vous pouvez lire ici plus d'informations sur tout ce qui peut être configuré, mais vérifiez cet exemple sur la configuration du trafic HTTP pour certains domaines :
* **Activités exportées** : Vérifiez les activités exportées dans le manifest car cela pourrait être dangereux. Plus tard dans l'analyse dynamique, il sera expliqué comment [exploiter ce comportement](./#exploiting-exported-activities-authorisation-bypass).
* **Fournisseurs de contenu** : Si un fournisseur exporté est exposé, vous pourriez 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** dans 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 fait le service 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) pendant l'analyse dynamique.
* **Schéma d'URL** : Lisez le code de l'activité gérant le schéma et recherchez des vulnérabilités dans la gestion de l'entrée de l'utilisateur. Plus d'infos 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 à des versions d'Android vulnérables connues de l'exécuter.
**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 visuellement l'application victime, son interface utilisateur est conçue de manière à tromper l'utilisateur pour qu'il interagisse avec elle, tout en transmettant l'interaction à l'application victime.\
Une **activité** avec le **`launchMode`** défini sur **`singleTask` sans aucune `taskAffinity`** définie est vulnérable au détournement de tâche. Cela signifie qu'une **application** peut être installée et si elle est lancée avant la vraie application, elle pourrait **détourner la tâche de la vraie application** (ainsi l'utilisateur interagira avec la **mauvaise application en pensant qu'il utilise la vraie**).
Sur Android, les fichiers **stockés** dans le **stockage interne** sont **conçus** pour être **accessibles** exclusivement par l'**application** qui les a **créés**. Cette mesure de sécurité est **appliquée** par le système d'exploitation Android et est généralement adéquate pour les besoins de sécurité de la plupart des applications. Cependant, les développeurs utilisent parfois des modes tels que `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` pour **permettre** aux fichiers d'être **partagés** entre différentes applications. Cependant, ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris potentiellement malveillantes.
1.**Analyse statique :**
- **Assurez-vous** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` est **soigneusement examinée**. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non voulu ou non autorisé**.
2.**Analyse dynamique :**
- **Vérifiez** les **autorisations** définies sur les fichiers créés par l'application. En particulier, **vérifiez** si des fichiers sont **définis comme lisibles ou modifiables mondialement**. Cela peut poser un risque de sécurité important, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers.
### Directives pour la gestion des fichiers sur le stockage externe
Lorsque vous travaillez avec des fichiers sur le **stockage externe**, comme les cartes SD, certaines précautions doivent être prises :
1.**Accessibilité** :
- Les fichiers sur le stockage externe sont **lisibles et modifiables mondialement**. Cela signifie que n'importe quelle application ou utilisateur peut accéder à ces fichiers.
2.**Préoccupations de sécurité** :
- Étant donné la facilité d'accès, il est conseillé de **ne pas stocker d'informations sensibles** sur le stockage externe.
- Le stockage externe peut être retiré ou accédé par n'importe quelle application, le rendant moins sécurisé.
3.**Traitement des données provenant du stockage externe** :
- Effectuez toujours une **validation des entrées** sur les données récupérées depuis le stockage externe. Cela est crucial car les données proviennent d'une source non fiable.
- Il est fortement déconseillé de stocker des exécutables ou des fichiers de classe sur le stockage externe pour un chargement dynamique.
- Si votre application doit récupérer des fichiers exécutables depuis le stockage externe, assurez-vous que ces fichiers sont **signés et vérifiés cryptographiquement** avant d'être chargés dynamiquement. Cette étape est essentielle pour maintenir l'intégrité de sécurité de votre application.
À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoire qui **limite l'accès d'une application au répertoire spécifique à cette application**. Cela empêche une application malveillante 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/<nomdupackage>/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/<nomdupackage>/databases/` et parfois il est possible de trouver des informations sensibles en clair dans ce dossier.
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 :
Certains développeurs enregistrent des données sensibles dans le stockage local et les chiffrent avec une clé codée/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.
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 **hashes** sont utilisés pour stocker des mots de passe par exemple, des hashes résistants à la **brute-force** devraient être utilisés avec un sel.
* Il est recommandé d'**obfusquer l'APK** pour compliquer 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.
Selon ce [**billet de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked est un méta-algorithme qui compresse le contenu d'une application dans un seul fichier. Le blog parle de la possibilité de créer une application qui décompresse ce type d'applications... et d'une manière plus rapide qui implique d'**exécuter l'application et de rassembler les fichiers décompressés du système de fichiers**.
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**), des **sinks** (qui indiquent à l'outil les **endroits dangereux** où une entrée utilisateur malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-sinks** qui indique une vulnérabilité.
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 pourriez utiliser un outil tel que [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes en sécurité !
> 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 rooté (émulé ou non) est extrêmement recommandé.
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, ce qui est utile pour voir comment un APK se comporte.
* [**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).
* [**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._)
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. Sélectionnez donc de petits écrans si possible.
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 depuis une autre machine virtuelle avec les outils).
> 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**, ainsi nous pourrons **apprendre comment l'application fonctionne** tandis que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard.
Souvent, les développeurs laissent des informations de débogage en public. Ainsi, toute application avec l'autorisation `READ_LOGS` peut **accéder à ces journaux** et peut obtenir des informations sensibles à travers cela.\
En naviguant dans l'application, utilisez [**pidcat**](https://github.com/JakeWharton/pidcat)_(Recommandé, plus facile à utiliser et à lire_) ou [adb logcat](adb-commands.md#logcat) pour lire les journaux créés et **rechercher des informations sensibles**.
Notez que à partir d'**Android 4.0**, les **applications ne peuvent accéder qu'à leurs propres journaux**. Les applications ne peuvent donc pas accéder aux journaux d'autres applications.\
Quoi qu'il en soit, il est toujours recommandé de **ne pas journaliser d'informations sensibles**.
Android fournit un **cadre basé sur le presse-papiers** pour fournir la fonction copier-coller dans les applications Android. Mais cela crée un problème sérieux lorsque certaines **autres applications** peuvent **accéder** au **presse-papiers** qui contient des données sensibles. La fonction de **copier-coller** devrait être **désactivée** pour la **partie sensible** de l'application. Par exemple, désactivez la copie des détails de la carte de crédit.
Si une application **plante** pendant l'exécution et qu'elle **enregistre des journaux** quelque part, ces journaux peuvent être utiles à un attaquant, surtout dans les cas où l'application Android ne peut pas être rétro-ingéniée. Ensuite, évitez de créer des journaux lorsque les applications plantent et si les journaux sont envoyés sur le réseau, assurez-vous qu'ils sont envoyés sur un canal SSL.\
En tant que testeur d'intrusion, **essayez de jeter un œil à ces journaux**.
La plupart des applications utilisent d'autres services dans leur application comme Google Adsense mais parfois elles **divulguent certaines données sensibles** ou des données qui ne sont pas nécessaires à envoyer à ce service. Cela peut arriver parce que le développeur n'a pas implémenté correctement la fonctionnalité. Vous pouvez **vérifier en interceptant le trafic** de l'application et voir si des données sensibles sont envoyées à des tiers ou non.
La plupart des applications utiliseront des **bases de données SQLite internes** pour enregistrer des informations. Pendant le test d'intrusion, jetez un **œil** aux **bases de données** créées, aux noms des **tables** et des **colonnes** et à toutes les **données** enregistrées car vous pourriez trouver des **informations sensibles** (ce qui serait une vulnérabilité).\
Les bases de données devraient être situées dans `/data/data/le.nom.du.package/databases` comme `/data/data/com.mwr.example.sieve/databases`
Si la base de données enregistre des informations confidentielles et est **chiffrée** mais que vous pouvez **trouver** le **mot de passe** à l'intérieur de l'application, c'est toujours une **vulnérabilité**.
**Drozer** vous permet de **prendre le rôle d'une application Android** et d'interagir avec d'autres applications. Il peut faire **tout ce qu'une application installée peut faire**, comme utiliser le mécanisme de communication inter-processus (IPC) d'Android et interagir avec le système d'exploitation sous-jacent. À partir du [Guide Drozer](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf).\
Drozer est un outil utile pour **exploiter les activités exportées, les services exportés et les fournisseurs de contenu** comme vous le verrez dans les sections suivantes.
Lorsqu'une activité est exportée, vous pouvez invoquer son écran à partir d'une application externe. Par conséquent, si une activité avec des **informations sensibles** est **exportée**, vous pourriez **contourner** les **mécanismes d'authentification** pour y accéder.\
**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), apparemment cela n'est dangereux que sur les anciennes versions (versions d'API <21).
Notez qu'une contournement d'autorisation n'est pas toujours une vulnérabilité, cela dépend de la manière dont le contournement fonctionne et des informations exposées.
**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 s'agit d'une fuite d'informations sensibles.
Si le tapjacking n'est pas empêché, vous pourriez abuser de l'activité exportée pour faire effectuer à l'**utilisateur des actions inattendues**. Pour plus d'informations sur [**ce qu'est le Tapjacking, suivez le lien**](./#tapjacking).
Les fournisseurs de contenu sont essentiellement utilisés pour **partager des données**. Si une application dispose de fournisseurs de contenu disponibles, vous pourriez être en mesure d'**extraire des données sensibles** d'eux. Il est également intéressant de tester d'éventuelles **injections SQL** et **traversées de chemin** car elles pourraient être vulnérables.\
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 devriez **vérifier** le **code** pour comprendre ce qu'il fait et le **tester** de manière **dynamique** pour extraire des informations confidentielles, contourner les mesures d'authentification...\
[**Apprenez comment exploiter les Services avec Drozer.**](drozer-tutorial/#services)
Vous pouvez rechercher manuellement des liens profonds, en utilisant des outils comme MobSF ou des scripts comme [celui-ci](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
Pour trouver le **code qui sera exécuté dans l'application**, allez à l'activité appelée par le lien profond et recherchez la fonction **`onNewIntent`**.
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 !**
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 bons points de terminaison à l'intérieur de l'application, vous pourriez être en mesure de provoquer 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 de terminaison 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/).
* **Absence d'inspection de certificat :** L'application Android ne parvient pas à vérifier 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 font passer 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 de type MITM. Ainsi, tout attaquant peut facilement décrypter cette connexion.
* **Fuite d'informations de confidentialité :** Il arrive souvent que les applications effectuent l'authentification via un canal sécurisé mais que toutes les autres connexions se fassent via un canal non sécurisé. Cela n'ajoute pas à la sécurité de l'application car d'autres données sensibles comme le cookie de session ou les données utilisateur peuvent être interceptées par un utilisateur malveillant.
Parmi les 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 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 découverte et la correction de ce type de vulnérabilités [**ici**](https://manifestsecurity.com/android-application-security-part-10/).
Par défaut, lors de l'établissement d'une connexion SSL, 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 pose un problème d'**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é.\
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.\
**Veuillez,** [**lire ce guide pour apprendre comment installer un certificat CA personnalisé**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine)**.**
Pour les applications ciblant **l'API Level 24+ il ne suffit pas d'installer le certificat CA de Burp** sur l'appareil. Pour contourner cette nouvelle protection, vous devez modifier le fichier de configuration de la sécurité réseau. Ainsi, vous pourriez modifier ce fichier pour autoriser votre certificat CA ou vous pouvez [**lire cette page pour un tutoriel sur comment forcer l'application à accepter à nouveau tous les certificats installés sur l'appareil**](make-apk-accept-ca-certificate.md).
Nous avons déjà discuté de ce qu'est l'épinglage SSL juste 2 paragraphes plus tôt. 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 principal 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 pourriez 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 **l'analyse dynamique de MobSF** (expliquée 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-ip-forwarding-iptables-568171b52b62)
Notez qu'à cette étape, vous devriez rechercher des vulnérabilités Web courantes. Beaucoup d'informations sur les vulnérabilités Web se trouvent dans ce livre, donc je ne vais pas les mentionner ici.
Boîte à outils d'instrumentation dynamique pour les développeurs, les reverse-engineers et les chercheurs en sécurité. En savoir plus sur [www.frida.re](https://www.frida.re).\
**C'est incroyable, vous pouvez accéder à une application en cours d'exécution et accrocher des méthodes en temps réel pour changer le comportement, changer les valeurs, extraire des valeurs, exécuter un code différent...**\
**Apprenez à utiliser Frida :** [**Tutoriel Frida**](frida-tutorial/)\
**Quelques "GUI" pour les actions avec Frida :** [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)\
**Quelques autres abstractions basées sur Frida :** [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)\
**Vous pouvez trouver quelques scripts Frida impressionnants ici :** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
Sur Android, le Keystore est le meilleur endroit pour stocker des données sensibles, cependant, avec suffisamment de privilèges, il est toujours **possible d'y accéder**. Comme les applications ont tendance à stocker ici des **données sensibles en texte clair**, les tests d'intrusion doivent vérifier cela car un utilisateur root ou quelqu'un ayant un accès physique à l'appareil pourrait voler ces données.
Pour accéder aux données à l'intérieur du keystore, vous pouvez utiliser ce script Frida : [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
En utilisant le script Frida suivant, il pourrait être possible de **contourner l'authentification par empreinte digitale** que les applications Android pourraient effectuer afin de **protéger certaines zones sensibles :**
Lorsque vous mettez une application en arrière-plan, Android stocke une **capture d'écran de l'application** afin que lorsqu'elle revienne à l'avant-plan, elle commence à charger l'image avant l'application pour donner l'impression que l'application a été chargée plus rapidement.
Cependant, si cette capture d'écran contient des **informations sensibles**, une personne ayant accès à la capture d'écran pourrait **voler ces informations** (notez que vous avez besoin des droits root pour y accéder).
Android propose un moyen de **prévenir la capture d'écran en définissant le paramètre de mise en page FLAG\_SECURE**. En utilisant ce drapeau, le contenu de la fenêtre est traité comme sécurisé, l'empêchant d'apparaître dans les captures d'écran ou d'être affiché sur des écrans non sécurisés.
Cet outil pourrait vous aider à gérer différents outils lors de l'analyse dynamique : [https://github.com/NotSoSecure/android\_application\_analyzer](https://github.com/NotSoSecure/android\_application\_analyzer)
Cette vulnérabilité ressemble à **l'Open Redirect en sécurité web**. Puisque la classe `Intent` est `Parcelable`, **les objets appartenant à cette classe** peuvent être **transmis** en tant que **données supplémentaires** dans un autre objet `Intent`.\
De nombreux développeurs **utilisent** cette **fonctionnalité** et créent des **composants proxy** (activités, récepteurs de diffusion et services) qui **prennent un Intent intégré et le transmettent à des méthodes dangereuses** telles que `startActivity(...)`, `sendBroadcast(...)`, etc.\
C'est dangereux car **un attaquant peut forcer l'application à lancer un composant non exporté qui ne peut pas être lancé directement depuis une autre application**, ou à accorder à l'attaquant l'accès à ses fournisseurs de contenu. **`WebView`** change parfois une **URL d'une chaîne en un objet `Intent`**, en utilisant la méthode `Intent.parseUri(...)`, et le transmet à `startActivity(...)`.
Vous connaissez probablement ce type de vulnérabilités du Web. Vous devez être particulièrement prudent avec ces vulnérabilités dans une application Android :
* **Injection JavaScript (XSS) :** Vérifiez que le support JavaScript et des plugins est désactivé pour tout WebView (désactivé par défaut). [Plus d'informations ici](webview-attacks.md#javascript-enabled).
* **Inclusion de fichiers locaux :** Vérifiez que l'accès au système de fichiers est désactivé pour tout WebView (activé par défaut) `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'informations ici](webview-attacks.md#javascript-enabled).
* **Cookies éternels** : Dans plusieurs cas, lorsque l'application Android termine la session, le cookie n'est pas révoqué ou il pourrait même être enregistré sur le disque.
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes en bugs !
**Évaluation des vulnérabilités de l'application** en utilisant une interface web conviviale. Vous pouvez également effectuer une analyse dynamique (mais vous devez préparer l'environnement).
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 pourra également l'analyser.
MobSF vous permet également de **diff/Comparer** 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 = <Votre clé API>``VT_UPLOAD = TRUE`). Vous pouvez également définir `VT_UPLOAD` sur `False`, puis le **hash** sera **téléchargé** au lieu du fichier.
**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 machine virtuelle ou Docker ne fonctionnera pas). _Remarque : Vous devez **d'abord démarrer une machine virtuelle dans genymotion** et **ensuite MobSF**._\
* **Extraire les données de l'application** (URL, journaux, 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.
À partir des versions d'Android > 5, il **démarrera automatiquement Frida** et définira les paramètres de **proxy** globaux pour **capturer** le trafic. Il ne capturera le trafic que de l'application testée.
Par défaut, il utilisera également certains scripts Frida pour **contourner l'épinglage 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 **sauvegarder** 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 à l'intérieur de "**Frida Live Logs**").
* **Énumérer les classes chargées** : Il affichera toutes les classes chargées
* **Capturer les chaînes** : Il affichera toutes les chaînes capturées lors de l'utilisation de l'application (très bruyant)
* **Capturer les comparaisons de chaînes** : Peut être très utile. Il **affichera les 2 chaînes 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 motif de classe** : Rechercher des classes par motif
* **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 intéressantes de l'API Android.
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**".
Mobsf vous propose également un shell avec quelques commandes **adb**, commandes **MobSF**, et commandes **shell** courantes en bas de la page d'analyse dynamique. Quelques commandes intéressantes :
Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur le bas de "**HTTP(S) Traffic**" ou une vue plus agréable sur le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** vers des **proxies** comme 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.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.
Après avoir effectué une analyse dynamique avec MobSF, les paramètres du proxy peuvent être mal configurés et vous ne pourrez pas les corriger depuis l'interface graphique. Vous pouvez corriger les paramètres du proxy en effectuant :
Vous pouvez obtenir l'outil sur [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
Cet outil utilisera certains **Hooks** pour vous informer de **ce qui se passe dans l'application** pendant que vous effectuez une **analyse dynamique**.
Cet outil est conçu pour rechercher plusieurs **vulnérabilités liées à la sécurité des applications Android**, que ce soit dans le **code source** ou 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, intentions, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test.
SUPER est une application en ligne de commande qui peut être utilisée sous Windows, MacOS X et Linux, pour analyser les fichiers _.apk_ à la recherche de vulnérabilités. Cela se fait en décompressant les APK et en appliquant une série de règles pour détecter ces vulnérabilités.
Toutes les règles sont regroupées dans un fichier `rules.json`, et chaque entreprise ou testeur peut créer ses propres règles pour analyser ce dont ils ont besoin.
StaCoAn est un outil **multiplateforme** qui aide les développeurs, les chasseurs de bugs 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.
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.\
**Androwarn** est un outil dont le but principal est de détecter et 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 applications "malveillantes"** tels que : l'exfiltration des identifiants de téléphonie, l'interception du flux audio/vidéo, la modification des données PIM, l'exécution de code arbitraire...
**MARA** est un **C**adre d'**A**nalyse et d'**I**ngénierie **R**everse d'**A**pplications **M**obiles. C'est un outil qui regroupe des outils couramment utilisés pour l'ingénierie inverse et l'analyse d'applications mobiles, pour aider à tester les applications mobiles contre les menaces de sécurité mobiles de l'OWASP. Son objectif est de rendre cette tâche plus facile et conviviale pour les développeurs d'applications mobiles et les professionnels de la sécurité.
* 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)
**ProGuard** est un outil en ligne de commande open source qui réduit, 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.
**DeGuard inverse le processus d'obfuscation effectué par les outils d'obfuscation Android. Cela permet de nombreuses analyses de sécurité, y compris l'inspection du code et la prédiction des bibliothèques.**
Il s'agit d'un **déobfuscateur Android générique.** 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 vous donne des informations sur **comment un APK a été créé**. Il identifie de nombreux **compilateurs**, **packers**, **obfuscateurs**, et d'autres choses étranges. C'est [_PEiD_](https://www.aldeid.com/wiki/PEiD) pour Android.
AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut la collection des derniers frameworks, tutoriels et laboratoires de différents geeks de la sécurité et chercheurs pour l'ingénierie inverse et l'analyse de logiciels malveillants.
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes en bugs!
<summary><strong>Apprenez le hacking AWS de zéro à héros avec</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de hacking en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
