diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index b429020fb..c26c1c08c 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,11 +1,12 @@ -# Pentesting des Applications Android +# Pentesting des applications Android {{#include ../../banners/hacktricks-training.md}} -## Bases des Applications Android +## Notions de base sur les 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** : + {{#ref}} android-applications-basics.md {{#endref}} @@ -13,23 +14,23 @@ 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 les appareils soit via **USB** soit via **réseau** depuis un ordinateur. Cet utilitaire permet le **copie** de fichiers dans les deux sens, **installation** et **désinstallation** d'applications, **exécution** de commandes shell, **sauvegarde** de données, **lecture** de journaux, entre autres fonctions. +**ADB** permet de contrôler les appareils soit via **USB** soit via **Network** depuis un ordinateur. Cet utilitaire 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. -Jetez un œil à la liste suivante de [**Commandes ADB**](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 ou des drapeaux bien obfusqués). Ensuite, il pourrait être intéressant de décompiler l'apk, de modifier le code et de le recompiler.\ -[**Dans ce tutoriel**, vous pouvez **apprendre à décompiler un APK, modifier le code Smali et recompiler l'APK** avec la nouvelle fonctionnalité](smali-changes.md). Cela pourrait être très utile comme **alternative pour plusieurs tests lors de l'analyse dynamique** qui vont être présentés. Ensuite, **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** (peut‑être des passwords bien obfusqués ou des flags). Ensuite, il peut être intéressant de décompiler l'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. Donc, **gardez toujours cette possibilité à l'esprit**. ## Autres astuces intéressantes -- [Usurpation de votre emplacement dans le Play Store](spoofing-your-location-in-play-store.md) -- [API privilégiée Shizuku (accès privilégié non-root basé sur ADB)](shizuku-privileged-api.md) -- [Exploitation des Mécanismes de Mise à Jour In-App Insecure](insecure-in-app-update-rce.md) -- [Abus des Services d'Accessibilité (Android RAT)](accessibility-services-abuse.md) -- **Télécharger des APKs** : [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) -- Extraire l'APK de l'appareil : +- [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md) +- [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) +- [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) +- [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) +- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) +- Extraire l'APK depuis l'appareil: ```bash adb shell pm list packages com.android.insecurebankv2 @@ -48,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Études de cas & Vulnérabilités +## Études de cas & Vulnerabilities {{#ref}} @@ -62,164 +63,168 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Analyse statique -Tout d'abord, pour analyser un APK, vous devriez **jeter un œil au code Java** en utilisant un décompilateur.\ -Veuillez, [**lire ici pour trouver des informations sur les différents décompilateurs disponibles**](apk-decompilers.md). +First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\ +Please, [**read here to find information about different available decompilers**](apk-decompilers.md). ### Recherche d'informations intéressantes -En regardant simplement les **chaînes** 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 **chiffrements**, 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 (identifiants administratifs codés en dur dans l'application). +Rien qu'en regardant les **strings** de l'APK, vous pouvez rechercher des **passwords**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des **api keys**, de l'**encryption**, des **bluetooth uuids**, des **tokens** et tout ce qui est intéressant... recherchez même des backdoors d'exécution de code ou des backdoors d'authentification (hardcoded admin credentials to the app). **Firebase** -Faites particulièrement attention aux **URLs firebase** et vérifiez si elles sont mal configurées. [Plus d'informations sur ce qu'est Firebase et comment l'exploiter ici.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Portez une attention particulière aux **Firebase URLs** et vérifiez si elles sont mal configurées. [Plus d'informations sur ce qu'est Firebase et comment l'exploiter ici.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Compréhension de base de l'application - Manifest.xml, strings.xml +### Basic understanding of the 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 accessibles en utilisant des décompilateurs 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 sont accessibles via des décompilateurs ou en renommant l'extension APK en .zip puis en décompressant. -Les **vulnérabilités** identifiées dans le **Manifest.xml** incluent : +**Vulnerabilities** identified from the **Manifest.xml** include: -- **Applications débogables** : Les applications définies comme débogables (`debuggable="true"`) dans le fichier _Manifest.xml_ posent un risque car elles permettent des connexions pouvant mener à une exploitation. Pour une compréhension plus approfondie sur la façon d'exploiter les applications débogables, référez-vous à un tutoriel sur la recherche et l'exploitation des applications débogables sur un appareil. -- **Paramètres de sauvegarde** : L'attribut `android:allowBackup="false"` doit être explicitement défini pour les applications traitant des informations sensibles afin d'empêcher les sauvegardes de données non autorisées via adb, surtout lorsque le débogage USB est activé. -- **Sécurité réseau** : Les configurations de sécurité réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité comme les certificats et les paramètres de trafic HTTP. Un exemple est de permettre le trafic HTTP pour des domaines spécifiques. -- **Activités et services exportés** : Identifier les activités et services exportés dans le manifeste peut mettre en évidence des composants qui pourraient être mal utilisés. Une analyse plus approfondie lors des tests dynamiques peut révéler comment exploiter ces composants. -- **Fournisseurs de contenu et FileProviders** : Les fournisseurs de contenu 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. -- **Receveurs de diffusion et schémas d'URL** : Ces composants pourraient être exploités, en prêtant une attention particulière à la façon dont les schémas d'URL sont gérés pour les vulnérabilités d'entrée. -- **Versions SDK** : Les attributs `minSdkVersion`, `targetSDKVersion` et `maxSdkVersion` indiquent les versions Android prises en charge, soulignant l'importance de ne pas prendre en charge des versions Android obsolètes et vulnérables pour des raisons de sécurité. +- **Debuggable Applications**: Les applications définies comme debuggable (`debuggable="true"`) dans le fichier _Manifest.xml_ représentent un risque car elles autorisent des connexions pouvant mener à une exploitation. Pour comprendre comment exploiter des applications debuggable, référez-vous à un tutoriel sur la découverte et l'exploitation d'applications debuggable sur un appareil. +- **Backup Settings**: L'attribut `android:allowBackup="false"` devrait être explicitement défini pour les applications manipulant des informations sensibles afin d'empêcher des sauvegardes non autorisées via adb, en particulier lorsque le usb debugging est activé. +- **Network Security**: Les 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 certificate pinning et les réglages du trafic HTTP. Un exemple est d'autoriser le trafic HTTP pour des domaines spécifiques. +- **Exported Activities and Services**: Identifier les activities et services exportés dans le manifest peut mettre en évidence des composants susceptibles d'être détournés. Une analyse plus approfondie en test dynamique peut révéler comment exploiter ces composants. +- **Content Providers and FileProviders**: Des content providers exposés pourraient permettre un accès non autorisé ou la modification de données. La configuration des FileProviders doit également être scrutée. +- **Broadcast Receivers and URL Schemes**: Ces composants pourraient être utilisés pour des exploitations, en portant une attention particulière à la gestion des URL schemes pour des vulnérabilités d'entrée. +- **SDK Versions**: Les attributs `minSdkVersion`, `targetSDKVersion`, et `maxSdkVersion` indiquent les versions Android supportées, ce qui souligne 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 schémas personnalisés et d'autres notes de développeur peuvent être découvertes, soulignant la nécessité d'un examen attentif de ces ressources. +From the **strings.xml** file, sensitive information such as API keys, custom schemas, and other developer notes can be discovered, underscoring the need for careful review of these resources. ### Tapjacking -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 visiblement l'application victime, son interface utilisateur est conçue de manière à tromper l'utilisateur pour qu'il interagisse avec elle, tout en transmettant l'interaction à l'application victime.\ -En effet, cela **aveugle l'utilisateur sur le fait qu'il effectue réellement des actions sur l'application victime**. +**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 visiblement l'application victime, son interface utilisateur est conçue de façon à tromper l'utilisateur pour qu'il interagisse avec elle, tandis qu'elle transmet 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**. -Trouvez plus d'informations dans : +Find more information in: {{#ref}} tapjacking.md {{#endref}} -### Détournement de tâche +### Task Hijacking -Une **activité** avec le **`launchMode`** défini sur **`singleTask` sans aucune `taskAffinity`** définie est vulnérable au détournement de tâche. Cela signifie qu'une **application** peut être installée et si elle est lancée avant la véritable application, elle pourrait **détourner la tâche de la véritable application** (de sorte que l'utilisateur interagira avec l'**application malveillante en pensant qu'il utilise la véritable**). +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 **hijack the task of the real application** (donc l'utilisateur interagira avec la **malicious application en pensant utiliser la vraie**). -Plus d'infos dans : +More info in: {{#ref}} android-task-hijacking.md {{#endref}} -### Stockage de données non sécurisé +### Insecure data storage -**Stockage interne** +**Internal Storage** -Dans Android, les fichiers **stockés** dans le **stockage interne** sont **conçus** pour être **accessibles** exclusivement par l'**application** qui les **a créés**. Cette mesure de sécurité est **appliquée** par le système d'exploitation Android et est généralement adéquate pour les besoins de sécurité de la plupart des applications. Cependant, les développeurs utilisent parfois des modes tels que `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` pour **permettre** le partage de fichiers entre différentes applications. Pourtant, ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris celles potentiellement malveillantes. +Sur 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 suffisante pour la plupart des applications. Cependant, les développeurs utilisent parfois des modes comme `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` pour **permettre** le partage de fichiers entre différentes applications. Ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris potentiellement malveillantes. -1. **Analyse statique :** -- **Assurez-vous** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` est **soigneusement examinée**. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non intentionnel ou non autorisé**. -2. **Analyse dynamique :** -- **Vérifiez** les **permissions** définies sur les fichiers créés par l'application. En particulier, **vérifiez** si des fichiers sont **définis comme lisibles ou modifiables par tous**. Cela peut poser un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers. +1. **Static Analysis:** +- **Ensure** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` soit **examinée attentivement**. Ces modes **peuvent exposer** des fichiers à des accès non souhaités ou non autorisés. +2. **Dynamic Analysis:** +- **Verify** les **permissions** définies sur les fichiers créés par l'app. En particulier, **vérifiez** si des fichiers sont **rendux lisibles ou modifiables worldwide**. Cela peut poser un risque de sécurité important, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers. -**Stockage externe** +**External Storage** -Lorsqu'il s'agit de fichiers sur le **stockage externe**, comme les cartes SD, certaines précautions doivent être prises : +Quand on traite des fichiers sur le **external storage**, comme les cartes SD, certaines précautions doivent être prises: -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. **Préoccupations de sécurité** : -- Étant donné la facilité d'accès, il est conseillé de **ne pas stocker d'informations sensibles** sur le stockage externe. -- Le stockage externe peut être retiré ou accessible par n'importe quelle application, ce qui le rend moins sécurisé. -3. **Gestion des données provenant du stockage externe** : -- Toujours **effectuer une validation des entrées** sur les données récupérées du stockage externe. Cela est crucial car les données proviennent d'une source non fiable. -- Il est fortement déconseillé de stocker des exécutables ou des fichiers de classe sur le stockage externe pour un chargement dynamique. -- Si votre application doit récupérer des fichiers exécutables à partir du stockage externe, 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. **Accessibility**: +- Les fichiers sur external storage sont **globalement lisibles et modifiables**. Cela signifie que toute application ou utilisateur peut y accéder. +2. **Security Concerns**: +- É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. **Handling Data from External Storage**: +- Toujours **effectuer une validation des entrées** sur les données récupérées depuis l'external storage. C'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 classes sur l'external storage pour un chargement dynamique. +- Si votre application doit impérativement récupérer des fichiers exécutables depuis l'external storage, assurez-vous que ces fichiers soient **signés et vérifiés cryptographiquement** avant d'être chargés dynamiquement. Cette étape est vitale pour maintenir l'intégrité de la sécurité de votre application. -Le stockage externe peut être **accédé** dans `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` +External storage can be **accessed** in /storage/emulated/0 , /sdcard , /mnt/sdcard > [!TIP] -> À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoire qui **limite l'accès d'une application au répertoire spécifiquement pour cette application**. Cela empêche une application malveillante d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre application. +> 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. -**Données sensibles stockées en texte clair** +**Sensitive data stored in clear-text** -- **Préférences partagées** : Android permet à chaque application de facilement sauvegarder des fichiers xml dans le chemin `/data/data//shared_prefs/` et il est parfois possible de trouver des informations sensibles en texte clair dans ce dossier. -- **Bases de données** : Android permet à chaque application de facilement sauvegarder des bases de données sqlite dans le chemin `/data/data//databases/` et il est parfois possible de trouver des informations sensibles en texte clair dans ce dossier. +- **Shared preferences**: Android allow to each application to easily save xml files in the path /data/data//shared_prefs/ and sometimes it's possible to find sensitive information in clear-text in that folder. +- **Databases**: Android allow to each application to easily save sqlite databases in the path /data/data//databases/ and sometimes it's possible to find sensitive information in clear-text in that folder. -### TLS cassé +### Broken TLS -**Accepter tous les certificats** +**Accept All Certificates** -Pour une raison quelconque, parfois les développeurs acceptent tous les certificats même si, par exemple, le nom d'hôte ne correspond pas à des lignes de code comme celle-ci : +For some reason sometimes developers accept all the certificates even if for example the hostname does not match with lines of code like the following one: ```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 le certificat CA de Burp sur l'appareil. Vous pouvez également générer avec Burp un certificat pour un nom d'hôte différent et l'utiliser. +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. Vous pouvez également générer avec Burp un certificat pour un nom d'hôte différent et l'utiliser. -### Cryptographie cassée +### Cryptographie défaillante -**Mauvais processus de gestion des clés** +**Processus de gestion des clés insuffisants** -Certains développeurs enregistrent des données sensibles dans le stockage local et les cryptent avec une clé codée en dur/prévisible dans le code. Cela ne devrait pas être fait car un certain reverse engineering pourrait permettre aux attaquants d'extraire les informations confidentielles. +Certains développeurs sauvegardent des données sensibles dans le stockage local et les chiffrent avec une clé codée en dur/prédictible dans le code. Cela ne devrait pas être fait car du reversing pourrait permettre à des attaquants d'extraire les informations confidentielles. **Utilisation d'algorithmes non sécurisés et/ou obsolètes** -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 **hashs** sont utilisés pour stocker des mots de passe par exemple, des hashs résistants à la force brute devraient être utilisés avec du sel. +Les développeurs ne devraient pas utiliser des **deprecated algorithms** pour effectuer des **authorisation checks**, **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é de **d'obfusquer l'APK** pour rendre le travail de reverse engineering plus difficile pour les attaquants. -- Si l'application est sensible (comme les applications bancaires), elle devrait effectuer ses **propres vérifications pour voir si le mobile est rooté** et agir en conséquence. -- Si l'application est sensible (comme les applications bancaires), elle devrait vérifier si un **émulateur** est utilisé. -- Si l'application est sensible (comme les applications bancaires), elle devrait **vérifier sa propre intégrité avant de s'exécuter** pour vérifier si elle a été modifiée. -- Utilisez [**APKiD**](https://github.com/rednaga/APKiD) pour vérifier quel compilateur/emballeur/obfuscateur a été utilisé pour construire l'APK. +- Il est recommandé d'**obfusquer l'APK** pour rendre le travail de reverse engineering plus difficile pour les attaquants. +- 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 de s'exécuter** pour vérifier si elle a été modifiée. +- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK -### Application React Native +### React Native Application + +Read the following page to learn how to easily access javascript code of React applications: -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 + +Read the following page to learn how to easily access C# code of a xamarin applications: -Lisez la page suivante pour apprendre comment accéder facilement au code C# des applications xamarin : {{#ref}} ../xamarin-apps.md {{#endref}} -### Applications Superpackées +### Superpacked Applications -Selon ce [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacké 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 application qui décompresse ce type d'applications... et d'une méthode plus rapide qui consiste à **exécuter l'application et à rassembler les fichiers décompressés à partir du système de fichiers.** +According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** -### Analyse statique de code automatisée +### Automated Static Code Analysis -L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), des **sinks** (qui indiquent à l'outil les **endroits dangereux** où une entrée utilisateur malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-sinks** qui indique une vulnérabilité. +The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. -Avec cette connaissance, **mariana-trench examinera le code et trouvera les vulnérabilités possibles.** +With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. -### Secrets divulgués +### Secrets leaked -Une application peut contenir des secrets (clés API, mots de passe, URLs cachées, sous-domaines...) à l'intérieur que vous pourriez être en mesure de découvrir. Vous pourriez utiliser un outil tel que [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks). +An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) + +### Bypass Biometric Authentication -### Contournement de l'authentification biométrique {{#ref}} bypass-biometric-authentication-android.md {{#endref}} -### Autres fonctions intéressantes +### Other interesting functions -- **Exécution de code** : `Runtime.exec(), ProcessBuilder(), native code:system()` -- **Envoyer des SMS** : `sendTextMessage, sendMultipartTestMessage` -- **Fonctions natives** déclarées comme `native` : `public native, System.loadLibrary, System.load` -- [Lisez ceci pour apprendre **comment inverser les fonctions natives**](reversing-native-libraries.md) +- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` +- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` +- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` +- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) + +### **Other tricks** -### **Autres astuces** {{#ref}} content-protocol.md @@ -231,154 +236,155 @@ content-protocol.md ## Analyse dynamique -> Tout d'abord, vous avez besoin d'un environnement où vous pouvez installer l'application et tout l'environnement (certificat CA de Burp, Drozer et Frida principalement). Par conséquent, un appareil rooté (é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 and Frida mainly). Par conséquent, un appareil rooté (émulé ou non) est fortement recommandé. ### Analyse dynamique en ligne -Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme vous permet de **télécharger** et **d'exécuter** des APK, ce qui est 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 le comportement d'un apk. -Vous pouvez même **voir les journaux de votre application** sur le web et vous connecter via **adb**. +Vous pouvez même **voir les logs de votre application** sur le web et vous connecter via **adb**. ![](<../../images/image (831).png>) -Grâce à la connexion ADB, vous pouvez utiliser **Drozer** et **Frida** à l'intérieur des émulateurs. +Grâce à la connexion ADB vous pouvez utiliser **Drozer** et **Frida** à l'intérieur des émulateurs. ### Analyse dynamique locale -#### Utilisation d'un émulateur +#### Utiliser un émulateur -- [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des appareils **x86** et **arm**, et selon [**ceci**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html), les **dernières versions x86** prennent en charge les bibliothèques ARM sans avoir besoin d'un émulateur ARM lent). +- [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des devices **x86** et **arm**, et d'après [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). - Apprenez à le configurer sur cette page : + {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _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 prend pas en charge Frida ou Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._) +- [**Nox**](https://es.bignox.com) (Gratuit, mais il ne supporte pas Frida ou Drozer). > [!TIP] -> Lorsque vous créez un nouvel émulateur sur n'importe quelle plateforme, rappelez-vous que plus l'écran est grand, plus l'émulateur fonctionnera lentement. Donc, sélectionnez de petits écrans si possible. +> Lors de la création d'un nouvel émulateur sur n'importe quelle plateforme, souvenez-vous que plus l'écran est grand, plus l'émulateur sera lent. Donc, sélectionnez des écrans petits si possible. -Pour **installer les services Google** (comme l'AppStore) dans Genymotion, vous devez cliquer sur le bouton marqué en rouge de l'image suivante : +Pour **installer google services** (comme AppStore) dans Genymotion, vous devez cliquer sur le bouton marqué en rouge de l'image suivante : ![](<../../images/image (277).png>) -De plus, notez que dans la **configuration de la VM Android dans Genymotion**, vous pouvez sélectionner le **mode réseau Bridge** (ce qui sera utile si vous vous connectez à la VM Android depuis une autre VM avec les outils). +De plus, notez que dans la **configuration de la VM Android dans Genymotion** vous pouvez sélectionner le **Bridge Network mode** (cela sera utile si vous vous connectez à la VM Android depuis une VM différente avec les outils). #### Utiliser un appareil physique -Vous devez activer les **options de débogage** et il serait bien si vous pouviez le **rooter** : +Vous devez activer les options de **debugging** et il est préférable de pouvoir le **rooter** : -1. **Paramètres**. -2. (À partir d'Android 8.0) Sélectionnez **Système**. -3. Sélectionnez **À propos du téléphone**. -4. Appuyez sur **Numéro de build** 7 fois. -5. Revenez en arrière et vous trouverez les **options de développeur**. +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**. -> Une fois que vous avez installé l'application, la première chose que vous devriez faire est de l'essayer et d'enquêter sur ce qu'elle fait, comment elle fonctionne et vous y habituer.\ -> Je vous suggérerai de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard. +> Une fois que vous avez installé l'application, la première chose à faire est de l'essayer, d'investiguer 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 consulter ultérieurement. ### Fuite de données non intentionnelle -**Journalisation** +**Logging** -Les développeurs doivent être prudents de ne pas exposer **des informations de débogage** publiquement, car cela peut entraîner des fuites de données sensibles. Les outils [**pidcat**](https://github.com/JakeWharton/pidcat) et `adb logcat` sont recommandés pour surveiller les journaux d'application afin d'identifier et de protéger les informations sensibles. **Pidcat** est privilégié pour sa facilité d'utilisation et sa lisibilité. +Les développeurs doivent être prudents quant à l'exposition d'informations de **debugging** publiquement, car cela peut entraîner des leaks de données sensibles. Les outils [**pidcat**](https://github.com/JakeWharton/pidcat) et `adb logcat` sont recommandés pour surveiller les logs des applications afin d'identifier et de protéger les informations sensibles. **Pidcat** est privilégié pour sa facilité d'utilisation et sa lisibilité. > [!WARNING] -> Notez qu'à partir de **versions plus récentes qu'Android 4.0**, **les applications ne peuvent accéder qu'à leurs propres journaux**. Donc, les applications ne peuvent pas accéder aux journaux d'autres applications.\ -> Quoi qu'il en soit, il est toujours recommandé de **ne pas enregistrer d'informations sensibles**. +> Notez que depuis **later newer than 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**. -**Mise en cache du tampon Copier/Coller** +**Mise en cache du presse-papiers (Copy/Paste Buffer Caching)** -Le cadre **basé sur le presse-papiers** d'Android permet la fonctionnalité de copier-coller dans les applications, mais pose un risque car **d'autres applications** peuvent **accéder** au presse-papiers, exposant potentiellement des données sensibles. Il est crucial de **désactiver les fonctions de copier/coller** pour les sections sensibles d'une application, comme les détails de carte de crédit, afin de prévenir les fuites de données. +Le framework **clipboard-based** d'Android permet la fonctionnalité de copier-coller dans les apps, mais présente un risque car **d'autres applications** peuvent **accéder** au presse-papiers, 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 de crédit, afin de prévenir les leaks de données. -**Journaux de plantage** +**Crash Logs** -Si une application **plante** et **enregistre des journaux**, ces journaux peuvent aider les attaquants, en particulier lorsque l'application ne peut pas être inversée. Pour atténuer ce risque, évitez de journaliser lors des plantages, et si des journaux 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 attaquants, particulièrement lorsque l'application ne peut pas être reverse-engineered. Pour atténuer ce risque, évitez de logger lors des crashs, et si des 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 œil à ces journaux**. +En tant que pentester, **essayez de jeter un œil à ces logs**. -**Données analytiques envoyées à des tiers** +**Analytics Data Sent To 3rd Parties** -Les applications intègrent souvent des services comme Google Adsense, ce qui peut involontairement **fuir des données sensibles** en raison d'une mise en œuvre incorrecte par les développeurs. Pour identifier les fuites de données potentielles, il est conseillé de **intercepter le trafic de l'application** et de vérifier toute information sensible envoyée à des services tiers. +Les applications intègrent souvent des services comme Google Adsense, qui peuvent involontairement **leak sensitive data** à cause d'une mauvaise implémentation par les développeurs. Pour identifier de potentielles fuites de données, il est conseillé d'**intercepter le trafic de l'application** et de vérifier si des informations sensibles sont envoyées à des services tiers. -### Bases de données SQLite +### SQLite DBs -La plupart des applications utiliseront des **bases de données SQLite internes** pour enregistrer des informations. Pendant le pentest, jetez un **œil** aux **bases de données** créées, aux noms des **tables** et des **colonnes** et à toutes les **données** enregistrées car vous pourriez trouver des **informations sensibles** (ce qui constituerait une vulnérabilité).\ -Les bases de données devraient être situées dans `/data/data/the.package.name/databases` comme `/data/data/com.mwr.example.sieve/databases`. +La plupart des applications utilisent 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 constituerait 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 base de données enregistre des informations confidentielles et est **crypté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 enregistre des informations confidentielles et est **encrypted** mais que vous pouvez **trouver** le **password** à l'intérieur de l'application, c'est toujours une **vulnerability**. -Énumérez les tables en utilisant `.tables` et énumérez les colonnes des tables en faisant `.schema `. +Énumérez les tables avec `.tables` et énumérez les colonnes des tables avec `.schema ` -### Drozer (Exploitation des activités exportées, des fournisseurs de contenu et des services) +### Drozer (Exploit Activities, Content Providers and Services) -D'après [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf) : **Drozer** vous permet d'**assumer le rôle d'une application Android** et d'interagir avec d'autres applications. Il peut faire **tout ce qu'une application installée peut faire**, comme utiliser le mécanisme de communication inter-processus (IPC) d'Android et interagir avec le système d'exploitation sous-jacent.\ -Drozer est un outil utile pour **exploiter les activités exportées, les services exportés et les fournisseurs de contenu** 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** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ +Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections. -### Exploitation des activités exportées +### Exploiting exported Activities -[**Lisez ceci si vous voulez rafraîchir ce qu'est une activité Android.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Rappelez-vous également que le code d'une activité commence dans la méthode **`onCreate`**. +[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ +Also remember that the code of an activity starts in the **`onCreate`** method. -**Contournement de l'autorisation** +**Authorisation bypass** -Lorsqu'une activité est exportée, vous pouvez invoquer son écran depuis une application externe. Par conséquent, si une activité contenant des **informations sensibles** est **exportée**, vous pourriez **contourner** les mécanismes **d'authentification** **pour y accéder.** +When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.** -[**Apprenez comment exploiter les activités exportées avec Drozer.**](drozer-tutorial/index.html#activities) +[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -Vous pouvez également démarrer une activité exportée depuis adb : +You can also start an exported activity from adb: -- PackageName est com.example.demo -- Exported ActivityName est com.example.test.MainActivity +- PackageName is com.example.demo +- Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTE**: MobSF détectera comme malveillant l'utilisation de _**singleTask/singleInstance**_ comme `android:launchMode` dans une activité, mais en raison de [cela](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparemment cela n'est dangereux que sur les anciennes versions (versions API < 21). +**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] -> Notez qu'un contournement d'autorisation n'est pas toujours une vulnérabilité, cela dépend de la manière dont le contournement fonctionne et des informations qui sont exposées. +> Note that an authorisation bypass is not always a vulnerability, it would depend on how the bypass works and which information is exposed. **Fuite d'informations sensibles** -**Les activités peuvent également renvoyer des résultats**. Si vous parvenez à trouver une activité exportée et non protégée appelant la méthode **`setResult`** et **renvoyant des informations sensibles**, il y a une fuite d'informations sensibles. +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 **retournant des informations sensibles**, il y a une fuite d'informations sensibles. #### Tapjacking -Si le tapjacking n'est pas prévenu, vous pourriez abuser de l'activité exportée pour faire en sorte que **l'utilisateur effectue des actions inattendues**. Pour plus d'infos sur [**ce qu'est le Tapjacking, suivez le lien**](#tapjacking). +Si tapjacking n'est pas empêché, vous pourriez abuser de l'activity exportée pour faire **effectuer à l'utilisateur des actions inattendues**. For more info about [**what is Tapjacking follow the link**](#tapjacking). -### Exploitation des Content Providers - Accéder et manipuler des informations sensibles +### Exploiting Content Providers - Accessing and manipulating sensitive information -[**Lisez ceci si vous voulez rafraîchir ce qu'est un Content Provider.**](android-applications-basics.md#content-provider)\ -Les content providers sont essentiellement utilisés pour **partager des données**. Si une application a des content providers disponibles, vous pourriez être en mesure d'**extraire des données sensibles** à partir d'eux. Il est également intéressant de tester d'éventuelles **injections SQL** et **Path Traversals** car elles pourraient être vulnérables. +[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ +Content providers sont essentiellement utilisés pour **partager des données**. Si une application possède des content providers disponibles, vous pourriez être capable d'**extraire des données sensibles** depuis ceux-ci. Il est également intéressant de tester d'éventuelles **SQL injections** et **Path Traversals** car elles pourraient être vulnérables. -[**Apprenez à exploiter les Content Providers avec Drozer.**](drozer-tutorial/index.html#content-providers) +[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) -### **Exploitation des Services** +### **Exploiting Services** -[**Lisez ceci si vous voulez rafraîchir ce qu'est un Service.**](android-applications-basics.md#services)\ -Rappelez-vous que les actions d'un Service commencent dans la méthode `onStartCommand`. +[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ +Souvenez-vous que les actions d'un Service commencent dans la méthode `onStartCommand`. -Un service est essentiellement quelque chose qui **peut recevoir des données**, **les traiter** et **renvoyer** (ou non) une réponse. Donc, si une application exporte certains services, vous devriez **vérifier** le **code** pour comprendre ce qu'il fait et **le tester** **dynamiquement** pour extraire des informations confidentielles, contourner des mesures d'authentification...\ -[**Apprenez à exploiter les Services avec Drozer.**](drozer-tutorial/index.html#services) +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 devez **vérifier** le **code** pour comprendre ce qu'il fait et **tester** celui-ci **dynamiquement** pour extraire des infos confidentielles, bypass des mesures d'authentification...\ +[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) -### **Exploitation des Broadcast Receivers** +### **Exploiting Broadcast Receivers** -[**Lisez ceci si vous voulez rafraîchir ce qu'est un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Rappelez-vous que les actions d'un Broadcast Receiver commencent dans la méthode `onReceive`. +[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ +Souvenez-vous que les actions d'un Broadcast Receiver commencent dans la méthode `onReceive`. -Un broadcast receiver attendra un type de message. Selon la manière dont le récepteur gère le message, il pourrait être vulnérable.\ -[**Apprenez à exploiter les Broadcast Receivers avec Drozer.**](#exploiting-broadcast-receivers) +Un broadcast receiver attendra un type de message. Selon la façon dont le receiver traite le message, il pourrait être vulnérable.\ +[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) -### **Exploitation des Schémas / Liens profonds** +### **Exploiting Schemes / Deep links** -Vous pouvez rechercher des liens profonds manuellement, en utilisant des outils comme MobSF ou des scripts comme [celui-ci](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Vous pouvez **ouvrir** un **schéma** déclaré en utilisant **adb** ou un **navigateur** : +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] ``` -_Remarque que tu peux **omettre le nom du package** et le mobile appellera automatiquement l'application qui devrait ouvrir ce lien._ +_Notez que vous pouvez **omettre le nom du package** et le mobile ouvrira automatiquement l'application appropriée pour ce lien._ ```html Click me @@ -387,82 +393,133 @@ _Remarque que tu peux **omettre le nom du package** et le mobile appellera autom ``` **Code exécuté** -Pour trouver le **code qui sera exécuté dans l'App**, allez à 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 cherchez la fonction **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) -**Informations sensibles** +**Infos sensibles** -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 toute autre application pourrait **imiter 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 toute autre application pourrait **se faire passer pour le deep link et voler ces données !** **Paramètres dans le chemin** -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 parcours de chemin en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\ -Notez que si vous trouvez les bons points de terminaison à l'intérieur de l'application, vous pourriez être en mesure de provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), **prise de contrôle de compte** (si vous pouvez modifier les détails des utilisateurs sans jeton CSRF et que le point de terminaison vulnérable utilise la bonne méthode) et toute autre vulnérabilité. Plus [d'infos à ce sujet ici](http://dphoeniixx.com/2020/12/13-2/). +Vous **devez aussi 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 CSRF token et que l'endpoint vuln utilisait la méthode adéquate) et toute autre vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). **Plus d'exemples** -Un [rapport de bug bounty intéressant](https://hackerone.com/reports/855618) concernant des liens (_/.well-known/assetlinks.json_). +Un [interesting bug bounty report](https://hackerone.com/reports/855618) intéressant sur les liens (_/.well-known/assetlinks.json_). -### Échecs d'inspection et de vérification de la couche de transport +### Inspection de la couche transport et échecs de vérification -- **Les certificats ne sont pas toujours inspectés correctement** 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 à utiliser des connexions HTTP. -- **Les négociations lors de la poignée de main SSL/TLS sont parfois faibles**, utilisant des suites de chiffrement non sécurisées. Cette vulnérabilité rend la connexion susceptible aux attaques de type homme du milieu (MITM), permettant aux attaquants de déchiffrer les données. -- **La fuite d'informations privées** est un risque lorsque les applications s'authentifient via des canaux sécurisés mais communiquent ensuite par 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 détails des utilisateurs, contre l'interception par des entités malveillantes. +- **Certificates are not always inspected properly** par les applications Android. Il est courant que ces applications ignorent les avertissements et acceptent des certificats self-signed ou, dans certains cas, repassent à des connexions HTTP. +- **Negotiations during the SSL/TLS handshake are sometimes weak**, utilisant des suites de chiffrement non sécurisées. Cette vulnérabilité rend la connexion susceptible aux attaques man-in-the-middle (MITM), permettant aux attaquants de décrypter les données. +- **Leakage of private information** est un risque lorsque les applications s'authentifient via des canaux sécurisés mais communiquent ensuite sur des canaux non sécurisés pour d'autres transactions. Cette approche ne protège pas les données sensibles, telles que les session cookies ou les détails utilisateur, contre l'interception par des entités malveillantes. #### Vérification des certificats -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é. Cela est crucial car des configurations TLS non sécurisées et la transmission de données sensibles par des canaux non chiffrés peuvent poser des risques significatifs. Pour des étapes détaillées sur la vérification des certificats de serveur et le traitement des vulnérabilités, [**cette ressource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des conseils complets. +Nous allons nous concentrer sur la **certificate verification**. L'intégrité du certificat du serveur doit être vérifiée pour renforcer la sécurité. Ceci est crucial car des configurations TLS insecure et la transmission de données sensibles sur des canaux non chiffrés peuvent poser des risques importants. Pour des étapes détaillées sur la vérification des certificats serveur et la remédiation des vulnérabilités, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des conseils complets. #### SSL Pinning -Le 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. Il est fortement recommandé de mettre en œuvre le SSL Pinning pour les applications traitant des informations sensibles. +SSL Pinning est une mesure de sécurité où l'application vérifie le certificat du serveur contre une copie connue stockée dans l'application elle-même. Cette méthode est essentielle pour prévenir les attaques MITM. La mise en œuvre de SSL Pinning est fortement recommandée pour les applications traitant des informations sensibles. #### Inspection du trafic -Pour inspecter le trafic HTTP, il est nécessaire d'**installer le certificat de l'outil proxy** (par exemple, 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é, [**cliquez ici**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +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 et supérieur** nécessitent des modifications de la configuration de sécurité réseau pour accepter le certificat CA du proxy. Cette étape est cruciale pour inspecter le trafic chiffré. Pour des instructions sur la modification de la configuration de sécurité réseau, [**reportez-vous à ce tutoriel**](make-apk-accept-ca-certificate.md). +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 cruciale 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 [**cette page**](flutter.md). Cela est dû au fait que, simplement ajouter le certificat dans le magasin ne fonctionnera pas car Flutter a sa propre liste de CAs valides. +Si **Flutter** est utilisé, vous devez suivre les instructions sur [**this page**](flutter.md). En effet, ajouter simplement le certificat dans le store ne fonctionnera pas, car Flutter utilise sa propre liste de CAs valides. -#### Contournement du SSL Pinning +#### Détection statique du SSL/TLS pinning -Lorsque le SSL Pinning est mis en œuvre, le contournement devient nécessaire pour inspecter le trafic HTTPS. Diverses méthodes sont disponibles à cet effet : +Avant d’essayer des contournements runtime, cartographiez rapidement où le pinning est appliqué dans l'APK. La découverte statique vous aide à planifier des hooks/patches et à vous concentrer sur les bons chemins de code. -- Modifiez automatiquement l'**apk** pour **contourner** le SSL Pinning avec [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Le meilleur avantage de cette option est que vous n'aurez pas besoin de root pour contourner le SSL Pinning, mais vous devrez supprimer l'application et réinstaller la nouvelle, et cela ne fonctionnera pas toujours. -- Vous pourriez utiliser **Frida** (discuté ci-dessous) pour contourner cette protection. Voici un guide pour utiliser Burp+Frida+Genymotion : [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) -- Vous pouvez également essayer de **contourner automatiquement le SSL Pinning** en utilisant [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- Vous pouvez également essayer de **contourner automatiquement le SSL Pinning** en utilisant **l'analyse dynamique MobSF** (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) +Outil : SSLPinDetect +- Outil 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. +- Signale le chemin de fichier exact, le numéro de ligne et un extrait de code pour chaque correspondance. +- Couvre les frameworks courants et les chemins de code personnalisés : OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. -#### Recherche de vulnérabilités web courantes +Installation +- Pré-requis : Python >= 3.8, Java on PATH, apktool +```bash +git clone https://github.com/aancw/SSLPinDetect +cd SSLPinDetect +pip install -r requirements.txt +``` +Utilisation +```bash +# Basic +python sslpindetect.py -f app.apk -a apktool.jar -Il est également important de rechercher des vulnérabilités web courantes au sein de l'application. Des 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. +# Verbose (timings + per-match path:line + snippet) +python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v +``` +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 analyser à grande échelle. +```json +{ +"OkHttp Certificate Pinning": [ +"Lcom/squareup/okhttp/CertificatePinner;", +"Lokhttp3/CertificatePinner;", +"setCertificatePinner" +], +"TrustManager Override": [ +"Ljavax/net/ssl/X509TrustManager;", +"checkServerTrusted" +] +} +``` +Notes et conseils +- Scan rapide des grandes apps via multi-threading et I/O mappée en mémoire ; les regex précompilées réduisent l'overhead / les faux positifs. +- Pattern collection: https://github.com/aancw/smali-sslpin-patterns +- Cibles typiques à trier ensuite : +- OkHttp: usage de CertificatePinner, setCertificatePinner, références de package okhttp3/okhttp +- TrustManagers personnalisés: javax.net.ssl.X509TrustManager, overrides de checkServerTrusted +- Contexts SSL personnalisés: SSLContext.getInstance + SSLContext.init avec des managers personnalisés +- Pins déclaratifs dans res/xml network security config et références dans le manifest +- Utilisez les emplacements trouvés pour planifier des hooks Frida, des patchs statiques ou des revues de config avant les tests dynamiques. + + + +#### Contournement de SSL Pinning + +Quand SSL Pinning est implémenté, le contourner devient nécessaire pour inspecter le trafic HTTPS. Plusieurs méthodes existent pour cela : + +- Modifier automatiquement l'**apk** pour **bypasser** 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 bypasser le SSL Pinning, mais vous devrez supprimer l'application et réinstaller la nouvelle, et ça ne marche pas toujours. +- Vous pouvez utiliser **Frida** (discuté ci‑dessous) pour bypasser 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 **bypasser 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 **bypasser 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**. Lire ce 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 + +Il est important de rechercher aussi les vulnérabilités web courantes dans l'application. Les informations détaillées pour les identifier et les atténuer dépassent le cadre de ce résumé mais sont largement traitées ailleurs. ### Frida -[Frida](https://www.frida.re) est un outil d'instrumentation dynamique pour les développeurs, les ingénieurs en rétro-ingénierie et les chercheurs en sécurité.\ -**Vous pouvez accéder à l'application en cours d'exécution et accrocher des méthodes en temps réel pour changer le comportement, changer des valeurs, extraire des valeurs, exécuter différents codes...**\ -Si vous souhaitez effectuer un pentesting sur des applications Android, vous devez savoir comment utiliser 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 à l'exécution pour changer le comportement, modifier des valeurs, extraire des valeurs, exécuter du code différent...**\ +Si vous voulez pentest des applications Android vous devez savoir utiliser Frida. -- Apprenez à utiliser Frida : [**Tutoriel Frida**](frida-tutorial/index.html) -- Une sorte de "GUI" pour les actions avec Frida : [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection est excellent pour automatiser l'utilisation de Frida : [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- Apprenez à utiliser Frida : [**Frida tutorial**](frida-tutorial/index.html) +- Quelques "GUI" pour actions avec Frida : [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Objection est excellent pour automatiser l'utilisation de Frida : [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) - Vous pouvez trouver des scripts Frida intéressants ici : [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Essayez de contourner les mécanismes anti-debugging / anti-frida en chargeant Frida comme indiqué dans [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (outil [linjector](https://github.com/erfur/linjector-rs)) +- Essayez de bypasser les mécanismes anti-debugging / anti-frida en chargeant Frida comme indiqué dans [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (outil [linjector](https://github.com/erfur/linjector-rs)) -#### Flux de travail de contournement de l'anti-instrumentation & SSL pinning +#### Anti-instrumentation & workflow de contournement SSL pinning {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Dump de mémoire - Fridump** +### **Dump mémoire - Fridump** -Vérifiez si l'application stocke des informations sensibles dans la mémoire qu'elle ne devrait pas stocker, comme des mots de passe ou des mnémotechniques. +Vérifiez si l'application stocke des informations sensibles en mémoire qu'elle ne devrait pas, comme des mots de passe ou des mnemonics. -En utilisant [**Fridump3**](https://github.com/rootbsd/fridump3), vous pouvez dumper la mémoire de l'application avec : +Avec [**Fridump3**](https://github.com/rootbsd/fridump3) vous pouvez dumper la mémoire de l'app avec: ```bash # With PID python3 fridump3.py -u @@ -471,120 +528,120 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Cela va vider la mémoire dans le dossier ./dump, et là-dedans, vous pourriez grep avec quelque chose comme : +Cela va dump la mémoire dans le dossier ./dump, et là vous pouvez 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** -Dans Android, le Keystore est le meilleur endroit pour stocker des données sensibles, cependant, avec suffisamment de privilèges, il est toujours **possible d'y accéder**. Comme les applications ont tendance à y stocker **des données sensibles en texte clair**, les pentests devraient vérifier cela en tant qu'utilisateur root ou quelqu'un ayant un accès physique à l'appareil pourrait être en mesure de voler ces données. +Sur Android, le Keystore est le meilleur endroit pour stocker des données sensibles, cependant, avec des privilèges suffisants il est encore **possible d'y accéder**. Comme les applications ont tendance à stocker ici **des données sensibles en clair**, les pentests devraient le vérifier en tant que root user, car quelqu'un ayant un accès physique à l'appareil pourrait voler ces données. -Même si une application stocke des données dans le keystore, les données devraient être chiffrées. +Même si une app stocke des données dans le keystore, les données doivent être chiffrées. -Pour accéder aux données à l'intérieur du keystore, vous pouvez utiliser ce script Frida : [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Pour accéder aux données à l'intérieur du keystore vous pourriez utiliser ce Frida script: [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 ``` -### **Contour/Biométrie Bypass** +### **Fingerprint/Biometrics Bypass** -En utilisant le script Frida suivant, il pourrait être possible de **contourner l'authentification par empreinte digitale** que les applications Android pourraient effectuer afin de **protéger certaines zones sensibles :** +En utilisant le script Frida suivant, il pourrait être possible de **bypass fingerprint authentication** que certaines applications Android mettent en œuvre pour **protect certain sensitive areas:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` -### **Images de Fond** +### **Images d'arrière-plan** -Lorsque vous mettez une application en arrière-plan, Android stocke un **instantané de l'application** afin que, lorsqu'elle est récupérée au premier plan, elle commence à charger l'image avant l'application, ce qui donne l'impression que l'application a été chargée plus rapidement. +Lorsque vous mettez une application en arrière-plan, Android stocke un **instantané de l'application**, de sorte que lorsqu'elle est rétablie au premier plan, Android commence à charger l'image avant l'application, donnant l'impression que l'application s'est chargée plus rapidement. -Cependant, si cet instantané contient des **informations sensibles**, quelqu'un ayant accès à l'instantané pourrait **voler ces informations** (notez que vous avez besoin de root pour y accéder). +Cependant, si cet instantané contient des **informations sensibles**, quelqu'un ayant accès à l'instantané pourrait **voler ces infos** (notez que vous avez besoin de root pour y accéder). -Les instantanés sont généralement stockés autour de : **`/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 de mise en page FLAG_SECURE**. En utilisant ce drapeau, le contenu de la fenêtre est traité comme sécurisé, empêchant son apparition dans les captures d'écran ou d'être visualisé sur des affichages 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 les captures d'écran ou d'être affiché sur des écrans non sécurisés. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` -### **Analyseur d'Application Android** +### **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) +Cet outil peut vous aider à gérer différents outils pendant l'analyse dynamique : [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) -### Injection d'Intent +### Intent Injection -Les développeurs créent souvent des composants proxy comme des activités, des services et des récepteurs de diffusion qui gèrent 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 proxies comme des 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é. -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 fournisseurs de contenu sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` qui convertit les URL en objets `Intent` via `Intent.parseUri(...)` et les exécute ensuite, ce qui peut conduire à des injections d'Intent malveillantes. +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` qui convertit des URLs en objets `Intent` via `Intent.parseUri(...)` puis les exécute, ce qui peut conduire à des injections d'Intent malveillantes. -### Points Essentiels +### Essential Takeaways -- **Injection d'Intent** est similaire au problème de Redirection Ouverte sur le web. +- **Intent Injection** est similaire au problème Open Redirect du web. - Les exploits impliquent de passer des objets `Intent` en tant qu'extras, qui peuvent être redirigés pour exécuter des opérations non sécurisées. -- Cela peut exposer des composants non exportés et des fournisseurs de contenu aux attaquants. -- La conversion d'URL en `Intent` de `WebView` peut faciliter des actions non intentionnelles. +- Cela peut exposer des composants non exportés et des content providers aux attaquants. +- La conversion d'URL en `Intent` par `WebView` peut faciliter des actions non désirées. -### Injections Côté Client Android et autres +### Android Client Side Injections and others -Vous connaissez probablement ce type de vulnérabilités sur le Web. Vous devez être particulièrement prudent avec ces vulnérabilités dans une application Android : +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 : -- **Injection SQL :** Lors de la gestion de requêtes dynamiques ou de Content-Providers, assurez-vous d'utiliser des requêtes paramétrées. -- **Injection JavaScript (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). -- **Inclusion de Fichiers Locaux :** Les WebViews ne devraient pas avoir accès au système de fichiers (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'infos ici](webview-attacks.md#javascript-enabled). -- **Cookies éternels :** Dans plusieurs cas, lorsque l'application Android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque. -- [**Drapeau Sécurisé** dans les cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) +- **SQL Injection:** Lors du traitement de requêtes dynamiques ou de 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). [More info here](webview-attacks.md#javascript-enabled). +- **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);)`. [More info here](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** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Analyse Automatique +## Automatic Analysis ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) -**Analyse statique** +**Static analysis** ![](<../../images/image (866).png>) -**Évaluation de la vulnérabilité de l'application** utilisant une belle interface web. Vous pouvez également effectuer une analyse dynamique (mais vous devez préparer l'environnement). +**Évaluation des vulnérabilités de l'application** via une belle interface web. 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 ``` -Remarque que MobSF peut analyser des applications **Android**(apk)**, IOS**(ipa) **et Windows**(apx) (_Les applications Windows doivent être analysées depuis un MobSF installé sur un hôte Windows_).\ -De plus, si vous créez un fichier **ZIP** avec le code source d'une application **Android** ou **IOS** (allez dans le dossier racine de l'application, sélectionnez tout et créez un fichier ZIP), il pourra également l'analyser. +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** avec le code source d'une application **Android** ou **IOS** (allez au dossier racine de l'application, sélectionnez tout et créez un ZIPfile), il pourra également l'analyser. -MobSF permet également de faire une analyse **diff/Compare** et d'intégrer **VirusTotal** (vous devrez définir votre clé API dans _MobSF/settings.py_ et l'activer : `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Vous pouvez également définir `VT_UPLOAD` sur `False`, alors le **hash** sera **téléchargé** au lieu du fichier. +MobSF vous permet aussi 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 régler `VT_UPLOAD` sur `False`, dans ce cas le **hash** sera **upload** au lieu du fichier. -### Analyse dynamique assistée avec MobSF +### Assisted Dynamic analysis with MobSF -**MobSF** peut également être très utile pour l'**analyse dynamique** sur **Android**, mais dans ce cas, vous devrez installer MobSF et **genymotion** sur votre hôte (une VM ou Docker ne fonctionnera pas). _Remarque : Vous devez **d'abord démarrer une VM dans genymotion** et **ensuite MobSF.**_\ -L'**analyseur dynamique MobSF** peut : +**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: You need to **start first a VM in genymotion** and **then MobSF.**_\ +L'**analyseur dynamique** de MobSF peut : -- **Extraire les données de l'application** (URLs, journaux, presse-papiers, captures d'écran faites par vous, captures d'écran faites par "**Exported Activity Tester**", e-mails, bases de données SQLite, fichiers XML et autres fichiers créés). Tout cela se fait automatiquement sauf pour les captures d'écran, vous devez appuyer lorsque vous voulez une capture d'écran ou vous devez appuyer sur "**Exported Activity Tester**" pour obtenir des captures d'écran de toutes les activités exportées. -- Capturer le **trafic HTTPS** -- Utiliser **Frida** pour obtenir des **informations d'exécution** +- **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 des captures de toutes les activités exportées. +- Capture **HTTPS traffic** +- Use **Frida** to obtain **runtime** **information** -À partir des versions Android **> 5**, il **démarrera automatiquement Frida** et définira les paramètres de **proxy** globaux pour **capturer** le trafic. Il ne capturera que le trafic de l'application testée. +À partir des versions **Android > 5**, il démarrera **automatiquement Frida** et définira les paramètres globaux de **proxy** pour **capture** le trafic. Il ne capturera que le trafic de l'application testée. **Frida** -Par défaut, il utilisera également certains scripts Frida pour **contourner le SSL pinning**, **la détection de root** et **la détection de débogueur** et pour **surveiller des API intéressantes**.\ -MobSF peut également **invoquer des activités exportées**, prendre des **captures d'écran** de celles-ci et **les enregistrer** pour le rapport. +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. -Pour **démarrer** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les journaux générés par les scripts Frida et "**Live API Monitor**" pour voir toutes les invocations aux méthodes accrochées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\ -MobSF vous permet également de charger vos propres **scripts Frida** (pour envoyer les résultats de vos scripts Frida à MobSF, utilisez la fonction `send()`). Il dispose également de **plusieurs scripts pré-écrits** que vous pouvez charger (vous pouvez en ajouter d'autres dans `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), il suffit de **les sélectionner**, d'appuyer sur "**Load**" et d'appuyer sur "**Start Instrumentation**" (vous pourrez voir les journaux de ces scripts dans "**Frida Live Logs**"). +Pour **start** les tests dynamiques, 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 sur "**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 Frida scripts à MobSF utilisez la fonction `send()`). Il contient également **several pre-written scripts** que vous pouvez charger (vous pouvez en ajouter d'autres dans `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), il suffit de **les sélectionner**, appuyer sur "**Load**" et appuyer sur "**Start Instrumentation**" (vous pourrez voir les logs de ces scripts dans "**Frida Live Logs**"). ![](<../../images/image (419).png>) -De plus, vous avez quelques fonctionnalités auxiliaires de Frida : +De plus, vous disposez de quelques fonctionnalités auxiliaires Frida : -- **Énumérer les classes chargées** : Il imprimera toutes les classes chargées -- **Capturer des chaînes** : Il imprimera toutes les chaînes capturées lors de l'utilisation de l'application (très bruyant) -- **Capturer les comparaisons de chaînes** : Pourrait être très utile. Il **affichera les 2 chaînes comparées** et si le résultat était vrai ou faux. -- **Énumérer les méthodes de classe** : Mettez le nom de la classe (comme "java.io.File") et il imprimera toutes les méthodes de la classe. -- **Rechercher un motif de classe** : Rechercher des classes par motif -- **Tracer les méthodes de classe** : **Tracer** une **classe entière** (voir les entrées et sorties de toutes les méthodes de la classe). N'oubliez pas qu'en mode par défaut, MobSF trace plusieurs méthodes d'API Android intéressantes. +- **Enumerate Loaded Classes**: Il affichera toutes les classes chargées +- **Capture Strings**: Il affichera toutes les chaînes capturées pendant l'utilisation de l'application (très bruyant) +- **Capture String Comparisons**: Peut être très utile. Il **montrera les 2 chaînes being compared** et si le résultat était True or False. +- **Enumerate Class Methods**: Indiquez le nom de la classe (comme "java.io.File") et il imprimera 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 qu'au départ MobSF trace plusieurs méthodes Android Api intéressantes. -Une fois que vous avez sélectionné le module auxiliaire que vous souhaitez utiliser, vous devez appuyer sur "**Start Instrumentation**" et vous verrez toutes les sorties dans "**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 vous propose également un shell avec quelques commandes **adb**, des **commandes MobSF**, et des **commandes shell** courantes en bas de la page d'analyse dynamique. Quelques commandes intéressantes : +MobSF fournit également un shell avec quelques commandes **adb**, **MobSF commands**, et des **shell** **commands** courantes en bas de la page d'analyse dynamique. Quelques commandes intéressantes : ```bash help shell ls @@ -593,34 +650,34 @@ exported_activities services receivers ``` -**Outils HTTP** +**HTTP tools** -Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur le bouton "**HTTP(S) Traffic**" en bas ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\ -Pour ce faire, _allumez Burp -->_ _désactivez Intercept --> dans MobSB HTTPTools, sélectionnez la requête_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bottom or a nicer view in "**Start HTTPTools**" green bottom. From the second option, you can **send** the **captured requests** to **proxies** like Burp or 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)). -Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer sur "**Start Web API Fuzzer**" pour **fuzz les requêtes http** et rechercher des vulnérabilités. +Une fois l'analyse dynamique terminée avec MobSF, vous pouvez cliquer sur "**Start Web API Fuzzer**" pour **fuzz http requests** et rechercher des vulnérabilités. > [!TIP] -> Après avoir effectué une analyse dynamique avec MobSF, les paramètres du proxy peuvent être mal configurés et vous ne pourrez pas les corriger depuis l'interface graphique. Vous pouvez corriger les paramètres du proxy en faisant : +> Après avoir effectué une analyse dynamique avec MobSF, les paramètres proxy peuvent être mal configurés et vous ne pourrez pas les corriger depuis la GUI. Vous pouvez réparer les paramètres proxy en exécutant : > > ``` > adb shell settings put global http_proxy :0 > ``` -### Analyse Dynamique Assistée avec Inspeckage +### Assisted Dynamic Analysis with Inspeckage -Vous pouvez obtenir l'outil depuis [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Cet outil utilisera des **Hooks** pour vous informer **de ce qui se passe dans l'application** pendant que vous effectuez une **analyse dynamique**. +You can get the tool from [**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/) -C'est un **excellent outil pour effectuer une analyse statique avec une interface graphique** +C'est un **excellent outil pour effectuer une analyse statique avec une GUI** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Cet outil est conçu pour rechercher plusieurs **vulnérabilités liées à la sécurité des applications Android**, que ce soit dans le **code source** ou les **APKs empaquetés**. L'outil est également **capable de créer un APK déployable "Proof-of-Concept"** et des **commandes ADB**, pour exploiter certaines des vulnérabilités trouvées (activités exposées, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test. +Cet outil est conçu pour rechercher plusieurs **security related Android application vulnerabilities**, soit dans le **source code** soit dans des **packaged APKs**. L'outil est aussi **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 @@ -629,22 +686,22 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Affiche tous les fichiers extraits pour une référence facile -- Décompile automatiquement les fichiers APK en format Java et Smali -- Analyse AndroidManifest.xml pour des vulnérabilités et comportements courants -- Analyse statique du code source pour des vulnérabilités et comportements courants +- Affiche tous les fichiers extraits pour une consultation facile +- Décompile automatiquement les APK en Java et Smali +- Analyse AndroidManifest.xml pour les vulnérabilités et comportements courants +- Analyse statique du code source pour les vulnérabilités et comportements courants - Informations sur l'appareil -- et plus +- et plus encore ```bash reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER est une application en ligne de commande qui peut être utilisée sur Windows, MacOS X et Linux, 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 qui peut être utilisée sous Windows, MacOS X et Linux, et qui analyse des _.apk_ files à la recherche de vulnérabilités. Il le fait en décompressant les APKs et en appliquant une série de règles pour détecter ces vulnérabilités. -Toutes les règles sont centrées dans un fichier `rules.json`, et chaque entreprise ou testeur peut créer ses propres règles pour analyser ce dont ils ont 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 selon ses besoins. -Téléchargez les derniers binaires sur la [page de téléchargement](https://superanalyzer.rocks/download.html) +Téléchargez les derniers binaires depuis la [download page](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -652,17 +709,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn est un outil **multiplateforme** qui aide les développeurs, les chasseurs de bugs et les hackers éthiques à effectuer une [analyse de code statique](https://en.wikipedia.org/wiki/Static_program_analysis) sur des applications mobiles. +StaCoAn est un outil **crossplatform** 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 concept est que vous faites glisser et déposer votre fichier d'application mobile (un fichier .apk ou .ipa) sur l'application StaCoAn et elle générera un rapport visuel et portable pour vous. Vous pouvez ajuster les paramètres et les listes de mots pour obtenir une expérience personnalisée. +Le concept est que vous glissiez-déposiez votre fichier d'application mobile (un fichier .apk ou .ipa) sur l'application StaCoAn et elle générera pour vous un rapport visuel et portable. Vous pouvez ajuster les paramètres et les wordlists pour obtenir une expérience personnalisée. -Télécharger[ dernière version](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) -Le framework AndroBugs est un système d'analyse de vulnérabilités Android qui aide les développeurs ou les hackers à trouver des vulnérabilités de sécurité potentielles dans les applications Android.\ +AndroBugs Framework est un système d'analyse de vulnérabilités Android qui aide les développeurs ou les hackers à trouver des vulnérabilités potentielles dans les applications Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -670,11 +727,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** est un outil dont le principal objectif est de détecter et d'avertir l'utilisateur des comportements malveillants potentiels développés par une application Android. +**Androwarn** est un outil dont le but principal est de détecter et d'avertir l'utilisateur au sujet de comportements potentiellement malveillants développés par une application Android. -La détection est effectuée par l'**analyse statique** du bytecode Dalvik de l'application, représenté sous forme de **Smali**, avec la bibliothèque [`androguard`](https://github.com/androguard/androguard). +La détection est effectuée par l'**analyse statique** du Dalvik bytecode de l'application, représenté en **Smali**, à l'aide de la bibliothèque [`androguard`](https://github.com/androguard/androguard). -Cet outil recherche des **comportements courants des applications "malveillantes"** tels que : exfiltration d'identifiants de téléphonie, interception de flux audio/vidéo, modification de données PIM, exécution de code arbitraire... +Cet outil recherche les **comportements courants des applications 'malveillantes'** comme : Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -682,81 +739,84 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** est un **M**obile **A**pplication **R**everse engineering et **A**nalysis Framework. C'est un outil qui regroupe des outils d'ingénierie inverse et d'analyse d'applications mobiles couramment utilisés, pour aider à tester les applications mobiles contre les menaces de sécurité mobile OWASP. Son objectif est de rendre cette tâche plus facile et plus conviviale pour les développeurs d'applications mobiles et les professionnels de la sécurité. +**MARA** est un 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'assister les tests des applications mobiles contre les menaces de sécurité mobile OWASP. Son objectif est de rendre cette tâche plus simple et plus accessible aux développeurs d'applications mobiles et aux professionnels de la sécurité. -Il est capable de : +It is able to: -- Extraire du code Java et Smali en utilisant différents outils -- Analyser des APK en utilisant : [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- Extraire des informations privées de l'APK en utilisant des 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) +- Extract Java and Smali code using different tools +- Analyze APKs using: [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) +- Extract private information from the APK using regexps. +- Analyze the Manifest. +- Analyze found domains using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Utile pour détecter les malwares : [https://koodous.com/](https://koodous.com) +Utile pour détecter les malware: [https://koodous.com/](https://koodous.com/) ## Obfuscating/Deobfuscating code -Notez qu'en fonction du service et de la configuration que vous utilisez pour obfusquer le code, les secrets peuvent ou non être obfusqués. +Notez que, selon le service et la configuration que vous utilisez pour obfuscate le code, les secrets peuvent ou non rester obfuscated. ### [ProGuard]() -D'après [Wikipedia](): **ProGuard** est un outil en ligne de commande open source qui réduit, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et de supprimer les instructions inutilisées. ProGuard est un logiciel libre et est distribué sous la licence publique générale GNU, version 2. +From [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. Il est capable d'optimiser le bytecode ainsi que de détecter et supprimer les instructions non utilisées. ProGuard est un logiciel libre distribué sous la GNU General Public License, version 2. -ProGuard est distribué dans le cadre du SDK Android et s'exécute lors de la construction de l'application en mode release. +ProGuard is distributed as part of the Android SDK and runs when building the application in release mode. ### [DexGuard](https://www.guardsquare.com/dexguard) -Trouvez un guide étape par étape pour déobfusquer l'apk dans [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Find a step-by-step guide to deobfuscate the apk in [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) Last time we checked, the Dexguard mode of operation was: -- charger une ressource en tant qu'InputStream ; -- alimenter le résultat à une classe héritant de FilterInputStream pour le déchiffrer ; -- faire une obfuscation inutile pour faire perdre quelques minutes à un reverseur ; -- alimenter le résultat déchiffré à un ZipInputStream pour obtenir un fichier DEX ; -- enfin, charger le DEX résultant en tant que ressource en utilisant la méthode `loadDex`. +- load a resource as an InputStream; +- feed the result to a class inheriting from FilterInputStream to decrypt it; +- do some useless obfuscation to waste a few minutes of time from a reverser; +- feed the decrypted result to a ZipInputStream to get a DEX file; +- finally load the resulting DEX as a Resource using the `loadDex` method. ### [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é, y compris l'inspection du code et la prédiction des bibliothèques.** +**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.** -Vous pouvez télécharger un APK obfusqué sur leur plateforme. +Vous pouvez uploader un APK obfuscated sur leur plateforme. -### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app) +### [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 les applications android et déobfusquer le code des 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 application** pour comprendre son comportement et ensuite **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é. +It is a **generic android deobfuscator.** Simplify **virtually executes an app** to understand its behavior and then **tries to optimize the code** so it behaves identically but is easier for a human to understand. Each optimization type is simple and generic, so it doesn't matter what the specific type of obfuscation is used. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD vous donne des informations sur **comment un APK a été créé**. Il identifie de nombreux **compilateurs**, **packers**, **obfuscateurs**, et d'autres choses étranges. C'est [_PEiD_](https://www.aldeid.com/wiki/PEiD) pour Android. +APKiD gives you information about **how an APK was made**. It identifies many **compilers**, **packers**, **obfuscators**, and other weird stuff. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android. ### Manual -[Lire ce tutoriel pour apprendre quelques astuces sur **comment inverser une obfuscation personnalisée**](manual-deobfuscation.md) +[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md) -## Labs +## Laboratoires ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut la collection des derniers frameworks, tutoriels et laboratoires de différents geeks et chercheurs en sécurité pour l'ingénierie inverse et l'analyse de malware. +AndroL4b est une virtual machine de sécurité Android basée sur ubuntu-mate qui inclut une collection des derniers frameworks, tutoriels et labs provenant de différents experts en sécurité et chercheurs pour le reverse engineering et l'analyse de malware. -## References +## Références - [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 sur 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) -## Yet to try +## À essayer - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)