From fe001276e421522225e4123a9a2fcb0211563354 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 8 Sep 2025 01:34:32 +0000 Subject: [PATCH] Translated ['', 'src/mobile-pentesting/android-app-pentesting/android-an --- .../android-app-pentesting/README.md | 502 +++++++++--------- ...-instrumentation-and-ssl-pinning-bypass.md | 131 +++-- .../avd-android-virtual-device.md | 143 +++-- .../frida-tutorial/README.md | 97 +++- .../install-burp-certificate.md | 62 ++- 5 files changed, 570 insertions(+), 365 deletions(-) diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 9ceb1cf78..91a07ac47 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,10 @@ -# Pentesting des Applications Android +# Pentesting des applications Android {{#include ../../banners/hacktricks-training.md}} -## Notions de base des Applications Android +## Notions de base des applications Android -Il est fortement recommandé de commencer par lire cette page pour connaître les **parties les plus importantes liées à la sécurité Android et les composants les plus dangereux d'une application Android** : +It's highly recommended to start reading this page to know about the **most important parts related to Android security and the most dangerous components in an Android application**: {{#ref}} @@ -13,15 +13,15 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -C'est l'outil principal dont vous avez besoin pour vous connecter à un appareil Android (émulé ou physique).\ -**ADB** permet de contrôler des appareils soit via **USB** soit via **Network** depuis un ordinateur. Cet outil permet la **copie** de fichiers dans les deux sens, l'**installation** et la **désinstallation** d'apps, l'**exécution** de commandes shell, la **sauvegarde** des données, la **lecture** des logs, entre autres fonctions. +This is the main tool you need to connect to an android device (emulated or physical).\ +**ADB** allows to control devices either over **USB** or **Network** from a computer. This utility enables the **copying** of files in both directions, **installation** and **uninstallation** of apps, **execution** of shell commands, **backing up** of data, **reading** of logs, among other functions. -Consultez la liste suivante des [**ADB Commands**](adb-commands.md) pour apprendre à utiliser adb. +Consultez la liste suivante de [**ADB Commands**](adb-commands.md) pour apprendre à utiliser adb. ## Smali -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 fortement obfusqués ou des flags). Dans ce cas, il peut être utile de décompiler le apk, modifier le code et le recompiler.\ -[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Cela peut être très utile comme **alternative pour plusieurs tests lors de l'analyse dynamique** qui vont être présentés. Ainsi, **gardez toujours à l'esprit cette possibilité**. +Parfois il est intéressant de **modifier le code de l'application** pour accéder à des **informations cachées** (maybe well obfuscated passwords or flags). Then, it could be interesting to decompile the apk, modify the code and recompile it.\ +[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Cela peut être très utile comme **alternative pour plusieurs tests lors de l'analyse dynamique** qui sont going to presented. Then, **keep always in mid this possibility**. ## Autres astuces intéressantes @@ -63,37 +63,37 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Analyse statique -Tout d'abord, pour analyser un APK vous devriez **examiner le code Java** à l'aide d'un decompiler.\ -Veuillez, [**lire ici pour trouver des informations sur les différents decompilers disponibles**](apk-decompilers.md). +Tout d'abord, pour analyser un APK vous devriez **regarder le code Java** en utilisant un décompilateur.\ +Veuillez [**lire ici pour trouver des informations sur les différents décompilateurs disponibles**](apk-decompilers.md). ### Recherche d'informations intéressantes -En examinant simplement les **strings** de l'APK vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des éléments liés à **encryption**, des **bluetooth uuids**, des **tokens** et tout ce qui est intéressant... cherchez même des backdoors d'exécution de code ou des backdoors d'authentification (credentials admin hardcodés dans l'app). +En regardant simplement les **strings** de l'APK vous pouvez rechercher des **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des **api** keys, **encryption**, **bluetooth uuids**, **tokens** et tout ce qui est intéressant... cherchez même des backdoors d'exécution de code ou des backdoors d'authentification (hardcoded admin credentials dans l'app). **Firebase** -Portez une attention particulière aux **Firebase URLs** et vérifiez si la configuration est incorrecte. [Plus d'informations sur ce qu'est Firebase et comment l'exploiter ici.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Faites particulièrement attention aux **firebase URLs** et vérifiez si elles sont mal configurées. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Compréhension de base de l'application - Manifest.xml, strings.xml +### Compréhension basique de l'application - Manifest.xml, strings.xml -L'**examen des fichiers _Manifest.xml_ et _strings.xml_ d'une application peut révéler des vulnérabilités de sécurité potentielles**. Ces fichiers peuvent être consultés avec des decompilers ou en renommant l'extension du fichier APK en .zip puis en le décompressant. +L'**examen des fichiers _Manifest.xml_ et _strings.xml_ d'une application peut révéler des vulnérabilités de sécurité potentielles**. Ces fichiers peuvent être consultés avec des décompilateurs ou en renommant l'extension du fichier APK en .zip puis en le décompressant. -**Vulnérabilités** identifiées à partir du **Manifest.xml** incluent : +Les **vulnérabilités** identifiées dans le **_Manifest.xml_** incluent : -- **Applications debuggables**: Les applications définies comme debuggable (`debuggable="true"`) dans le fichier _Manifest.xml_ présentent un risque car elles permettent des connexions qui peuvent mener à une exploitation. Pour mieux comprendre comment exploiter des applications debuggables, consultez un tutoriel sur la découverte et l'exploitation d'applications debuggables sur un device. -- **Paramètres de backup**: L'attribut `android:allowBackup="false"` devrait être explicitement défini pour les applications traitant des informations sensibles afin d'empêcher des sauvegardes non autorisées via adb, surtout lorsque usb debugging est activé. -- **Network Security**: Des configurations réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité comme le pinning de certificats et les paramètres de trafic HTTP. Un exemple est d'autoriser le trafic HTTP pour des domaines spécifiques. -- **Exported Activities and Services**: Identifier les activités et services exportés dans le manifest peut mettre en évidence des composants susceptibles d'être détournés. Une analyse plus poussée lors des tests dynamiques peut révéler comment exploiter ces composants. -- **Content Providers and FileProviders**: Des content providers exposés pourraient permettre un accès ou une modification non autorisés des données. La configuration des FileProviders doit également être examinée. -- **Broadcast Receivers and URL Schemes**: Ces composants pourraient être utilisés pour l'exploitation, en portant une attention particulière à la manière dont les URL schemes sont gérés pour les vulnérabilités d'entrée. -- **SDK Versions**: Les attributs `minSdkVersion`, `targetSDKVersion`, et `maxSdkVersion` indiquent les versions Android supportées, soulignant l'importance de ne pas supporter des versions Android obsolètes et vulnérables pour des raisons de sécurité. +- **Applications débogables** : Les applications marquées comme debuggable (`debuggable="true"`) dans le fichier _Manifest.xml_ présentent un risque car elles permettent des connexions pouvant conduire à une exploitation. Pour mieux comprendre comment exploiter des applications debuggable, référez-vous à un tutoriel sur la découverte et l'exploitation des applications debuggable sur un appareil. +- **Paramètres de backup** : L'attribut `android:allowBackup="false"` devrait être explicitement défini pour les applications traitant des informations sensibles afin d'empêcher des sauvegardes de données non autorisées via adb, surtout lorsque USB debugging est activé. +- **Sécurité réseau** : Les configurations de security réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité tels que le certificate pinning et les paramètres du trafic HTTP. Un exemple est d'autoriser le trafic HTTP pour des domaines spécifiques. +- **Activities et Services exportés** : Identifier les activities et services exportés dans le manifest peut mettre en évidence des composants susceptibles d'être abusés. Une analyse plus poussée lors de tests dynamiques peut révéler comment exploiter ces composants. +- **Content Providers et FileProviders** : Des content providers exposés pourraient permettre un accès ou une modification non autorisés des données. La configuration des FileProviders doit aussi être examinée. +- **Broadcast Receivers et URL Schemes** : Ces composants pourraient être exploités, en prêtant une attention particulière à la gestion des URL schemes pour les vulnérabilités d'entrée. +- **Versions SDK** : Les attributs `minSdkVersion`, `targetSDKVersion` et `maxSdkVersion` indiquent les versions Android supportées, soulignant l'importance de ne pas supporter des versions Android obsolètes et vulnérables pour des raisons de sécurité. -À partir du fichier **strings.xml**, des informations sensibles telles que des clés API, des schemas personnalisés et d'autres notes de développeurs peuvent être découvertes, ce qui souligne la nécessité d'un examen attentif de ces ressources. +À partir du fichier **strings.xml**, des informations sensibles telles que des API keys, des custom schemas et d'autres notes de développeur peuvent être découvertes, ce qui souligne la nécessité d'un examen attentif de ces ressources. ### Tapjacking -**Tapjacking** est une attaque où une **malicious application** 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 telle manière qu'elle trompe l'utilisateur pour qu'il interagisse avec elle, tout en transmettant l'interaction à l'application victime.\ -En pratique, c'est **aveugler l'utilisateur afin qu'il ne sache pas qu'il effectue en réalité des actions sur l'application victime**. +Le **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, tandis qu'elle transmet l'interaction à l'application victime.\ +En effet, c'est **empêcher l'utilisateur de savoir qu'il effectue en réalité des actions sur l'application victime**. Find more information in: @@ -104,7 +104,7 @@ tapjacking.md ### Task Hijacking -Une **activity** avec le **`launchMode`** défini sur **`singleTask` sans aucun `taskAffinity`** est vulnérable au Task Hijacking. 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 **malicious application** en pensant utiliser la vraie). +Une **activity** avec le `launchMode` réglé sur `singleTask` sans `taskAffinity` défini est vulnérable au **Task Hijacking**. Cela signifie qu'une **application** peut être installée et, si elle est lancée avant la vraie application, elle pourrait **détourner la task de la vraie application** (l'utilisateur interagira donc avec l'application malveillante en pensant utiliser la vraie). More info in: @@ -115,78 +115,78 @@ android-task-hijacking.md ### Stockage de données non sécurisé -Internal Storage +**Stockage interne** -En Android, les fichiers **stockés** en **internal** storage sont **conçus** pour être **accessibles** exclusivement par l'**app** 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** que des fichiers soient **partagés** entre différentes applications. Or, ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris potentiellement malveillantes. +Sur Android, les fichiers **stockés** en **stockage interne** sont **conçus** pour être **accessibles** exclusivement par l'**app** 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 suffisante 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** le partage de fichiers entre différentes applications. Ces modes **n'empêchent pas l'accès** à ces fichiers par d'autres applications, y compris potentiellement malveillantes. -1. **Static Analysis:** -- **Vérifier** soigneusement l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE`. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non intentionnel ou non autorisé**. -2. **Dynamic Analysis:** -- **Valider** les **permissions** définies sur les fichiers créés par l'app. Plus précisément, **vérifiez** si des fichiers sont **réglés comme lisibles ou modifiables par tous**. Cela peut constituer un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur le device, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers. +1. **Analyse statique :** +- **Vérifiez** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` est **examinée attentivement**. Ces modes **peuvent potentiellement exposer** des fichiers à un accès non intentionnel ou non autorisé. +2. **Analyse dynamique :** +- **Vérifiez** les **permissions** définies sur les fichiers créés par l'app. Plus précisément, **vérifiez** si des fichiers sont définis comme lisibles ou modifiables par tous. Cela peut représenter un risque de sécurité important, car cela permettrait à **toute application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers. -External Storage +**Stockage externe** -Lorsqu'on traite des fichiers sur le **external storage**, comme les SD Cards, certaines précautions doivent être prises : +Lorsqu'on traite des fichiers sur le **stockage externe**, comme les cartes SD, certaines précautions doivent être prises : -1. **Accessibilité**: -- Les fichiers sur external storage sont **globalement lisibles et modifiables**. 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 l'external storage. -- L'external storage peut être retiré ou accédé par n'importe quelle application, le rendant moins sécurisé. -3. **Traitement des données provenant de l'external storage**: -- Effectuez toujours une **validation d'entrée** sur les données récupérées depuis l'external storage. C'est crucial car ces données proviennent d'une source non fiable. -- Il est fortement déconseillé de stocker des exécutables ou des fichiers de classes sur external storage pour les charger dynamiquement. -- Si votre application doit récupérer des fichiers exécutables depuis l'external storage, assurez-vous que ces fichiers sont **signés et vérifiés cryptographiquement** avant d'être chargés dynamiquement. Cette étape est vitale pour maintenir l'intégrité de sécurité de votre application. +1. **Accessibilité** : +- Les fichiers sur le stockage externe sont **globalement lisibles et modifiables**. Cela signifie que n'importe quelle application ou utilisateur peut accéder à ces fichiers. +2. **Problèmes 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ûr. +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. Ceci 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 la sécurité de votre application. -External storage peut être **accédé** dans `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` +Le stockage externe peut être **accédé** dans `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] -> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files. +> À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoires qui **limite l'accès d'une app au répertoire qui lui est spécifiquement dédié**. Cela empêche une application malveillante d'obtenir un accès en lecture ou écriture aux fichiers d'une autre app. -Données sensibles stockées en clair +**Données sensibles stockées en clair** -- **Shared preferences**: Android permet à chaque application de facilement sauvegarder des fichiers xml dans le chemin `/data/data//shared_prefs/` et parfois il est possible de trouver des informations sensibles en clear-text dans ce dossier. -- **Databases**: Android permet à chaque application de facilement sauvegarder des bases sqlite dans le chemin `/data/data//databases/` et parfois il est possible de trouver des informations sensibles en clear-text dans ce dossier. +- **Shared preferences** : Android permet à chaque application de facilement sauvegarder 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. +- **Databases** : Android permet à chaque application de sauvegarder facilement des bases sqlite dans le chemin `/data/data//databases/` et parfois il est possible de trouver des informations sensibles en clair dans ce dossier. -### TLS compromis +### TLS cassé -Accepter tous les certificats +**Accept All Certificates** -Pour une raison quelconque, certains développeurs acceptent parfois tous les certificats même si, par exemple, le hostname ne correspond pas, avec des lignes de code comme la suivante : +Pour une raison quelconque, parfois des développeurs acceptent tous les certificats même si, par exemple, le hostname 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 hostname différent et l'utiliser. +Une bonne façon de tester cela est d'essayer de capturer le traffic en utilisant un proxy comme Burp sans autoriser le Burp CA sur l'appareil. Aussi, vous pouvez générer avec Burp un certificat pour un hostname différent et l'utiliser. ### Cryptographie défaillante -**Mauvaises pratiques de gestion des clés** +**Mauvaises procédures de gestion des 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 du reversing pourrait permettre à des attaquants d'extraire l'information confidentielle. +Certains développeurs sauvegardent des données sensibles dans le stockage local et les chiffrent avec une clé hardcodée/prédictible dans le code. Cela ne devrait pas être fait car un peu de reversing pourrait permettre à des attackers d'extraire l'information confidentielle. **Utilisation d'algorithmes non sécurisés et/ou obsolètes** -Les développeurs ne devraient pas utiliser des **deprecated algorithms** pour effectuer des **checks** d'authorisation, **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, il faut utiliser des hashes résistants au brute-force avec du salt. +Les développeurs ne devraient pas utiliser d'**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** au brute-force devraient être utilisés avec du salt. ### Autres vérifications -- Il est recommandé d'**obfusquer l'APK** pour rendre plus difficile le travail de reverse engineering pour les attaquants. -- Si l'app est sensible (comme des apps bancaires), elle devrait effectuer ses **propres vérifications pour détecter si le mobile est rooted** et agir en conséquence. -- Si l'app est sensible (comme des apps bancaires), elle devrait vérifier si un **emulator** est utilisé. -- Si l'app est sensible (comme des apps bancaires), elle devrait **vérifier son intégrité avant exécution** pour détecter si elle a été modifiée. +- Il est recommandé d'**obfusquer l'APK** pour rendre le travail de reverse engineer plus difficile aux attackers. +- Si l'app est sensible (comme les apps bancaires), elle devrait effectuer ses **propres vérifications pour savoir si le mobile est rooté** et agir en conséquence. +- Si l'app est sensible (comme les apps bancaires), elle devrait vérifier si un **emulator** est utilisé. +- Si l'app est sensible (comme les apps bancaires), elle devrait **vérifier son intégrité avant exécution** pour détecter si elle a été modifiée. - Utilisez [**APKiD**](https://github.com/rednaga/APKiD) pour vérifier quel compiler/packer/obfuscator a été utilisé pour construire l'APK -### Application React Native +### React Native Application -Lisez la page suivante pour apprendre comment accéder facilement au code javascript des applications React : +Lisez la page suivante pour apprendre comment accéder facilement au code javascript des applications React : {{#ref}} react-native-application.md {{#endref}} -### Applications Xamarin +### Xamarin Applications Lisez la page suivante pour apprendre comment accéder facilement au code C# d'une application xamarin : @@ -195,21 +195,21 @@ Lisez la page suivante pour apprendre comment accéder facilement au code C# d'u ../xamarin-apps.md {{#endref}} -### Applications Superpacked +### Superpacked Applications Selon ce [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked est un algorithme Meta qui compresse le contenu d'une application en un seul fichier. Le blog parle de la possibilité de créer une app qui décompresse ce type d'apps... et d'une méthode plus rapide qui consiste à **exécuter l'application et récupérer les fichiers décompressés depuis le filesystem.** ### Analyse statique automatisée du code -L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnerabilities** en **scannant** le **code** de l'application. Cet outil contient une série de **known sources** (qui indiquent à l'outil les **endroits** où l'**input** est **contrôlé par l'utilisateur**), **sinks** (qui indiquent à l'outil les **endroits** **dangereux** où un input malveillant pourrait causer des dommages) et des **rules**. Ces rules indiquent la **combinaison** de **sources-sinks** qui signale une vulnérabilité. +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 **known sources** (qui indiquent à l'outil les **endroits** où l'**input** est **contrôlé par l'utilisateur**), **sinks** (qui indiquent à l'outil les **endroits dangereux** où un input malveillant pourrait causer des dommages) et des **rules**. Ces rules indiquent la **combinaison** de **sources-sinks** qui signale une vulnérabilité. -Avec ces informations, **mariana-trench analysera le code et trouvera d'éventuelles vulnérabilités**. +Avec ces informations, **mariana-trench va analyser le code et trouver d'éventuelles vulnérabilités**. ### Secrets leaked -Une application peut contenir des secrets (API keys, passwords, hidden urls, subdomains...) en son sein que vous pourriez découvrir. Vous pouvez utiliser un outil tel que [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +Une application peut contenir des secrets (API keys, mots de passe, urls cachées, sous-domaines...) à l'intérieur d'elle que vous pourriez être capable 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 +### Bypass Biometric Authentication {{#ref}} @@ -221,7 +221,7 @@ bypass-biometric-authentication-android.md - **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` - **Native functions** déclarées comme `native`: `public native, System.loadLibrary, System.load` -- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) +- [Lisez ceci pour apprendre **comment reverse native functions**](reversing-native-libraries.md) ### **Autres astuces** @@ -234,13 +234,13 @@ content-protocol.md --- -## Analyse dynamique +## Dynamic Analysis -> 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 rooted (émulé ou non) est fortement recommandé. +> Tout d'abord, vous avez besoin d'un environnement où vous pouvez installer l'application et tout l'environnement (Burp CA cert, Drozer et Frida principalement). Par conséquent, un device rooté (emulated ou non) est fortement recommandé. -### Analyse dynamique en ligne +### Online Dynamic analysis -Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme permet de **uploader** et **exécuter** des APKs, elle est donc utile pour voir comment un APK se comporte. +Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme permet d'**uploader** et **d'exécuter** des APKs, donc elle est utile pour voir comment un apk se comporte. Vous pouvez même **voir les logs de votre application** sur le web et vous connecter via **adb**. @@ -248,11 +248,11 @@ Vous pouvez même **voir les logs de votre application** sur le web et vous conn Grâce à la connexion ADB vous pouvez utiliser **Drozer** et **Frida** à l'intérieur des emulators. -### Analyse dynamique locale +### Local Dynamic Analysis #### Using an emulator -- [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des devices **x86** et **arm**, et selon [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**les dernières versions x86** prennent en charge les **ARM libraries** sans avoir besoin d'un emulator ARM lent). +- [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des devices **x86** et **arm**, et selon [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**les dernières versions x86** supportent les libraries ARM sans avoir besoin d'un emulator ARM lent). - Apprenez à le configurer sur cette page : @@ -260,79 +260,85 @@ Grâce à la connexion ADB vous pouvez utiliser **Drozer** et **Frida** à l'int avd-android-virtual-device.md {{#endref}} -- [**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 des erreurs potentielles._) +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(version gratuite :** Personal Edition, création de compte requise. _Il est recommandé de **télécharger** la version **AVEC**_ _**VirtualBox** pour éviter des erreurs potentielles._) - [**Nox**](https://es.bignox.com) (Gratuit, mais il ne supporte pas Frida ou Drozer). > [!TIP] -> Lors de la création d'un nouvel emulator sur n'importe quelle plateforme, souvenez-vous que plus l'écran est grand, plus l'emulator sera lent. Préférez donc des écrans petits si possible. +> Lors de la création d'un nouvel emulator sur n'importe quelle plateforme, souvenez-vous que plus l'écran est grand, plus l'emulator sera lent. Donc sélectionnez des écrans petits si possible. -Pour **installer google services** (comme AppStore) dans Genymotion vous devez cliquer sur le bouton marqué en rouge de l'image suivante : +Pour **installer les google services** (comme AppStore) dans Genymotion vous devez cliquer sur le bouton marqué en rouge dans l'image suivante : ![](<../../images/image (277).png>) -Aussi, notez que dans la **configuration de la Android VM dans Genymotion** vous pouvez sélectionner le **Bridge Network mode** (cela sera utile si vous vous connectez à la Android VM depuis une autre VM contenant les outils). +Notez aussi que dans la **configuration de la VM Android dans Genymotion** vous pouvez sélectionner le **Bridge Network mode** (cela sera utile si vous devez vous connecter à la VM Android depuis une VM différente contenant les outils). -#### Utilisation d'un appareil physique +#### Use a physical device -Vous devez activer les options de **debugging** et il est préférable de pouvoir le **rooter** : +Vous devez activer les options de **debugging** et ce serait bien si vous pouvez le **rooter** : 1. **Settings**. -2. (FromAndroid 8.0) Select **System**. -3. Select **About phone**. -4. Press **Build number** 7 times. -5. Go back and you will find the **Developer options**. +2. (FromAndroid 8.0) Sélectionnez **System**. +3. Sélectionnez **About phone**. +4. Appuyez **Build number** 7 fois. +5. Revenez et vous trouverez les **Developer options**. -> Une fois que vous avez installé l'application, la première chose à faire est de l'essayer et d'étudier ce qu'elle fait, comment elle fonctionne et vous familiariser avec elle.\ -> Je suggère d'**effectuer cette analyse dynamique initiale en utilisant MobSF dynamic analysis + pidcat**, ainsi nous pourrons **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez revoir plus tard. +> Une fois que vous avez installé l'application, la première chose à faire est de l'essayer et d'étudier ce qu'elle fait, comment elle fonctionne et de vous familiariser avec elle.\ +> Je suggère d'**effectuer cette analyse dynamique initiale en utilisant MobSF dynamic analysis + pidcat**, ainsi nous pourrons **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez revoir ensuite. -### Fuites de données non intentionnelles +Magisk/Zygisk quick notes (recommandé sur les appareils Pixel) +- Patch boot.img avec l'app Magisk et flashez via fastboot pour obtenir un systemless root +- Activez Zygisk + DenyList pour masquer le root ; envisagez LSPosed/Shamiko quand un masquage plus robuste est nécessaire +- Conservez le boot.img original pour récupérer après les OTA ; re-patchez après chaque OTA +- Pour le mirroring d'écran, utilisez scrcpy sur l'hôte + +### Unintended Data Leakage **Logging** -Les développeurs doivent se méfier d'exposer des **debugging information** publiquement, car cela peut conduire à des données sensibles leaks. Les outils [**pidcat**](https://github.com/JakeWharton/pidcat) et `adb logcat` sont recommandés pour surveiller les logs de l'application afin d'identifier et protéger les informations sensibles. **Pidcat** est préféré pour sa simplicité et sa lisibilité. +Les développeurs doivent être prudents en exposant des **informations de debugging** publiquement, car cela peut mener à des fuites de données sensibles. Les outils [**pidcat**](https://github.com/JakeWharton/pidcat) et `adb logcat` sont recommandés pour surveiller les logs d'application afin d'identifier et protéger les informations sensibles. **Pidcat** est préféré pour sa facilité d'utilisation et sa lisibilité. > [!WARNING] -> Notez que depuis **les versions plus récentes qu'Android 4.0**, **les applications ne peuvent accéder qu'à leurs propres logs**. Ainsi, les applications ne peuvent pas accéder aux logs des autres apps.\ +> Notez que à partir des **versions postérieures à Android 4.0**, **les applications ne peuvent accéder qu'à leurs propres logs**. Ainsi les applications ne peuvent pas accéder aux logs d'autres apps.\ > Quoi qu'il en soit, il est toujours recommandé de **ne pas logger d'informations sensibles**. **Copy/Paste Buffer Caching** -Le framework **clipboard-based** d'Android permet la fonctionnalité copier-coller dans les apps, mais présente un risque car **d'autres applications** peuvent **accéder** au clipboard, exposant potentiellement des données sensibles. Il est crucial de **désactiver copy/paste** pour les sections sensibles d'une application, comme les informations de carte bancaire, afin d'empêcher des data leaks. +Le framework basé sur le **clipboard** d'Android permet la fonctionnalité copy-paste dans les apps, mais présente un risque car **d'autres applications** peuvent **accéder** au clipboard, exposant potentiellement des données sensibles. Il est crucial de **désactiver les fonctions de copy/paste** pour les sections sensibles d'une application, comme les détails de carte bancaire, afin de prévenir les leaks. **Crash Logs** -Si une application **crashe** et **sauvegarde des logs**, ces logs peuvent aider des attaquants, particulièrement lorsque l'application ne peut pas être reverse-engineered. Pour atténuer ce risque, évitez de logger lors des crashes, et si les logs doivent être transmis sur le réseau, assurez-vous qu'ils sont envoyés via un canal SSL pour la sécurité. +Si une application **crashe** et **sauvegarde des logs**, ces logs peuvent aider des attackers, particulièrement quand l'application ne peut pas être reverse-engineerée. Pour atténuer ce risque, évitez de logger lors de crashs, et si les logs doivent être transmis sur le réseau, assurez-vous qu'ils sont envoyés via un canal SSL pour la sécurité. -En tant que pentester, **essayez de jeter un coup d'œil à ces logs**. +En tant que pentester, **essayez de jeter un œil à ces logs**. **Analytics Data Sent To 3rd Parties** -Les applications intègrent souvent des services comme Google Adsense, qui peuvent involontairement leak des données sensibles en raison d'une implémentation incorrecte par les développeurs. Pour identifier d'éventuels data leaks, il est conseillé d'intercepter le trafic de l'application et de vérifier si des informations sensibles sont envoyées à des services tiers. +Les applications intègrent souvent des services comme Google Adsense, qui peuvent involontairement **leak des données sensibles** à cause d'une implémentation incorrecte par les développeurs. Pour identifier de potentielles leaks, il est conseillé d'**intercepter le traffic de l'application** et de vérifier si des informations sensibles sont envoyées à des services tiers. ### SQLite DBs -La plupart des applications utilisent des bases de données SQLite internes pour sauvegarder des informations. Pendant le pentest, jetez un coup d'œil aux databases créées, aux noms des tables et des colonnes et à toutes les données sauvegardées car vous pourriez trouver des informations sensibles (ce qui constituerait une vulnérabilité).\ -Les databases devraient se trouver dans /data/data/the.package.name/databases comme /data/data/com.mwr.example.sieve/databases +La plupart des applications utiliseront des **bases de données SQLite internes** pour sauvegarder des informations. Pendant le pentest, jetez un **œil** aux **databases** créées, aux noms des **tables** et des **colonnes** et à toutes les **données** sauvegardées car vous pourriez trouver des **informations sensibles** (ce qui serait une vulnérabilité).\ +Les bases de données devraient se trouver dans `/data/data/the.package.name/databases` comme `/data/data/com.mwr.example.sieve/databases` -Si la database sauvegarde des informations confidentielles et est **encryptée** mais que vous pouvez **trouver** le **mot de passe** à l'intérieur de l'application, c'est toujours une **vulnérabilité**. +Si la base de données sauvegarde des informations confidentielles et est **encrypted** mais que vous pouvez **find** le **password** à l'intérieur de l'application, c'est toujours une **vulnérabilité**. -Énumérez les tables en utilisant `.tables` et énumérez les colonnes des tables en faisant `.schema ` +Enumérez les tables en utilisant `.tables` et énumérez les colonnes des tables en faisant `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -D'après les [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf) : **Drozer** permet d'assumer le rôle d'une application Android et d'interagir avec d'autres apps. Il peut faire tout ce qu'une application installée peut faire, comme utiliser le mécanisme Inter-Process Communication (IPC) d'Android et interagir avec le système d'exploitation sous-jacent.\ -Drozer est un outil utile pour **exploiter les exported activities, exported services et Content Providers** comme vous l'apprendrez dans les sections suivantes. +From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permet de **prendre le rôle d'une app Android** et d'interagir avec d'autres apps. Il peut faire **tout ce qu'une application installée peut faire**, comme utiliser le mécanisme d'Inter-Process Communication (IPC) d'Android et interagir avec le système d'exploitation sous-jacent. .\ +Drozer est un outil utile pour **exploiter des activities exportées, des services exportés et des Content Providers** comme vous l'apprendrez dans les sections suivantes. -### Exploitation des exported Activities +### Exploiting exported Activities [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Souvenez-vous aussi que le code d'une activity commence dans la méthode **`onCreate`**. +Rappelez-vous aussi que le code d'une activity démarre dans la méthode **`onCreate`**. **Authorisation bypass** -Quand une Activity est exported vous pouvez invoquer son écran depuis une app externe. Donc, si une activity contenant des **sensitive information** est **exported** vous pourriez **bypass** les mécanismes d'**authentication** pour y accéder. +Quand une Activity est exportée vous pouvez invoquer son écran depuis une app externe. Donc, si une activity contenant des **informations sensibles** est **exportée** vous pourriez **bypasser** les mécanismes d'**authentication** **pour y accéder.** -[**Apprenez comment exploiter les exported activities avec Drozer.**](drozer-tutorial/index.html#activities) +[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) Vous pouvez aussi démarrer une activity exportée depuis adb : @@ -344,47 +350,47 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity **NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21). > [!TIP] -> Note that an authorisation bypass is not always a vulnerability, it would depend on how the bypass works and which information is exposed. +> Notez qu'un authorisation bypass n'est pas toujours une vulnérabilité ; cela dépend de la façon dont le bypass fonctionne et des informations exposées. **Sensitive information leakage** -**Activities can also return results**. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, there is a sensitive information leakage. +Les Activities peuvent aussi renvoyer des résultats. Si vous parvenez à trouver une activity exportée et non protégée appelant la méthode **`setResult`** et **renvoyant des informations sensibles**, il y a un sensitive information leakage. #### Tapjacking -If tapjacking isn't prevented, you could abuse the exported activity to make the **user perform unexpected actions**. For more info about [**what is Tapjacking follow the link**](#tapjacking). +Si le Tapjacking n'est pas empêché, vous pourriez abuser de l'activity exportée pour faire en sorte que **l'utilisateur réalise des actions inattendues**. Pour plus d'info sur [**ce qu'est le Tapjacking, suivez le lien**](#tapjacking). ### Exploiting Content Providers - Accessing and manipulating sensitive information [**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers are basically used to **share data**. If an app has available content providers you may be able to **extract sensitive** data from them. It also interesting to test possible **SQL injections** and **Path Traversals** as they could be vulnerable. +Les Content providers sont essentiellement utilisés pour **partager des données**. Si une app dispose de content providers accessibles, vous pourriez être capable d'**extraire des données sensibles** depuis ceux-ci. Il est aussi intéressant de tester d'éventuelles **SQL injections** et **Path Traversals** car elles pourraient être vulnérables. [**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** [**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ -Remember that a the actions of a Service start in the method `onStartCommand`. +Rappelez-vous que les actions d'un Service commencent dans la méthode `onStartCommand`. -As service is basically something that **can receive data**, **process** it and **returns** (or not) a response. Then, if an application is exporting some services you should **check** the **code** to understand what is it doing and **test** it **dynamically** for extracting confidential info, bypassing authentication measures...\ +Un Service est essentiellement quelque chose qui **peut recevoir des données**, les **traiter** et **renvoyer** (ou non) une réponse. Donc, si une application exporte des services, vous devriez **vérifier** le **code** pour comprendre ce qu'il fait et le **tester** **dynamiquement** afin d'extraire des informations confidentielles, contourner des mesures d'authentification...\ [**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** [**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Remember that a the actions of a Broadcast Receiver start in the method `onReceive`. +Rappelez-vous que les actions d'un Broadcast Receiver commencent dans la méthode `onReceive`. -A broadcast receiver will be waiting for a type of message. Depending on ho the receiver handles the message it could be vulnerable.\ +Un Broadcast Receiver attend un certain type de message. Selon la manière dont le receiver gère le message, il pourrait être vulnérable.\ [**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -You can look for deep links manually, using tools like MobSF or scripts like [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -You can **open** a declared **scheme** using **adb** or a **browser**: +Vous pouvez rechercher des deep links manuellement, en utilisant des outils comme MobSF ou des scripts comme [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Vous pouvez **ouvrir** un **scheme** déclaré en utilisant **adb** ou un **browser**: ```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 que l'appareil mobile lancera automatiquement l'application qui doit ouvrir ce lien._ +_Notez que vous pouvez **omettre le nom du package** et le mobile appellera automatiquement l'application qui doit ouvrir ce lien._ ```html Click me @@ -393,56 +399,56 @@ _Notez que vous pouvez **omettre le nom du package** et que l'appareil mobile la ``` **Code exécuté** -Pour trouver le **code qui sera exécuté dans l'application**, allez dans l'activité appelée par le deeplink et recherchez la fonction **`onNewIntent`**. +Pour trouver le **code qui sera exécuté dans l'App**, allez à l'activité appelée par le deeplink et recherchez la fonction **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) -**Informations sensibles** +**Sensitive info** -Chaque fois que vous trouvez un deep link, vérifiez que **il ne reçoit pas de données sensibles (comme des mots de passe) via les paramètres d'URL**, car toute autre application pourrait **usurper le deep link et voler ces données !** +Chaque fois que vous trouvez un deep link, vérifiez qu'**il ne reçoit pas de données sensibles (comme des mots de passe) via des paramètres d'URL**, car n'importe quelle autre application pourrait **usurper le deep link et voler ces données !** -**Paramètres dans le chemin** +**Parameters in path** -Vous **devez également vérifier si un deep link 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 un path traversal en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ -Notez que si vous trouvez les endpoints corrects dans l'application, vous pourriez provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), un **account takeover** (si vous pouvez modifier les détails des utilisateurs sans token CSRF et que l'endpoint vulnérable utilisait la méthode appropriée) et toute autre vulnérabilité. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). +Vous **devez aussi vérifier si un deep link utilise un paramètre à l'intérieur du path** de l'URL comme : `https://api.example.com/v1/users/{username}` , dans ce cas vous pouvez forcer un path traversal en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Notez que si vous trouvez les endpoints corrects dans l'application vous pourriez provoquer un **Open Redirect** (si une partie du path est utilisée comme nom de domaine), un **account takeover** (si vous pouvez modifier les users details sans token CSRF et que l'endpoint vulnérable utilise la méthode appropriée) et toute autre vuln. Plus d'[info about this here](http://dphoeniixx.com/2020/12/13-2/). **More examples** -An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). +Un [intéressant bug bounty report](https://hackerone.com/reports/855618) au sujet des links (_/.well-known/assetlinks.json_). -### Inspection de la couche transport et échecs de vérification +### Transport Layer Inspection and Verification Failures -- **Les certificats ne sont pas toujours correctement vérifiés** par les applications Android. Il est courant que ces applications ignorent les avertissements et acceptent des certificats auto-signés ou, dans certains cas, reviennent à des connexions HTTP. -- **Les négociations lors du handshake SSL/TLS sont parfois faibles**, utilisant des suites de chiffrement non sécurisées. Cette vulnérabilité rend la connexion susceptible à des attaques man-in-the-middle (MITM), permettant aux attaquants de déchiffrer les données. -- **Fuite d'informations privées** est un risque lorsque les applications authentifient via des canaux sécurisés mais communiquent ensuite via des canaux non sécurisés pour d'autres transactions. Cette approche ne protège pas les données sensibles, telles que les cookies de session ou les informations utilisateur, contre l'interception par des acteurs malveillants. +- **Les certificats ne sont pas toujours correctement inspectés** par les applications Android. Il est courant que ces applications ignorent les avertissements et acceptent des certificats auto-signés ou, dans certains cas, reviennent à des connexions HTTP. +- **Les négociations lors du handshake SSL/TLS sont parfois faibles**, employant des suites de chiffrement non sécurisées. Cette vulnérabilité rend la connexion susceptible à des attaques man-in-the-middle (MITM), permettant aux attaquants de déchiffrer les données. +- **Leakage of private information** représente un risque lorsque les applications s'authentifient via des canaux sécurisés puis communiquent via des canaux non sécurisés pour d'autres transactions. Cette approche ne protège pas les données sensibles, comme les cookies de session ou les informations utilisateur, d'une interception par des entités malveillantes. -#### Vérification des certificats +#### Certificate Verification -Nous nous concentrerons sur **certificate verification**. L'intégrité du certificat du serveur doit être vérifiée pour renforcer la sécurité. C'est crucial car des configurations TLS non sécurisées et la transmission de données sensibles sur des canaux non chiffrés peuvent présenter des risques importants. Pour des étapes détaillées sur la vérification des certificats serveur et la correction des vulnérabilités, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des conseils complets. +Nous allons nous concentrer sur la **vérification des certificats**. L'intégrité du certificat du serveur doit être vérifiée pour améliorer la sécurité. C'est crucial car des configurations TLS non sécurisées et la transmission de données sensibles sur des canaux non chiffrés peuvent présenter des risques importants. Pour des étapes détaillées sur la vérification des certificats serveur et la correction des vulnérabilités, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fournit un guide complet. #### SSL Pinning -SSL Pinning est une mesure de sécurité où l'application vérifie le certificat du serveur par rapport à une copie connue stockée dans l'application elle-même. Cette méthode est essentielle pour prévenir les attaques MITM. L'implémentation de SSL Pinning est fortement recommandée pour les applications manipulant des informations sensibles. +SSL Pinning est une mesure de sécurité où l'application vérifie le certificat du serveur par rapport à une copie connue stockée dans l'application elle-même. Cette méthode est essentielle pour prévenir les attaques MITM. Implémenter SSL Pinning est fortement recommandé pour les applications manipulant des informations sensibles. -#### Inspection du trafic +#### Traffic Inspection Pour inspecter le trafic HTTP, il est nécessaire d'**installer le certificat de l'outil proxy** (par ex., Burp). Sans l'installation de ce certificat, le trafic chiffré pourrait ne pas être visible via le proxy. Pour un guide sur l'installation d'un certificat CA personnalisé, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). Les applications ciblant **API Level 24 and above** nécessitent des modifications du Network Security Config pour accepter le certificat CA du proxy. Cette étape est critique pour inspecter le trafic chiffré. Pour des instructions sur la modification du Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -Si **Flutter** est utilisé, vous devez suivre les instructions sur [**this page**](flutter.md). Ceci est dû au fait que l'ajout du certificat dans le store ne fonctionnera pas, car Flutter a sa propre liste de CA valides. +Si **Flutter** est utilisé vous devez suivre les instructions sur [**this page**](flutter.md). Ceci est parce que, simplement ajouter le certificat dans le store ne fonctionnera pas car Flutter a sa propre liste de CAs valides. -#### Détection statique du SSL/TLS pinning +#### Static detection of SSL/TLS pinning -Avant de tenter des contournements à l'exécution, cartographiez rapidement où le pinning est appliqué dans l'APK. La découverte statique vous aide à planifier les hooks/patches et à vous concentrer sur les bons code paths. +Avant d'essayer des contournements à l'exécution, cartographiez rapidement où le pinning est appliqué dans l'APK. La découverte statique vous aide à planifier les hooks/patches et à vous concentrer sur les bons code paths. Tool: SSLPinDetect -- Utilitaire open-source d'analyse statique qui décompile l'APK en Smali (via apktool) et scanne des patterns regex sélectionnés d'implémentations de SSL/TLS pinning. +- Utilitaire open-source d'analyse statique qui décompile l'APK en Smali (via apktool) et scanne des motifs regex sélectionnés des implémentations de SSL/TLS pinning. - Rapporte le chemin de fichier exact, le numéro de ligne et un extrait de code pour chaque correspondance. -- Couvre les frameworks courants et les code paths personnalisés : OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, et Network Security Config XML pins. +- Couvre les frameworks courants et les code paths personnalisés : OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, et les pins Network Security Config XML. -Installation -- Prérequis : Python >= 3.8, Java dans le PATH, apktool +Install +- Prereqs: Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -456,8 +462,9 @@ python sslpindetect.py -f app.apk -a apktool.jar # Verbose (timings + per-match path:line + snippet) python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` -Exemple de règles de motifs (JSON) -Utilisez ou étendez les signatures pour détecter des styles de pinning propriétaires/personnalisés. Vous pouvez charger votre propre JSON et scanner à grande échelle. +Exemples de règles de pattern (JSON) + +Utilisez ou étendez des signatures pour détecter des styles de pinning propriétaires/personnalisés. Vous pouvez charger votre propre JSON et scanner à grande échelle. ```json { "OkHttp Certificate Pinning": [ @@ -471,37 +478,37 @@ Utilisez ou étendez les signatures pour détecter des styles de pinning propri ] } ``` -Notes et astuces -- Analyse rapide des grosses apps via multi-threading et memory-mapped I/O ; des regex pré-compilées réduisent l'overhead/les faux positifs. -- Collection de patterns: https://github.com/aancw/smali-sslpin-patterns -- Cibles typiques à trier ensuite : +Notes and tips +- Analyse rapide des grandes apps via multi-threading et I/O mémoire mappée ; les regex précompilées réduisent la surcharge/les faux positifs. +- Pattern collection: https://github.com/aancw/smali-sslpin-patterns +- Typical detection targets to triage next: - OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references -- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides +- Custom TrustManagers: javax.net.ssl.X509TrustManager, surcharges de checkServerTrusted - Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers - Declarative pins in res/xml network security config and manifest references -- Utilisez les emplacements trouvés pour planifier des Frida hooks, des patchs statiques, ou des revues de config avant les tests dynamiques. +- Use the matched locations to plan Frida hooks, static patches, or config reviews before dynamic testing. -#### Contourner SSL Pinning +#### Bypassing SSL Pinning -Quand SSL Pinning est implémenté, le contourner devient nécessaire pour inspecter le trafic HTTPS. Différentes méthodes sont disponibles pour cela : +Quand SSL Pinning est implémenté, le bypass devient nécessaire pour inspecter le trafic HTTPS. Différentes méthodes sont disponibles pour ça : -- Modifiez automatiquement l'**apk** pour **contourner** SSLPinning 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 le SSL Pinning, mais vous devrez supprimer l'application et réinstaller la nouvelle, et cela ne fonctionnera pas toujours. -- Vous pouvez utiliser **Frida** (décrit 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 aussi essayer de **contourner automatiquement SSL Pinning** en utilisant [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- Vous pouvez aussi essayer de **contourner automatiquement SSL Pinning** 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-ip-forwarding-iptables-568171b52b62) +- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Le principal avantage de cette option est que vous n'aurez pas besoin de root pour bypass SSL Pinning, mais il faudra désinstaller l'application et réinstaller la nouvelle, et cela ne fonctionnera pas toujours. +- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use 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/) +- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below) +- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Recherche de vulnérabilités web courantes +#### Looking for Common Web Vulnerabilities -Il est important de rechercher également les vulnérabilités web courantes dans l'application. Les informations détaillées sur l'identification et l'atténuation de ces vulnérabilités dépassent le cadre de ce résumé mais sont largement couvertes ailleurs. +Il est important de rechercher aussi des vulnérabilités web courantes dans l'application. Les détails sur l'identification et l'atténuation de ces vulnérabilités dépassent le cadre de ce résumé mais sont largement traités ailleurs. ### Frida [Frida](https://www.frida.re) est un toolkit d'instrumentation dynamique pour développeurs, reverse-engineers, et chercheurs en sécurité.\ -**Vous pouvez accéder à l'application en cours d'exécution et hooker des méthodes au runtime pour changer le comportement, modifier des valeurs, extraire des valeurs, exécuter du code différent...**\ -Si vous voulez pentester des applications Android vous devez savoir utiliser Frida. +**Vous pouvez accéder à l'application en cours d'exécution et hooker des méthodes à l'exécution pour modifier le comportement, changer des valeurs, extraire des valeurs, exécuter un code différent...**\ +Si vous voulez pentest des applications Android vous devez savoir utiliser Frida. - Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html) - Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) @@ -515,11 +522,11 @@ Si vous voulez pentester des applications Android vous devez savoir utiliser Fri android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Dumper la mémoire - Fridump** +### **Dump Memory - Fridump** Vérifiez si l'application stocke des informations sensibles en mémoire qu'elle ne devrait pas stocker, comme des mots de passe ou des mnémoniques. -En utilisant [**Fridump3**](https://github.com/rootbsd/fridump3) vous pouvez dumper la mémoire de l'app avec: +En utilisant [**Fridump3**](https://github.com/rootbsd/fridump3) vous pouvez effectuer un dump de la mémoire de l'app avec: ```bash # With PID python3 fridump3.py -u @@ -528,122 +535,120 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Cela va dump la mémoire dans le dossier ./dump, et là vous pouvez utiliser grep avec quelque chose comme : +Cela va dump la mémoire dans le dossier ./dump, et vous pouvez y faire un grep avec quelque chose comme : ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` -### **Données sensibles dans le Keystore** +### **Données sensibles dans Keystore** -Sur Android, le Keystore est l'endroit idéal pour stocker des données sensibles, cependant, avec des privilèges suffisants, il est toujours **possible d'y accéder**. +Sur Android, le Keystore est l'endroit idéal 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 clear text**, les pentests devraient le vérifier en tant que root user, car quelqu'un ayant un accès physique au périphérique pourrait voler ces données. -Comme les applications ont tendance à stocker ici des **données sensibles en clair**, les pentests doivent vérifier cela en tant qu'utilisateur root car quelqu'un ayant un accès physique à l'appareil pourrait être capable de voler ces données. +Même si une app stocke des données dans le keystore, ces données doivent être chiffrées. -Même si une application stocke des données dans le keystore, les données doivent être chiffrées. - -Pour accéder aux données dans le 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) +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) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -En utilisant le script Frida suivant, il peut être possible de **bypass fingerprint authentication** que des applications Android mettent en place afin de **protéger certaines zones sensibles :** +En utilisant le script Frida suivant, il pourrait être possible de **bypass fingerprint authentication** mis en œuvre par des applications Android pour **protéger certaines zones sensibles :** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Images d'arrière-plan** -Lorsque vous placez une application en arrière-plan, Android enregistre un **snapshot de l'application** afin que, lorsqu'elle est ramenée au premier plan, il commence par charger l'image avant l'application, donnant l'impression que l'app s'est chargée plus rapidement. +Lorsque vous placez une application en arrière-plan, Android enregistre un **instantané de l'application** : lorsqu'elle est ramenée au premier plan, l'image est chargée avant l'application pour donner l'impression que celle-ci s'est chargée plus rapidement. -Cependant, si ce snapshot contient des **informations sensibles**, une personne ayant accès au snapshot pourrait **voler ces informations** (note : il faut les privilèges root pour y accéder). +Cependant, si cet instantané contient des **informations sensibles**, une personne ayant accès à l'instantané pourrait **voler ces informations** (notez que vous avez besoin de root pour y accéder). -Les snapshots sont généralement stockés ici : **`/data/system_ce/0/snapshots`** +Les instantanés sont généralement stockés à : **`/data/system_ce/0/snapshots`** -Android fournit un moyen de **prévenir la capture d'écran en définissant le paramètre FLAG_SECURE** du layout. En utilisant ce flag, le contenu de la fenêtre est traité comme sécurisé, l'empêchant d'apparaître dans des captures d'écran ou d'être affiché sur des écrans non sécurisés. +Android fournit un moyen de **prévenir la capture d'écran en définissant le paramètre de layout FLAG_SECURE**. En utilisant ce flag, le contenu de la fenêtre est traité comme sécurisé, l'empêchant d'apparaître dans des captures d'écran ou d'être affiché sur des écrans non sécurisés. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` ### **Android Application Analyzer** -Cet outil peut 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) +This tool could help you managing different tools during the dynamic analysis: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Les développeurs créent souvent des composants proxy comme activities, services et broadcast receivers qui traitent ces Intents et les transmettent à des méthodes telles que `startActivity(...)` ou `sendBroadcast(...)`, ce qui peut être risqué. +Les développeurs créent souvent des composants proxy comme activities, services, et broadcast receivers qui gèrent ces Intents et les passent à des méthodes telles que `startActivity(...)` ou `sendBroadcast(...)`, ce qui peut être risqué. -Le danger réside dans le fait de permettre à des attaquants de déclencher des composants d'application non-exportés ou d'accéder à des content providers sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` convertissant des URLs en objets `Intent` via `Intent.parseUri(...)` puis les exécutant, ce qui peut conduire à des injections d'Intent malveillantes. +Le danger réside dans le fait de permettre aux attaquants de déclencher des composants d'application non-exportés ou d'accéder à des content providers sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` qui convertit les URLs en objets `Intent` via `Intent.parseUri(...)` puis les exécute, pouvant mener à des injections d'Intent malveillantes. ### Essential Takeaways -- **Intent Injection** is similar to web's Open Redirect issue. -- Exploits involve passing `Intent` objects as extras, which can be redirected to execute unsafe operations. -- It can expose non-exported components and content providers to attackers. -- `WebView`’s URL to `Intent` conversion can facilitate unintended actions. +- **Intent Injection** est similaire au problème d'Open Redirect sur le web. +- Les exploits impliquent de passer des objets `Intent` en tant qu'extras, qui peuvent être redirigés pour exécuter des opérations dangereuses. +- Cela peut exposer des composants non-exportés et des content providers aux attaquants. +- La conversion d'URL en `Intent` par le `WebView` peut faciliter des actions non prévues. -### Android Client Side Injections and others +### Injections côté client Android et autres Vous connaissez probablement ce type de vulnérabilités depuis le Web. Vous devez être particulièrement prudent avec ces vulnérabilités dans une application Android : -- **SQL Injection:** Lors du traitement de requêtes dynamiques ou de Content-Providers, assurez-vous d'utiliser des requêtes paramétrées. +- **SQL Injection:** Lorsqu'on manipule des requêtes dynamiques ou des Content-Providers, assurez-vous d'utiliser des requêtes paramétrées. - **JavaScript Injection (XSS):** Vérifiez que le support JavaScript et Plugin est désactivé pour tous les WebViews (désactivé par défaut). [Plus d'infos ici](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** Les WebViews doivent avoir l'accès au système de fichiers désactivé (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'infos ici](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: Dans plusieurs cas, quand l'application Android termine la session le cookie n'est pas révoqué ou il peut même être sauvegardé sur le disque -- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) +- **Local File Inclusion:** Les WebViews devraient avoir l'accès au système de fichiers désactivé (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'infos ici](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: Dans plusieurs cas, lorsque l'application Android termine la session, le cookie n'est pas révoqué ou peut même être sauvegardé sur le disque +- [**Secure Flag** dans les cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Automatic Analysis +## Analyse automatique ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) -**Static analysis** +**Analyse statique** ![](<../../images/image (866).png>) -**Vulnerability assessment of the application** using a nice web-based frontend. You can also perform dynamic analysis (but you need to prepare the environment). +**Évaluation des vulnérabilités de l'application** via une interface web agréable. Vous pouvez aussi effectuer une analyse dynamique (mais vous devez préparer l'environnement). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. +Remarquez que MobSF peut analyser **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +De plus, si vous créez un fichier **ZIP** contenant le code source d'une application **Android** ou **IOS** (allez dans le dossier racine de l'application, sélectionnez tout et créez un ZIPfile), il pourra aussi l'analyser. -MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. +MobSF permet également de **diff/Compare** 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 aussi définir `VT_UPLOAD` à `False`, alors le **hash** sera **upload** au lieu du fichier. ### Assisted Dynamic analysis with MobSF -**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -The **MobSF dynamic analyser** can: +**MobSF** peut aussi ê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 fonctionneront pas). _Note : Vous devez **démarrer d'abord une VM dans genymotion** puis **MobSF.**_\ +L'**analyseur dynamique MobSF** peut : -- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. -- Capture **HTTPS traffic** -- Use **Frida** to obtain **runtime** **information** +- **Dump application data** (URLs, logs, clipboard, captures d'écran faites par vous, captures d'écran faites par "**Exported Activity Tester**", emails, bases de données SQLite, fichiers XML, et autres fichiers créés). Tout ceci est fait automatiquement sauf pour les captures d'écran : vous devez appuyer quand vous voulez une capture d'écran ou appuyer sur "**Exported Activity Tester**" pour obtenir les captures d'écran de toutes les activités exportées. +- Capturer le **HTTPS traffic** +- Utiliser **Frida** pour obtenir des **runtime** **information** -From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. +À partir des versions Android **> 5**, il **démarrera automatiquement Frida** et configurera les paramètres de **proxy** globaux pour **capture** le traffic. Il ne capturera le traffic que de l'application testée. **Frida** -By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ -MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. +Par défaut, il utilisera aussi certains Frida Scripts pour **bypass SSL pinning**, **root detection** et **debugger detection** et pour **monitor interesting APIs**.\ +MobSF peut aussi **invoke exported activities**, prendre des **screenshots** de celles-ci et les **save** pour le rapport. -To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ -MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). +Pour **start** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les logs générés par les Frida scripts et "**Live API Monitor**" pour voir toutes les invocations des méthodes hookées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\ +MobSF permet aussi de charger vos propres **Frida scripts** (pour envoyer les résultats de vos scripts Frida à MobSF utilisez la fonction `send()`). Il propose également **plusieurs scripts pré-écrits** que vous pouvez charger (vous pouvez en ajouter d'autres dans `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), il suffit de **les sélectionner**, d'appuyer sur "**Load**" puis sur "**Start Instrumentation**" (vous pourrez voir les logs de ces scripts dans "**Frida Live Logs**"). ![](<../../images/image (419).png>) -Moreover, you have some Auxiliary Frida functionalities: +De plus, vous avez quelques fonctionnalités auxiliaires Frida : -- **Enumerate Loaded Classes**: It will print all the loaded classes -- **Capture Strings**: It will print all the capture strings while using the application (super noisy) -- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. -- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. -- **Search Class Pattern**: Search classes by pattern -- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. +- **Enumerate Loaded Classes** : Affiche toutes les classes chargées +- **Capture Strings** : Affiche toutes les strings capturées lors de l'utilisation de l'application (très bruyant) +- **Capture String Comparisons** : Peut être très utile. Il **montrera les 2 strings comparées** et si le résultat était True ou False. +- **Enumerate Class Methods** : Indiquez le nom de la classe (comme "java.io.File") et il affichera toutes les méthodes de la classe. +- **Search Class Pattern** : Recherche des classes par pattern +- **Trace Class Methods** : **Trace** une **classe entière** (voir les entrées et sorties de toutes les méthodes de la classe). Rappelez-vous que par défaut MobSF trace plusieurs méthodes Android intéressantes. -Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". +Une fois que vous avez sélectionné le module auxiliaire que vous voulez utiliser, vous devez appuyer sur "**Start Intrumentation**" et vous verrez toutes les sorties dans "**Frida Live Logs**". **Shell** -Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: +MobSF apporte aussi un shell avec quelques commandes **adb**, **MobSF commands**, et commandes **shell** courantes en bas de la page d'analyse dynamique. Quelques commandes intéressantes : ```bash help shell ls @@ -654,13 +659,13 @@ receivers ``` **Outils HTTP** -When HTTP traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bouton ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". From the second option, you can **envoyer** les **requêtes capturées** vers des **proxies** comme Burp ou Owasp ZAP.\ -To do so, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Lorsque le trafic http est capturé, vous pouvez voir une vue brute du trafic capturé sur le bouton "**HTTP(S) Traffic**" en bas ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". Depuis la deuxième option, vous pouvez **envoyer** les **requêtes capturées** vers des **proxies** comme Burp ou Owasp ZAP.\ +Pour ce faire, _démarrez 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)). -Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz http requests** an look for vulnerabilities. +Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez cliquer sur "**Start Web API Fuzzer**" pour **fuzz des requêtes http** et rechercher des vulnérabilités. > [!TIP] -> After performing a dynamic analysis with MobSF the proxy settings me be misconfigured and you won't be able to fix them from the GUI. You can fix the proxy settings by doing: +> 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 depuis la GUI. Vous pouvez corriger les paramètres de proxy en exécutant : > > ``` > adb shell settings put global http_proxy :0 @@ -668,7 +673,7 @@ Once you finish the dynamic analysis with MobSF you can press on "**Start Web AP ### Analyse dynamique assistée avec Inspeckage -You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ +Vous pouvez obtenir l'outil depuis [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ Cet outil utilise des **Hooks** pour vous indiquer **ce qui se passe dans l'application** pendant que vous effectuez une **analyse dynamique**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) @@ -679,7 +684,7 @@ C'est un **excellent outil pour effectuer une analyse statique avec une interfac ### [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 des **APKs packagés**. L'outil est également **capable de créer un APK déployable "Proof-of-Concept"** et des **ADB commands**, pour exploiter certaines des vulnérabilités trouvées (Exposed activities, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test. +Cet outil est conçu pour rechercher plusieurs **security related Android application vulnerabilities**, soit dans le **source code** soit dans les **packaged APKs**. L'outil est également **capable of creating a "Proof-of-Concept" deployable APK** et des **ADB commands**, pour exploiter certaines des vulnérabilités trouvées (Exposed activities, 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 @@ -688,10 +693,10 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Affiche tous les fichiers extraits pour consultation facile -- Décompile automatiquement les fichiers APK au format Java et Smali -- Analyse AndroidManifest.xml à la recherche de vulnérabilités et de comportements courants -- Analyse statique du code source pour détecter des vulnérabilités et des comportements courants +- Affiche tous les fichiers extraits pour une consultation facile +- Décompile automatiquement les fichiers APK en formats Java et Smali +- Analyse AndroidManifest.xml pour les vulnérabilités courantes et le comportement +- Analyse statique du code source pour détecter les vulnérabilités courantes et le comportement - Informations sur l'appareil - et plus encore ```bash @@ -699,9 +704,9 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER est une application en ligne de commande utilisable sous Windows, MacOS X et Linux, qui analyse les fichiers _.apk_ à la recherche de vulnérabilités. Elle le fait en décompressant les APK et en appliquant une série de règles pour détecter ces vulnérabilités. +SUPER est une application en ligne de commande utilisable sous Windows, MacOS X et Linux, qui analyse des fichiers _.apk_ à la recherche de vulnérabilités. Elle fonctionne 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 centralisé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. +Toutes les règles sont centralisé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. Téléchargez les derniers binaires depuis la [download page](https://superanalyzer.rocks/download.html) ``` @@ -711,17 +716,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn est un outil multiplateforme qui aide les développeurs, bugbounty hunters et ethical hackers à réaliser du static code analysis sur des applications mobiles. +StaCoAn est un outil **multi-plateforme** qui aide les développeurs, bugbounty hunters et ethical hackers effectuant [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) sur les applications mobiles. -Le principe est que vous glissez-déposez le fichier de votre application mobile (un .apk ou .ipa) sur l'application StaCoAn et elle génère un rapport visuel et portable pour vous. Vous pouvez ajuster les paramètres et les wordlists pour obtenir une expérience personnalisée. +Le concept est que vous glissez-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 wordlists pour obtenir une expérience personnalisée. -Télécharger la [latest release](https://github.com/vincentcox/StaCoAn/releases): +Télécharger[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework est un système d'analyse des vulnérabilités Android qui aide les développeurs ou hackers à trouver des vulnérabilités de sécurité potentielles dans les applications Android.\ +AndroBugs Framework est un système d'analyse de vulnérabilités Android qui aide les développeurs ou hackers à trouver des vulnérabilités potentielles dans les applications Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -729,9 +734,9 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** est un outil dont l'objectif principal est de détecter et d'avertir l'utilisateur des comportements potentiellement malveillants développés par une application Android. +**Androwarn** est un outil dont le but principal est de détecter et d'alerter l'utilisateur sur les comportements potentiellement malveillants développés par une application Android. -La détection est effectuée via la **static analysis** du Dalvik bytecode de l'application, représenté en **Smali**, à l'aide de la bibliothèque [`androguard`](https://github.com/androguard/androguard). +La détection est effectuée par **static analysis** du bytecode Dalvik de l'application, représenté en **Smali**, à l'aide de la bibliothèque [`androguard`](https://github.com/androguard/androguard). Cet outil recherche les **comportements courants des applications "malveillantes"** tels que : Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` @@ -741,84 +746,85 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** est un Framework d'ingénierie inverse et d'analyse d'applications mobiles (Mobile Application Reverse engineering and Analysis Framework). C'est un outil qui regroupe des outils couramment utilisés pour le reverse engineering et l'analyse d'applications mobiles, afin d'aider à tester les applications mobiles contre les menaces de sécurité mobile d'OWASP. Son objectif est de rendre cette tâche plus facile et plus accessible aux développeurs d'applications mobiles et aux professionnels de la sécurité. +**MARA** est un framework d'ingénierie inverse et d'analyse d'applications mobiles. C'est un outil qui regroupe des outils couramment utilisés pour l'ingénierie inverse et l'analyse d'applications mobiles, afin d'aider à tester les applications mobiles face aux menaces de sécurité mobile OWASP. Son objectif est de rendre cette tâche plus facile et plus accessible pour les développeurs d'applications mobiles et les professionnels de la sécurité. -Il peut : +Il permet de : -- Extraire le code Java et Smali en utilisant différents outils -- Analyser les APKs 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 depuis l'APK en utilisant des regexps. +- Extraire du code Java et Smali en utilisant différents outils +- Analyser des APKs 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 regexps. - Analyser le Manifest. - 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) +- Désobfusquer l'APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Utile pour détecter du malware: [https://koodous.com/](https://koodous.com/) +Utile pour détecter les malware : [https://koodous.com/](https://koodous.com/) ## Obfuscating/Deobfuscating code -Notez que, selon le service et la configuration utilisés pour obfusquer le code, les secrets peuvent ou non finir obfusqués. +Notez qu'en fonction du service et de la configuration utilisés pour obfusquer le code, les secrets peuvent ou non finir obfusqués. ### [ProGuard]() -D'après [Wikipedia](): **ProGuard** est un outil open source en ligne de commande qui réduit, optimise et obfusque le code Java. Il peut optimiser le bytecode ainsi que détecter et supprimer les instructions inutilisées. ProGuard est un logiciel libre et est distribué sous la GNU General Public License, version 2. +From [Wikipedia](): **ProGuard** est un outil open source en ligne de commande 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 libre distribué sous la GNU General Public License, version 2. ProGuard est distribué dans le cadre de l'Android SDK et s'exécute lors de la compilation de l'application en mode release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Trouvez un guide pas-à-pas pour déobfusquer l'apk sur [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Trouvez un guide pas à pas pour désobfusquer l'apk sur [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(D'après ce guide) La dernière fois que nous avons vérifié, le mode de fonctionnement de Dexguard était : +(From that guide) La dernière fois que nous avons vérifié, le mode d'opération de Dexguard était : - charger une ressource en tant que InputStream ; -- fournir le résultat à une classe héritant de FilterInputStream pour le déchiffrer ; -- effectuer une obfuscation inutile pour faire perdre quelques minutes à un reverser ; -- fournir le résultat déchiffré à un ZipInputStream pour obtenir un fichier DEX ; -- finalement charger le DEX résultant comme une Resource en utilisant la méthode `loadDex`. +- passer le résultat à une classe héritant de FilterInputStream pour la déchiffrer ; +- effectuer une obfuscation inutile pour faire perdre quelques minutes à un reverseur ; +- passer le résultat déchiffré à un ZipInputStream pour obtenir un fichier DEX ; +- enfin charger le DEX résultant comme Resource 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 de code et l'identification des bibliothèques.** +**DeGuard inverse le processus d'obfuscation réalisé par les outils d'obfuscation Android. Cela permet de réaliser de nombreuses analyses de sécurité, y compris l'inspection du code et l'identification des bibliothèques.** Vous pouvez téléverser un APK obfusqué sur leur plateforme. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans des apps android et déobfusquer le code d'applications android. Utilise l'API publique Gemini de Google. +This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API. ### [Simplify](https://github.com/CalebFenton/simplify) -C'est un **déobfuscateur android générique.** Simplify **exécute virtuellement une app** pour comprendre son comportement puis **essaie d'optimiser le code** afin 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é. +C'est un **déobfuscateur Android générique.** Simplify **exécute virtuellement une app** pour comprendre son comportement puis **essaie d'optimiser le code** afin qu'il se comporte de façon 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 **compilers**, **packers**, **obfuscators**, et d'autres trucs bizarres. C'est [_PEiD_](https://www.aldeid.com/wiki/PEiD) pour Android. +APKiD vous donne des informations sur **la façon dont un APK a été créé**. Il identifie de nombreux **compilateurs**, **packers**, **obfuscators**, et autres éléments étranges. C'est [_PEiD_](https://www.aldeid.com/wiki/PEiD) pour Android. ### Manual -[Lisez ce tutoriel pour apprendre quelques astuces sur **la façon d'inverser une obfuscation personnalisée**](manual-deobfuscation.md) +[Lisez ce tutoriel pour apprendre quelques astuces sur **comment déobfusquer une 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 ; elle inclut une collection des derniers frameworks, tutoriels et labs provenant de différents passionnés et chercheurs en sécurité pour le reverse engineering et l'analyse de malware. +AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut une collection des derniers frameworks, tutoriels et labs provenant de différents passionnés et chercheurs en sécurité pour le reverse engineering et l'analyse de malware. -## Références +## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [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 Android +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course - [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) - [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) - [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097) - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) +- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) -## À tester +## Yet to try - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md index ac589508c..b1574a105 100644 --- a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md +++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -2,15 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -Cette page fournit un workflow pratique pour retrouver dynamic analysis contre des applications Android qui détectent/empêchent l'instrumentation liée au root ou qui appliquent TLS pinning. Elle se concentre sur le triage rapide, les détections courantes et des hooks/tactiques copiables pour les bypasser sans repacking quand c'est possible. +Cette page fournit un workflow pratique pour retrouver une analyse dynamique contre des apps Android qui détectent/empêchent l'instrumentation ou imposent le TLS pinning. Elle se concentre sur le triage rapide, les détections courantes et des hooks/tactiques copiables-collables pour les contourner sans repacking quand c'est possible. ## Detection Surface (what apps check) -- Root checks: su binary, Magisk paths, getprop values, common root packages -- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs -- Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks -- Early init checks: Application.onCreate() or process start hooks that crash if instrumentation is present -- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins +- Vérifications de root : su binary, Magisk paths, getprop values, common root packages +- Frida/debugger checks (Java) : Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scan de /proc, classpath, bibliothèques chargées +- Anti‑debug natif : ptrace(), syscalls, anti‑attach, breakpoints, inline hooks +- Vérifications d'initialisation précoce : Application.onCreate() ou hooks de démarrage de process qui plantent si l'instrumentation est présente +- TLS pinning : custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins ## Step 1 — Quick win: hide root with Magisk DenyList @@ -18,39 +18,56 @@ Cette page fournit un workflow pratique pour retrouver dynamic analysis contre d - Enable DenyList, add the target package - Reboot and retest -Many apps only look for obvious indicators (su/Magisk paths/getprop). DenyList often neutralizes naive checks. +Beaucoup d'apps ne regardent que des indicateurs évidents (su/Magisk paths/getprop). DenyList neutralise souvent les vérifications naïves. References: - Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk ## Step 2 — 30‑second Frida Codeshare tests -Try common drop‑in scripts before deep diving: +Essayez des scripts drop‑in courants avant d'approfondir : - anti-root-bypass.js - anti-frida-detection.js - hide_frida_gum.js -Exemple: +Example: ```bash frida -U -f com.example.app -l anti-frida-detection.js ``` -Ces techniques neutralisent généralement les vérifications Java root/debug, les process/service scans et ptrace() natifs. Utile sur des apps peu protégées ; les hardened targets peuvent nécessiter des hooks adaptés. +Ces modules remplacent généralement les vérifications Java de root/debug, les scans de processus/services et l'appel natif ptrace(). Utiles sur des applications faiblement protégées ; les cibles durcies peuvent nécessiter des hooks sur mesure. - Codeshare: https://codeshare.frida.re/ -## Étape 3 — Contourner les détecteurs init-time en s'attachant tardivement +## Automatiser avec Medusa (Frida framework) -Beaucoup de détections ne s'exécutent que lors du process spawn/onCreate(). Les injections au spawn (-f) ou les gadgets se font repérer ; s'attacher après le chargement de l'UI peut permettre de passer outre. +Medusa fournit plus de 90 modules prêts à l'emploi pour SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception, et plus encore. +```bash +git clone https://github.com/Ch0pin/medusa +cd medusa +pip install -r requirements.txt +python medusa.py + +# Example interactive workflow +show categories +use http_communications/multiple_unpinner +use root_detection/universal_root_detection_bypass +run com.target.app +``` +Astuce : Medusa est great pour quick wins avant d'écrire des custom hooks. Vous pouvez aussi cherry-pick des modules et les combiner avec vos propres scripts. + +## Étape 3 — Contourner les détecteurs au démarrage en s'attachant tardivement + +De nombreuses détections ne s'exécutent que lors du process spawn/onCreate(). Spawn‑time injection (-f) ou gadgets sont détectés ; s'attacher après le chargement de l'UI peut permettre de passer. ```bash # Launch the app normally (launcher/adb), wait for UI, then attach frida -U -n com.example.app # Or with Objection to attach to running process aobjection --gadget com.example.app explore # if using gadget ``` -Si cela fonctionne, maintenez la session stable et procédez à la cartographie et aux vérifications des stubs. +Si cela fonctionne, maintenez la session stable et procédez à la cartographie et aux vérifications de stubs. -## Étape 4 — Cartographier la logique de détection via Jadx et recherche de chaînes +## Étape 4 — Cartographier la logique de détection via Jadx et la recherche de chaînes Mots-clés de triage statique dans Jadx : - "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger" @@ -70,7 +87,7 @@ APIs courantes à examiner/hook: ## Étape 5 — Runtime stubbing with Frida (Java) -Surcharger les vérifications personnalisées pour renvoyer des valeurs sûres sans repacking: +Outrepasser les gardes personnalisés pour renvoyer des valeurs sûres sans repacking : ```js Java.perform(() => { const Checks = Java.use('com.example.security.Checks'); @@ -85,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager'); AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); }; }); ``` -Triage des plantages précoces ? Dump classes juste avant que l'application ne plante pour repérer les namespaces de détection probables : +Triage des plantages précoces ? Dump classes juste avant qu'il ne plante pour repérer les namespaces de détection probables : ```js Java.perform(() => { Java.enumerateLoadedClasses({ @@ -94,7 +111,15 @@ onComplete: () => console.log('Done') }); }); ``` -Consigner et neutraliser les méthodes suspectes pour confirmer le flux d'exécution : +// Quick root detection stub example (adapt to target package/class names) +Java.perform(() => { +try { +const RootChecker = Java.use('com.target.security.RootCheck'); +RootChecker.isDeviceRooted.implementation = function () { return false; }; +} catch (e) {} +}); + +Consignez et neutralisez les méthodes suspectes pour confirmer le flux d'exécution : ```js Java.perform(() => { const Det = Java.use('com.example.security.DetectionManager'); @@ -104,9 +129,49 @@ return false; }; }); ``` +## Bypass emulator/VM detection (Java stubs) + +Heuristiques courantes : Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE contenant generic/goldfish/ranchu/sdk ; artefacts QEMU comme /dev/qemu_pipe, /dev/socket/qemud ; MAC par défaut 02:00:00:00:00:00 ; 10.0.2.x NAT ; absence de téléphonie/senseurs. + +Falsification rapide des champs Build : +```js +Java.perform(function(){ +var Build = Java.use('android.os.Build'); +Build.MODEL.value = 'Pixel 7 Pro'; +Build.MANUFACTURER.value = 'Google'; +Build.BRAND.value = 'google'; +Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys'; +}); +``` +Compléter avec des stubs pour les vérifications d'existence de fichiers et les identifiants (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) afin de renvoyer des valeurs réalistes. + +## SSL pinning bypass quick hook (Java) + +Neutraliser les TrustManagers personnalisés et forcer des SSL contexts permissifs : +```js +Java.perform(function(){ +var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager'); +var SSLContext = Java.use('javax.net.ssl.SSLContext'); + +// No-op validations +X509TrustManager.checkClientTrusted.implementation = function(){ }; +X509TrustManager.checkServerTrusted.implementation = function(){ }; + +// Force permissive TrustManagers +var TrustManagers = [ X509TrustManager.$new() ]; +var SSLContextInit = SSLContext.init.overload('[Ljavax.net.ssl.KeyManager;','[Ljavax.net.ssl.TrustManager;','java.security.SecureRandom'); +SSLContextInit.implementation = function(km, tm, sr){ +return SSLContextInit.call(this, km, TrustManagers, sr); +}; +}); +``` +Remarques +- Étendez pour OkHttp : hook okhttp3.CertificatePinner et HostnameVerifier selon les besoins, ou utilisez un script universel d'unpinning depuis CodeShare. +- Exemple d'exécution : `frida -U -f com.target.app -l ssl-bypass.js --no-pause` + ## Étape 6 — Suivre la piste JNI/native lorsque les hooks Java échouent -Tracer les entry points JNI pour localiser les native loaders et l'init de détection : +Tracez les points d'entrée JNI pour localiser les loaders natifs et l'initialisation de la détection : ```bash frida-trace -n com.example.app -i "JNI_OnLoad" ``` @@ -117,11 +182,11 @@ nm -D libfoo.so | head objdump -T libfoo.so | grep Java_ strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root' ``` -Reversing interactif/natif: +Interactif/natif reversing: - Ghidra: https://ghidra-sre.org/ - r2frida: https://github.com/nowsecure/r2frida -Exemple : neutraliser ptrace pour contourner un anti‑debug simple dans libc: +Exemple: neutraliser ptrace pour contourner un simple anti‑debug dans libc: ```js const ptrace = Module.findExportByName(null, 'ptrace'); if (ptrace) { @@ -130,7 +195,7 @@ return -1; // pretend failure }, 'int', ['int', 'int', 'pointer', 'pointer'])); } ``` -Voir aussi: +Voir aussi : {{#ref}} reversing-native-libraries.md {{#endref}} @@ -142,15 +207,17 @@ Si vous préférez le repacking aux runtime hooks, essayez : objection patchapk --source app.apk ``` Remarques: -- Nécessite apktool ; assurez-vous d'avoir une version récente à partir du guide officiel pour éviter des problèmes de build : https://apktool.org/docs/install -- Gadget injection permet l'instrumentation sans root mais peut quand même être détectée par des vérifications init‑time plus strictes. +- Nécessite apktool ; assurez‑vous d'utiliser une version récente depuis le guide officiel pour éviter des problèmes de build : https://apktool.org/docs/install +- Gadget injection permet l'instrumentation sans root mais peut néanmoins être détecté par des vérifications plus strictes à l'initialisation. + +Optionnellement, ajoutez des modules LSPosed et Shamiko pour renforcer la dissimulation du root dans les environnements Zygisk, et paramétrez le DenyList pour couvrir les processus enfants. Références: - Objection: https://github.com/sensepost/objection -## Étape 8 — Solution de secours : Patch TLS pinning pour la visibilité réseau +## Étape 8 — Solution de repli : Patch TLS pinning pour la visibilité réseau -Si l'instrumentation est bloquée, vous pouvez toujours inspecter le trafic en supprimant le pinning statiquement : +Si l'instrumentation est bloquée, vous pouvez toujours inspecter le trafic en supprimant le pinning de façon statique : ```bash apk-mitm app.apk # Then install the patched APK and proxy via Burp/mitmproxy @@ -166,7 +233,7 @@ make-apk-accept-ca-certificate.md install-burp-certificate.md {{#endref}} -## Aide-mémoire pratique des commandes +## Fiche mémo pratique des commandes ```bash # List processes and attach frida-ps -Uai @@ -184,12 +251,12 @@ objection --gadget com.example.app explore # Static TLS pinning removal apk-mitm app.apk ``` -## Conseils & mises en garde +## Astuces & mises en garde -- Privilégiez l'attachement tardif plutôt que le spawn lorsque les apps plantent au lancement -- Certaines détections se relancent dans des flows critiques (e.g., payment, auth) — gardez les hooks actifs pendant la navigation -- Mélangez analyse statique et dynamique : string hunt dans Jadx pour présélectionner des classes ; puis posez des hooks sur les méthodes pour vérifier au runtime -- Les apps hardened peuvent utiliser des packers et du TLS pinning natif — attendez-vous à reverser du code natif +- Préférez attaching late plutôt que spawning lorsque les apps plantent au lancement +- Certaines détections se relancent dans les critical flows (ex., payment, auth) — gardez les hooks actifs pendant la navigation +- Mixez static et dynamic : string hunt dans Jadx pour présélectionner des classes ; puis hook methods pour vérifier à runtime +- Les apps hardenées peuvent utiliser des packers et du native TLS pinning — attendez‑vous à devoir reverse le native code ## Références @@ -202,5 +269,7 @@ apk-mitm app.apk - [r2frida](https://github.com/nowsecure/r2frida) - [Apktool install guide](https://apktool.org/docs/install) - [Magisk](https://github.com/topjohnwu/Magisk) +- [Medusa (Android Frida framework)](https://github.com/Ch0pin/medusa) +- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md index 6afcf9a92..8f7113364 100644 --- a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md +++ b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md @@ -1,4 +1,4 @@ -# AVD - Android Virtual Device +# AVD - Appareil virtuel Android {{#include ../../banners/hacktricks-training.md}} @@ -6,14 +6,14 @@ Merci beaucoup à [**@offsecjay**](https://twitter.com/offsecjay) pour son aide ## Qu'est-ce que c'est -Android Studio permet de **faire fonctionner des machines virtuelles Android que vous pouvez utiliser pour tester des APK**. Pour les utiliser, vous aurez besoin de : +Android Studio permet d'**exécuter des machines virtuelles Android que vous pouvez utiliser pour tester des APKs**. Pour pouvoir les utiliser vous aurez besoin de : -- Les **outils SDK Android** - [Téléchargez ici](https://developer.android.com/studio/releases/sdk-tools). -- Ou **Android Studio** (avec les outils SDK Android) - [Téléchargez ici](https://developer.android.com/studio). +- Les **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools). +- Ou **Android Studio** (avec Android SDK tools) - [Download here](https://developer.android.com/studio). -Sous Windows (dans mon cas), **après avoir installé Android Studio**, j'avais les **outils SDK installés dans** : `C:\Users\\AppData\Local\Android\Sdk\tools` +Sur Windows (dans mon cas) **après avoir installé Android Studio** j'avais les **SDK Tools installés dans**: `C:\Users\\AppData\Local\Android\Sdk\tools` -Sur Mac, vous pouvez **télécharger les outils SDK** et les avoir dans le PATH en exécutant : +Sur mac vous pouvez **télécharger les SDK tools** et les avoir dans le PATH en exécutant: ```bash brew tap homebrew/cask brew install --cask android-sdk @@ -24,11 +24,11 @@ Pour les problèmes Java : ```java export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home ``` -## GUI +## Interface graphique ### Préparer la machine virtuelle -Si vous avez installé Android Studio, vous pouvez simplement ouvrir la vue principale du projet et accéder à : _**Outils**_ --> _**AVD Manager.**_ +Si vous avez installé Android Studio, ouvrez simplement la vue principale du projet et accédez à : _**Tools**_ --> _**AVD Manager.**_
@@ -36,29 +36,29 @@ Si vous avez installé Android Studio, vous pouvez simplement ouvrir la vue prin
-Ensuite, cliquez sur _**Créer un appareil virtuel**_ +Ensuite, cliquez sur _**Create Virtual Device**_
-_**sélectionnez** le téléphone que vous souhaitez utiliser_ et cliquez sur _**Suivant.**_ +_**sélectionnez** le téléphone que vous voulez utiliser_ et cliquez sur _**Next.**_ > [!WARNING] -> Si vous avez besoin d'un téléphone avec le Play Store installé, sélectionnez-en un avec l'icône du Play Store dessus ! +> Si vous avez besoin d'un téléphone avec Play Store installé, sélectionnez-en un avec l'icône Play Store ! > > -Dans la vue actuelle, vous allez pouvoir **sélectionner et télécharger l'image Android** que le téléphone va exécuter : +Dans cette vue, vous pourrez **sélectionner et télécharger l'image Android** que le téléphone va exécuter :
-Donc, sélectionnez-la et si elle n'est pas téléchargée, cliquez sur le symbole _**Télécharger**_ à côté du nom (**attendez maintenant que l'image soit téléchargée).**\ -Une fois l'image téléchargée, sélectionnez simplement **`Suivant`** et **`Terminer`**. +Donc, sélectionnez-la et si elle n'est pas téléchargée cliquez sur le symbole _**Download**_ à côté du nom (**attendez maintenant que l'image soit téléchargée).**\ +Une fois l'image téléchargée, sélectionnez simplement **`Next`** et **`Finish`**. -La machine virtuelle sera créée. Maintenant **chaque fois que vous accédez au gestionnaire AVD, elle sera présente**. +La machine virtuelle sera créée. Maintenant **à chaque fois que vous ouvrirez AVD Manager elle sera présente**. -### Exécuter la machine virtuelle +### Lancer la machine virtuelle -Pour **lancer** la machine, appuyez simplement sur le _**bouton Démarrer**_. +Pour la **lancer**, appuyez simplement sur le _**Start button**_. ![](<../../images/image (518).png>) @@ -67,7 +67,7 @@ Pour **lancer** la machine, appuyez simplement sur le _**bouton Démarrer**_. > [!WARNING] > Pour macOS, vous pouvez trouver l'outil `avdmanager` dans `/Users//Library/Android/sdk/tools/bin/avdmanager` et l'`emulator` dans `/Users//Library/Android/sdk/emulator/emulator` si vous les avez installés. -Tout d'abord, vous devez **décider quel téléphone vous souhaitez utiliser**, afin de voir la liste des téléphones possibles, exécutez : +Tout d'abord, vous devez **décider quel téléphone vous voulez utiliser**, pour afficher la liste des téléphones possibles exécutez: ``` C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device @@ -95,7 +95,7 @@ Name: Nexus 10 OEM : Google [...] ``` -Une fois que vous avez décidé du nom de l'appareil que vous souhaitez utiliser, vous devez **décider quelle image Android vous souhaitez exécuter sur cet appareil.**\ +Une fois que vous avez choisi le nom de l'appareil que vous voulez utiliser, vous devez **déterminer quelle image Android vous souhaitez exécuter sur cet appareil.**\ Vous pouvez lister toutes les options en utilisant `sdkmanager`: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list @@ -120,12 +120,12 @@ Type: Platform API level: 29 Revision: 4 ``` -À ce moment, vous avez décidé de l'appareil que vous souhaitez utiliser et vous avez téléchargé l'image Android, donc **vous pouvez créer la machine virtuelle en utilisant** : +À ce stade, vous avez choisi l'appareil que vous souhaitez utiliser et vous avez téléchargé l'image Android, donc **vous pouvez créer la machine virtuelle en utilisant** : ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X" ``` -Dans la dernière commande, **j'ai créé une VM nommée** "_AVD9_" en utilisant le **dispositif** "_Nexus 5X_" et l'**image Android** "_system-images;android-28;google_apis;x86_64_".\ -Maintenant, vous pouvez **lister les machines virtuelles** que vous avez créées avec : +Dans la dernière commande **j'ai créé une VM nommée** "_AVD9_" en utilisant le **device** "_Nexus 5X_" et l'**image Android** "_system-images;android-28;google_apis;x86_64_".\ +Maintenant vous pouvez **lister les machines virtuelles** que vous avez créées avec : ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd @@ -140,12 +140,12 @@ Name: Pixel_2_API_27 Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd Error: Google pixel_2 no longer exists as a device ``` -### Exécuter une machine virtuelle +### Lancer la machine virtuelle > [!WARNING] -> Pour macOS, vous pouvez trouver l'outil `avdmanager` dans `/Users//Library/Android/sdk/tools/bin/avdmanager` et l'`emulator` dans `/Users//Library/Android/sdk/emulator/emulator` si vous les avez installés. +> Pour macOS vous pouvez trouver l'outil `avdmanager` dans `/Users//Library/Android/sdk/tools/bin/avdmanager` et l'`emulator` dans `/Users//Library/Android/sdk/emulator/emulator` si vous les avez installés. -Nous avons déjà vu comment vous pouvez lister les machines virtuelles créées, mais **vous pouvez également les lister en utilisant** : +Nous avons déjà vu comment lister les machines virtuelles créées, mais **vous pouvez aussi les lister en utilisant**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds AVD9 @@ -162,53 +162,108 @@ C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -ht ``` ### Options de ligne de commande -Cependant, il existe **beaucoup d'options utiles de ligne de commande** que vous pouvez utiliser pour initier une machine virtuelle. Ci-dessous, vous pouvez trouver quelques options intéressantes mais vous pouvez [**trouver une liste complète ici**](https://developer.android.com/studio/run/emulator-commandline) +Cependant il existe **de nombreuses options utiles en ligne de commande** que vous pouvez utiliser pour lancer une machine virtuelle. Vous trouverez ci-dessous quelques options intéressantes mais vous pouvez [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline) **Démarrage** -- `-snapshot name` : Démarrer un instantané de la VM -- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Lister tous les instantanés enregistrés +- `-snapshot name` : Démarrer un snapshot de la VM +- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Lister tous les snapshots enregistrés **Réseau** -- `-dns-server 192.0.2.0, 192.0.2.255` : Permet d'indiquer séparés par des virgules les serveurs DNS à la VM. +- `-dns-server 192.0.2.0, 192.0.2.255` : Permet d'indiquer, séparés par des virgules, les serveurs DNS pour la VM. - **`-http-proxy 192.168.1.12:8080`** : Permet d'indiquer un proxy HTTP à utiliser (très utile pour capturer le trafic avec Burp) - Si les paramètres du proxy ne fonctionnent pas pour une raison quelconque, essayez de les configurer en interne ou en utilisant une application comme "Super Proxy" ou "ProxyDroid". -- `-netdelay 200` : Définir l'émulation de latence réseau en millisecondes. -- `-port 5556` : Définir le numéro de port TCP utilisé pour la console et adb. -- `-ports 5556,5559` : Définir les ports TCP utilisés pour la console et adb. -- **`-tcpdump /path/dumpfile.cap`** : Capturer tout le trafic dans un fichier +- `-netdelay 200` : Définit la latence réseau simulée en millisecondes. +- `-port 5556` : Définit le numéro de port TCP utilisé pour la console et adb. +- `-ports 5556,5559` : Définit les ports TCP utilisés pour la console et adb. +- **`-tcpdump /path/dumpfile.cap`** : Capture tout le trafic dans un fichier **Système** -- `-selinux {disabled|permissive}` : Définir le module de sécurité Security-Enhanced Linux sur mode désactivé ou permissif sur un système d'exploitation Linux. -- `-timezone Europe/Paris` : Définir le fuseau horaire pour le dispositif virtuel -- `-screen {touch(default)|multi-touch|o-touch}` : Définir le mode d'écran tactile émulé. -- **`-writable-system`** : Utilisez cette option pour avoir une image système modifiable pendant votre session d'émulation. Vous devrez également exécuter `adb root; adb remount`. C'est très utile pour installer un nouveau certificat dans le système. +- `-selinux {disabled|permissive}` : Définit le module de sécurité Security-Enhanced Linux en mode disabled ou permissive sur un système Linux. +- `-timezone Europe/Paris` : Définit le fuseau horaire pour le périphérique virtuel +- `-screen {touch(default)|multi-touch|o-touch}` : Définit le mode d'écran tactile émulé. +- **`-writable-system`** : Utilisez cette option pour disposer d'une image système en écriture durant votre session d'émulation. Vous devrez aussi exécuter `adb root; adb remount`. Ceci est très utile pour installer un nouveau certificat dans le système. -## Rooter un appareil Play Store +## Linux CLI setup (SDK/AVD quickstart) -Si vous avez téléchargé un appareil avec Play Store, vous ne pourrez pas obtenir le root directement, et vous recevrez ce message d'erreur +Les outils CLI officiels facilitent la création d'émulateurs rapides et débogables sans Android Studio. +```bash +# Directory layout +mkdir -p ~/Android/cmdline-tools/latest + +# Download commandline tools (Linux) +wget https://dl.google.com/android/repository/commandlinetools-linux-13114758_latest.zip -O /tmp/cmdline-tools.zip +unzip /tmp/cmdline-tools.zip -d ~/Android/cmdline-tools/latest +rm /tmp/cmdline-tools.zip + +# Env vars (add to ~/.bashrc or ~/.zshrc) +export ANDROID_HOME=$HOME/Android +export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH + +# Install core SDK components +sdkmanager --install "platform-tools" "emulator" + +# Install a debuggable x86_64 system image (Android 11 / API 30) +sdkmanager --install "system-images;android-30;google_apis;x86_64" + +# Create an AVD and run it with a writable /system & snapshot name +avdmanager create avd -n PixelRootX86 -k "system-images;android-30;google_apis;x86_64" -d "pixel" +emulator -avd PixelRootX86 -writable-system -snapshot PixelRootX86_snap + +# Verify root (debuggable images allow `adb root`) +adb root +adb shell whoami # expect: root +``` +Notes +- Variantes d'images système: google_apis (déboggable, permet `adb root`), google_apis_playstore (non rootable), aosp/default (léger). +- Types de build: userdebug permet souvent `adb root` sur les images compatibles debug. Les images Play Store sont des builds de production et bloquent l'accès root. +- Sur les hôtes x86_64, l'émulation système complète ARM64 n'est pas prise en charge à partir de API 28+. Pour Android 11+ utilisez les images Google APIs/Play qui incluent une traduction ARM-vers-x86 par application pour exécuter rapidement de nombreuses apps réservées à ARM. + +### Instantanés depuis la CLI +```bash +# Save a clean snapshot from the running emulator +adb -s emulator-5554 emu avd snapshot save my_clean_setup + +# Boot from a named snapshot (if it exists) +emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup +``` +## Traduction binaire ARM→x86 (Android 11+) + +Les images Google APIs et Play Store sur Android 11+ peuvent traduire les binaires d'applications ARM par processus tout en conservant le reste du système natif x86/x86_64. C'est souvent suffisamment rapide pour tester de nombreuses applications réservées à ARM sur un desktop. + +> Astuce : Préférez les images Google APIs x86/x86_64 pendant les pentests. Les images Play sont pratiques mais bloquent `adb root` ; ne les utilisez que lorsque vous avez spécifiquement besoin des Play services et acceptez l'absence de root. + +## Rooting a Play Store device + +Si vous avez téléchargé un appareil avec Play Store, vous ne pourrez pas obtenir le root directement, et vous obtiendrez ce message d'erreur ``` $ adb root adbd cannot run as root in production builds ``` -Utiliser [rootAVD](https://github.com/newbit1/rootAVD) avec [Magisk](https://github.com/topjohnwu/Magisk) m'a permis de le rooter (suivez par exemple [**cette vidéo**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **ou** [**celle-ci**](https://www.youtube.com/watch?v=qQicUW0svB8)). +En utilisant [rootAVD](https://github.com/newbit1/rootAVD) avec [Magisk](https://github.com/topjohnwu/Magisk) j'ai pu obtenir l'accès root (suivez par exemple [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **ou** [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)). ## Installer le certificat Burp -Consultez la page suivante pour apprendre à installer un certificat CA personnalisé : +Consultez la page suivante pour apprendre comment installer un certificat CA personnalisé : {{#ref}} install-burp-certificate.md {{#endref}} -## Options AVD intéressantes +## Options utiles pour l'AVD -### Prendre un instantané +### Prendre un snapshot -Vous pouvez **utiliser l'interface graphique** pour prendre un instantané de la VM à tout moment : +Vous pouvez **utiliser la GUI** pour prendre un snapshot de la VM à tout moment : ![](<../../images/image (234).png>) +## Références + +- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) +- [Android Emulator command line](https://developer.android.com/studio/run/emulator-commandline) +- [Run ARM apps on the Android Emulator (x86 translation)](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md index 8a5632a80..62b282d2f 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md @@ -1,30 +1,83 @@ -# Frida Tutorial +# Frida Tutoriel {{#include ../../../banners/hacktricks-training.md}} ## Installation -Installez **frida tools**: +Installer **frida tools**: ```bash pip install frida-tools pip install frida ``` -**Téléchargez et installez** sur l'android le **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ -Commande unique pour redémarrer adb en mode root, se connecter, télécharger frida-server, donner des permissions d'exécution et l'exécuter en arrière-plan : +**Télécharger et installer** sur l'appareil Android le **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ +Commande en une ligne pour redémarrer adb en mode root, s'y connecter, transférer frida-server, lui donner les permissions d'exécution et le lancer en arrière-plan: ```bash adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &" ``` -**Vérifiez** si cela **fonctionne** : +**Vérifier** si cela **fonctionne**: ```bash frida-ps -U #List packages and processes frida-ps -U | grep -i #Get all the package name ``` +## Frida server vs. Gadget (root vs. no-root) + +Deux façons courantes d'instrumenter des applications Android avec Frida : + +- Frida server (rooted devices): Poussez et exécutez un daemon natif qui vous permet de vous attacher à n'importe quel processus. +- Frida Gadget (no root): Intégrez Frida en tant que bibliothèque partagée dans l'APK et chargez-la automatiquement dans le processus cible. + +Frida server (rooted) +```bash +# Download the matching frida-server binary for your device's arch +# https://github.com/frida/frida/releases +adb root +adb push frida-server--android- /data/local/tmp/frida-server +adb shell chmod 755 /data/local/tmp/frida-server +adb shell /data/local/tmp/frida-server & # run at boot via init/magisk if desired + +# From host, list processes and attach +frida-ps -Uai +frida -U -n com.example.app +``` +Frida Gadget (no-root) + +1) Décompressez l'APK, ajoutez le gadget .so et la configuration : +- Placez libfrida-gadget.so dans lib// (p. ex., lib/arm64-v8a/) +- Créez assets/frida-gadget.config avec les paramètres de chargement de vos scripts + +Exemple frida-gadget.config +```json +{ +"interaction": { "type": "script", "path": "/sdcard/ssl-bypass.js" }, +"runtime": { "logFile": "/sdcard/frida-gadget.log" } +} +``` +2) Référencer/charger le gadget afin qu'il soit initialisé tôt : +- Le plus simple : ajouter un petit stub Java qui appelle System.loadLibrary("frida-gadget") dans Application.onCreate(), ou utiliser le chargement natif de la bibliothèque déjà présent. + +3) Repaqueter et signer l'APK, puis l'installer : +```bash +apktool d app.apk -o app_m +# ... add gadget .so and config ... +apktool b app_m -o app_gadget.apk +uber-apk-signer -a app_gadget.apk -o out_signed +adb install -r out_signed/app_gadget-aligned-debugSigned.apk +``` +4) Attacher depuis l'hôte au processus gadget : +```bash +frida-ps -Uai +frida -U -n com.example.app +``` +Remarques +- Gadget est détecté par certaines protections ; gardez les noms/chemins discrets et chargez-le tardivement/de façon conditionnelle si nécessaire. +- Sur les applications durcies, privilégiez les tests sur appareils rootés avec server + late attach, ou combinez avec Magisk/Zygisk hiding. + ## Tutoriels ### [Tutoriel 1](frida-tutorial-1.md) -**De**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ +**Source**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ **APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\ **Code source**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo) @@ -32,19 +85,19 @@ frida-ps -U | grep -i #Get all the package name ### [Tutoriel 2](frida-tutorial-2.md) -**De**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parties 2, 3 & 4)\ +**Source**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parties 2, 3 & 4)\ **APKs et code source**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) **Suivez le [lien pour le lire.](frida-tutorial-2.md)** ### [Tutoriel 3](owaspuncrackable-1.md) -**De**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\ +**Source**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\ **APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk) **Suivez le [lien pour le lire](owaspuncrackable-1.md).** -**Vous pouvez trouver plus de scripts Frida géniaux ici :** [**https://codeshare.frida.re/**](https://codeshare.frida.re) +**Vous pouvez trouver plus de scripts Awesome Frida ici:** [**https://codeshare.frida.re/**](https://codeshare.frida.re) ## Exemples rapides @@ -72,9 +125,9 @@ print('[ * ] Running Frida Demo application') script.load() sys.stdin.read() ``` -### Hooking functions without parameters +### Hooking des fonctions sans paramètres -Hookez la fonction `a()` de la classe `sg.vantagepoint.a.c` +Hook la fonction `a()` de la classe `sg.vantagepoint.a.c` ```javascript Java.perform(function () { ; rootcheck1.a.overload().implementation = function() { @@ -91,7 +144,7 @@ sysexit.exit.overload("int").implementation = function (var_0) { send("java.lang.System.exit(I)V // We avoid exiting the application :)") } ``` -Accrocher MainActivity `.onStart()` & `.onCreate()` +Hook MainActivity `.onStart()` & `.onCreate()` ```javascript var mainactivity = Java.use("sg.vantagepoint.uncrackable1.MainActivity") mainactivity.onStart.overload().implementation = function () { @@ -115,9 +168,9 @@ send("Activity HIT!!!") var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0) } ``` -### Accrocher des fonctions avec des paramètres et récupérer la valeur +### Hooking des fonctions avec des paramètres et récupération de la valeur -Accrocher une fonction de décryptage. Imprimer l'entrée, appeler la fonction originale pour déchiffrer l'entrée et enfin, imprimer les données en clair : +Hooking d'une fonction de decryption. Affichez l'entrée, appelez la fonction originale pour decrypt l'entrée et enfin affichez les données en clair : ```javascript function getString(data) { var ret = "" @@ -142,9 +195,9 @@ send("Decrypted flag: " + flag) return ret //[B } ``` -### Accrocher des fonctions et les appeler avec notre entrée +### Hooking des fonctions et les appeler avec notre entrée -Accrochez une fonction qui reçoit une chaîne et appelez-la avec une autre chaîne (de [ici](https://11x256.github.io/Frida-hooking-android-part-2/)) +Hook une fonction qui reçoit une string et l'appeler avec une autre string (d'après [here](https://11x256.github.io/Frida-hooking-android-part-2/)) ```javascript var string_class = Java.use("java.lang.String") // get a JS wrapper for java's String class @@ -159,9 +212,9 @@ return ret ``` ### Obtenir un objet déjà créé d'une classe -Si vous souhaitez extraire un attribut d'un objet créé, vous pouvez utiliser ceci. +Si vous voulez extraire un attribut d'un objet déjà créé, vous pouvez utiliser ceci. -Dans cet exemple, vous allez voir comment obtenir l'objet de la classe my_activity et comment appeler la fonction .secret() qui imprimera un attribut privé de l'objet : +Dans cet exemple, vous allez voir comment obtenir l'objet de la classe my_activity et comment appeler la fonction .secret() qui affichera un attribut privé de l'objet : ```javascript Java.choose("com.example.a11x256.frida_test.my_activity", { onMatch: function (instance) { @@ -175,7 +228,13 @@ onComplete: function () {}, ## Autres tutoriels Frida - [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs) -- [Partie 1 de la série de blogs sur l'utilisation avancée de Frida : Bibliothèques de chiffrement IOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) +- [Part 1 of Advanced Frida Usage blog series: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) +## Références + +- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) +- [Frida Gadget documentation](https://frida.re/docs/gadget/) +- [Frida releases (server binaries)](https://github.com/frida/frida/releases) + {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md index ad29cbf43..7e93ff45d 100644 --- a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md +++ b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md @@ -3,18 +3,30 @@ {{#include ../../banners/hacktricks-training.md}} +## Proxy système via ADB + +Configurez un proxy HTTP global afin que toutes les applications acheminent le trafic via votre intercepteur (Burp/mitmproxy) : +```bash +# Set proxy (device/emulator must reach your host IP) +adb shell settings put global http_proxy 192.168.1.2:8080 + +# Clear proxy +adb shell settings put global http_proxy :0 +``` +Astuce : Dans Burp, liez votre listener à 0.0.0.0 afin que les appareils sur le LAN puissent se connecter (Proxy -> Options -> Proxy Listeners). + ## Sur une machine virtuelle -Tout d'abord, vous devez télécharger le certificat Der depuis Burp. Vous pouvez le faire dans _**Proxy**_ --> _**Options**_ --> _**Importer / Exporter le certificat CA**_ +Tout d'abord, vous devez télécharger le certificat Der depuis Burp. Vous pouvez le faire dans _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_ ![](<../../images/image (367).png>) -**Exportez le certificat au format Der** et **transformons-le** en une forme que **Android** pourra **comprendre.** Notez que **pour configurer le certificat burp sur la machine Android dans AVD**, vous devez **exécuter** cette machine **avec** l'option **`-writable-system`**.\ -Par exemple, vous pouvez l'exécuter comme : +**Exportez le certificat au format Der** et transformons-le pour obtenir une forme que **Android** pourra **comprendre.** Notez que **pour configurer le certificat Burp sur la machine Android dans AVD** vous devez **exécuter** cette machine **avec** l'option **`-writable-system`**.\ +Par exemple vous pouvez l'exécuter comme : ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system ``` -Ensuite, pour **configurer le certificat burp, faites** : +Ensuite, pour **configurer le certificat de burps**, faites : ```bash openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0" @@ -25,39 +37,43 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges adb reboot #Now, reboot the machine ``` -Une fois que la **machine a terminé de redémarrer**, le certificat Burp sera en cours d'utilisation ! +Une fois que la machine a terminé le redémarrage, le certificat Burp sera utilisé par celle-ci ! -## Utiliser Magisc +## Using Magisc -Si vous **avez rooté votre appareil avec Magisc** (peut-être un émulateur), et que vous **ne pouvez pas suivre** les **étapes** précédentes pour installer le certificat Burp parce que le **système de fichiers est en lecture seule** et que vous ne pouvez pas le remonter en écriture, il existe une autre méthode. +Si vous avez **rooté votre appareil avec Magisc** (peut‑être un émulateur), et que vous **ne pouvez pas suivre** les **étapes** précédentes pour installer le certificat Burp parce que le **système de fichiers est en lecture seule** et que vous ne pouvez pas le remonter en écriture, il existe une autre méthode. -Expliqué dans [**cette vidéo**](https://www.youtube.com/watch?v=qQicUW0svB8), vous devez : +Expliqué dans [**cette vidéo**](https://www.youtube.com/watch?v=qQicUW0svB8) vous devez : -1. **Installer un certificat CA** : Il suffit de **faire glisser et déposer** le certificat Burp DER **en changeant l'extension** en `.crt` sur le mobile afin qu'il soit stocké dans le dossier Téléchargements et aller à `Installer un certificat` -> `Certificat CA` +1. **Installer un certificat CA** : Il suffit de **drag&drop** le certificat Burp au format DER en **changeant l’extension** en `.crt` sur le mobile pour qu’il soit stocké dans le dossier Downloads et aller à `Install a certificate` -> `CA certificate`
-- Vérifiez que le certificat a été correctement stocké en allant à `Informations d'identification de confiance` -> `UTILISATEUR` +- Vérifiez que le certificat a été correctement stocké en allant dans `Trusted credentials` -> `USER`
-2. **Le rendre de confiance pour le système** : Téléchargez le module Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (un fichier .zip), **faites-le glisser et déposez-le** dans le téléphone, allez dans l'application **Magics** sur le téléphone dans la section **`Modules`**, cliquez sur **`Installer depuis le stockage`**, sélectionnez le module `.zip` et une fois installé, **redémarrez** le téléphone : +2. **Le rendre approuvé par le système** : Téléchargez le module Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (un fichier .zip), **drag&drop** le sur le téléphone, allez dans l’app Magics du téléphone à la section **`Modules`**, cliquez sur **`Install from storage`**, sélectionnez le module `.zip` et une fois installé **redémarrez** le téléphone :
-- Après le redémarrage, allez à `Informations d'identification de confiance` -> `SYSTÈME` et vérifiez que le certificat Postswigger est là +- Après le redémarrage, allez dans `Trusted credentials` -> `SYSTEM` et vérifiez que le certificat Postswigger est présent
+### Learn how to create a Magisc module + +Consultez [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437) + ## Post Android 14 -Dans la dernière version d'Android 14, un changement significatif a été observé dans la gestion des certificats d'autorité de certification (CA) de confiance par le système. Auparavant, ces certificats étaient logés dans **`/system/etc/security/cacerts/`**, accessibles et modifiables par les utilisateurs ayant des privilèges root, ce qui permettait une application immédiate à travers le système. Cependant, avec Android 14, l'emplacement de stockage a été déplacé vers **`/apex/com.android.conscrypt/cacerts`**, un répertoire au sein du chemin **`/apex`**, qui est immuable par nature. +Dans la dernière release d’Android 14, un changement important a été observé dans la gestion des certificats d’autorité (CA) approuvés par le système. Auparavant, ces certificats étaient stockés dans **`/system/etc/security/cacerts/`**, accessibles et modifiables par les utilisateurs avec les privilèges root, ce qui permettait une application immédiate sur l’ensemble du système. Cependant, avec Android 14, l’emplacement de stockage a été déplacé vers **`/apex/com.android.conscrypt/cacerts`**, un répertoire situé dans le chemin **`/apex`**, qui est immuable par nature. -Les tentatives de remonter le **chemin APEX cacerts** en écriture échouent, car le système n'autorise pas de telles opérations. Même les tentatives de démonter ou de superposer le répertoire avec un système de fichiers temporaire (tmpfs) ne contournent pas l'immutabilité ; les applications continuent d'accéder aux données de certificat originales, quelles que soient les modifications au niveau du système de fichiers. Cette résilience est due au montage **`/apex`** étant configuré avec une propagation PRIVÉE, garantissant que toute modification dans le répertoire **`/apex`** n'affecte pas d'autres processus. +Les tentatives de remonter le **APEX cacerts path** en écriture échouent, car le système n’autorise pas ce type d’opération. Même les tentatives de démontage ou de superposition du répertoire avec un système de fichiers temporaire (tmpfs) ne contournent pas l’immuabilité ; les applications continuent d’accéder aux données de certificats d’origine quelles que soient les modifications au niveau du système de fichiers. Cette résilience est due au fait que le montage de **`/apex`** est configuré avec une PRIVATE propagation, ce qui garantit que toute modification au sein du répertoire **`/apex`** n’affecte pas les autres processus. -L'initialisation d'Android implique le processus `init`, qui, lors du démarrage du système d'exploitation, initie également le processus Zygote. Ce processus est responsable du lancement des processus d'application avec un nouvel espace de montage qui inclut un montage **`/apex`** privé, isolant ainsi les modifications apportées à ce répertoire des autres processus. +L’initialisation d’Android implique le processus `init` qui, au démarrage du système d’exploitation, lance également le processus Zygote. Ce dernier est responsable du lancement des processus d’application avec un nouveau mount namespace qui inclut un montage privé **`/apex`**, isolant ainsi les modifications de ce répertoire des autres processus. -Néanmoins, une solution de contournement existe pour ceux qui ont besoin de modifier les certificats CA de confiance pour le système dans le répertoire **`/apex`**. Cela implique de remonter manuellement **`/apex`** pour supprimer la propagation PRIVÉE, le rendant ainsi modifiable. Le processus comprend la copie du contenu de **`/apex/com.android.conscrypt`** vers un autre emplacement, le démontage du répertoire **`/apex/com.android.conscrypt`** pour éliminer la contrainte de lecture seule, puis la restauration du contenu à son emplacement d'origine dans **`/apex`**. Cette approche nécessite une action rapide pour éviter les plantages du système. Pour garantir l'application systémique de ces modifications, il est recommandé de redémarrer le `system_server`, ce qui redémarre effectivement toutes les applications et ramène le système à un état cohérent. +Néanmoins, il existe un contournement pour ceux qui doivent modifier les certificats CA approuvés par le système dans le répertoire **`/apex`**. Il consiste à remonter manuellement **`/apex`** pour retirer la PRIVATE propagation, rendant ainsi le répertoire modifiable. Le processus inclut la copie du contenu de **`/apex/com.android.conscrypt`** vers un autre emplacement, le démontage du répertoire **`/apex/com.android.conscrypt`** pour éliminer la contrainte en lecture seule, puis la restauration du contenu à son emplacement d’origine dans **`/apex`**. Cette approche nécessite une exécution rapide pour éviter des plantages système. Pour garantir l’application des changements à l’échelle du système, il est recommandé de redémarrer le `system_server`, ce qui redémarre effectivement toutes les applications et ramène le système à un état cohérent. ```bash # Create a separate temp directory, to hold the current certificates # Otherwise, when we add the mount we can't read the current certs anymore. @@ -117,26 +133,26 @@ echo "System certificate injected" ``` ### Bind-mounting through NSEnter -1. **Configuration d'un répertoire écrivable** : Initialement, un répertoire écrivable est établi en montant un `tmpfs` sur le répertoire de certificats système non-APEX existant. Cela est réalisé avec la commande suivante : +1. **Setting Up a Writable Directory**: Initialement, un répertoire inscriptible est créé en montant un `tmpfs` sur le répertoire système de certificats non-APEX existant. Ceci est réalisé avec la commande suivante : ```bash mount -t tmpfs tmpfs /system/etc/security/cacerts ``` -2. **Préparation des certificats CA** : Après la configuration du répertoire écrivable, les certificats CA que l'on souhaite utiliser doivent être copiés dans ce répertoire. Cela peut impliquer de copier les certificats par défaut depuis `/apex/com.android.conscrypt/cacerts/`. Il est essentiel d'ajuster les permissions et les étiquettes SELinux de ces certificats en conséquence. -3. **Montage lié pour Zygote** : En utilisant `nsenter`, on entre dans l'espace de noms de montage de Zygote. Zygote, étant le processus responsable du lancement des applications Android, nécessite cette étape pour s'assurer que toutes les applications initiées par la suite utilisent les certificats CA nouvellement configurés. La commande utilisée est : +2. **Préparation des certificats CA** : Après la création du répertoire en écriture, les certificats CA que l'on souhaite utiliser doivent être copiés dans ce répertoire. Cela peut impliquer de copier les certificats par défaut depuis `/apex/com.android.conscrypt/cacerts/`. Il est essentiel d'ajuster les permissions et les labels SELinux de ces certificats en conséquence. +3. **Montage bind pour Zygote** : En utilisant `nsenter`, on entre dans le namespace de montage de Zygote. Zygote, étant le processus responsable du lancement des applications Android, nécessite cette étape afin de s'assurer que toutes les applications lancées à partir de ce moment utilisent les certificats CA nouvellement configurés. La commande utilisée est : ```bash nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` Cela garantit que chaque nouvelle application démarrée respectera la configuration mise à jour des certificats CA. -4. **Application des modifications aux applications en cours d'exécution** : Pour appliquer les modifications aux applications déjà en cours d'exécution, `nsenter` est à nouveau utilisé pour entrer dans l'espace de noms de chaque application individuellement et effectuer un montage de liaison similaire. La commande nécessaire est : +4. **Appliquer les modifications aux applications en cours d'exécution** : Pour appliquer les modifications aux applications déjà en cours d'exécution, `nsenter` est à nouveau utilisé pour entrer dans l'espace de noms de chaque application individuellement et effectuer un bind mount similaire. La commande nécessaire est : ```bash nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` -5. **Approche alternative - Redémarrage doux** : Une méthode alternative consiste à effectuer le montage de liaison sur le processus `init` (PID 1) suivi d'un redémarrage doux du système d'exploitation avec les commandes `stop && start`. Cette approche propagerait les changements à travers tous les espaces de noms, évitant ainsi la nécessité de s'adresser individuellement à chaque application en cours d'exécution. Cependant, cette méthode est généralement moins préférée en raison de l'inconvénient du redémarrage. +5. **Approche alternative — redémarrage logiciel**: Une méthode alternative consiste à effectuer le bind mount sur le processus `init` (PID 1), suivie d'un redémarrage logiciel du système d'exploitation avec les commandes `stop && start`. Cette approche propagerait les changements à travers tous les namespaces, évitant la nécessité de traiter individuellement chaque application en cours d'exécution. Cependant, cette méthode est généralement moins privilégiée en raison de la gêne occasionnée par le redémarrage. ## Références -- [https://httptoolkit.com/blog/android-14-install-system-ca-certificate/](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/) - +- [Android 14: Install a system CA certificate on a rooted device](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/) +- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) {{#include ../../banners/hacktricks-training.md}}