Translated ['src/mobile-pentesting/android-app-pentesting/android-anti-i

2025-10-10 18:36:50 +00:00 · 2025-08-21 04:08:01 +00:00 · 2025-08-21 04:08:01 +00:00 · 7de6cf9887
commit 7de6cf9887
parent 7be520f22b
3 changed files with 231 additions and 21 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -326,6 +326,7 @@
 - [Android APK Checklist](mobile-pentesting/android-checklist.md)
 - [Android Applications Pentesting](mobile-pentesting/android-app-pentesting/README.md)
  - [Accessibility Services Abuse](mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md)
+  - [Android Anti Instrumentation And Ssl Pinning Bypass](mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md)
  - [Android Applications Basics](mobile-pentesting/android-app-pentesting/android-applications-basics.md)
  - [Android Task Hijacking](mobile-pentesting/android-app-pentesting/android-task-hijacking.md)
  - [ADB Commands](mobile-pentesting/android-app-pentesting/adb-commands.md)
--- a/src/mobile-pentesting/android-app-pentesting/README.md
+++ b/src/mobile-pentesting/android-app-pentesting/README.md
@ -12,7 +12,7 @@ android-applications-basics.md

 ## ADB (Android Debug Bridge)

-C'est l'outil principal dont vous avez besoin pour vous connecter à un appareil Android (émulé ou physique).\
+C'est l'outil principal dont vous avez besoin pour vous connecter à un appareil android (émulé ou physique).\
 **ADB** permet de contrôler les appareils soit via **USB** soit via **réseau** depuis un ordinateur. Cette utilité permet le **copie** de fichiers dans les deux sens, **installation** et **désinstallation** d'applications, **exécution** de commandes shell, **sauvegarde** de données, **lecture** de journaux, entre autres fonctions.

 Jetez un œil à la liste suivante de [**Commandes ADB**](adb-commands.md) pour apprendre à utiliser adb.
@ -24,7 +24,7 @@ Parfois, il est intéressant de **modifier le code de l'application** pour accé

 ## Autres astuces intéressantes

- [Usurpation de votre emplacement dans le Play Store](spoofing-your-location-in-play-store.md)
+- [Usurper votre emplacement dans le Play Store](spoofing-your-location-in-play-store.md)
 - [API privilégiée Shizuku (accès privilégié non-root basé sur ADB)](shizuku-privileged-api.md)
 - [Exploitation des Mécanismes de Mise à Jour In-App Insecure](insecure-in-app-update-rce.md)
 - [Abus des Services d'Accessibilité (Android RAT)](accessibility-services-abuse.md)
@ -65,11 +65,11 @@ Veuillez, [**lire ici pour trouver des informations sur les différents décompi

 ### Recherche d'informations intéressantes

-En regardant simplement les **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **bluetooth uuids**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application).
+En regardant simplement les **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **UUIDs bluetooth**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application).

 **Firebase**

-Faites particulièrement attention aux **URLs firebase** et vérifiez si elles sont mal configurées. [Plus d'informations sur ce qu'est Firebase et comment l'exploiter ici.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
+Faites particulièrement attention aux **URLs Firebase** et vérifiez si elles sont mal configurées. [Plus d'informations sur ce qu'est Firebase et comment l'exploiter ici.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)

 ### Compréhension de base de l'application - Manifest.xml, strings.xml

@ -194,7 +194,7 @@ Selon ce [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-

 ### Analyse statique automatisée du code

-L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), des **sinks** (qui indiquent à l'outil des **endroits dangereux** où une entrée malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-sinks** qui indique une vulnérabilité.
+L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), des **sinks** (qui indiquent à l'outil les **endroits dangereux** où une entrée malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-sinks** qui indique une vulnérabilité.

 Avec cette connaissance, **mariana-trench examinera le code et trouvera les vulnérabilités possibles.**

@ -270,10 +270,10 @@ Vous devez activer les options de **débogage** et il serait bien si vous pouvie
 2. (À partir d'Android 8.0) Sélectionnez **Système**.
 3. Sélectionnez **À propos du téléphone**.
 4. Appuyez sur **Numéro de build** 7 fois.
-5. Revenez en arrière et vous trouverez les **options de développeur**.
+5. Revenez en arrière et vous trouverez les **options de développement**.

 > Une fois que vous avez installé l'application, la première chose à faire est de l'essayer et d'enquêter sur ce qu'elle fait, comment elle fonctionne et de vous y habituer.\
-> Je vous suggérerai de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique de MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard.
+> Je vous suggérerai de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard.

 ### Fuite de données non intentionnelle

@ -374,7 +374,7 @@ Vous pouvez **ouvrir** un **schéma** déclaré en utilisant **adb** ou un **nav
 ```bash
 adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
 ```
-_Remarque que tu peux **omettre le nom du package** et le mobile appellera automatiquement l'application qui devrait ouvrir ce lien._
+_Remarque : vous pouvez **omettre le nom du package** et le mobile appellera automatiquement l'application qui devrait ouvrir ce lien._
 ```html
 <!-- Browser regular link -->
 <a href="scheme://hostname/path?param=value">Click me</a>
@ -394,11 +394,11 @@ Chaque fois que vous trouvez un deep link, vérifiez qu'il **ne reçoit pas de d
 **Paramètres dans le chemin**

 Vous **devez également vérifier si un deep link utilise un paramètre à l'intérieur du chemin** de l'URL comme : `https://api.example.com/v1/users/{username}`, dans ce cas, vous pouvez forcer un parcours de chemin en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
-Notez que si vous trouvez les bons points de terminaison à l'intérieur de l'application, vous pourriez être en mesure de provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), **prise de contrôle de compte** (si vous pouvez modifier les détails des utilisateurs sans jeton CSRF et que le point de terminaison vulnérable utilise la bonne méthode) et toute autre vulnérabilité. Plus [d'infos à ce sujet ici](http://dphoeniixx.com/2020/12/13-2/).
+Notez que si vous trouvez les bons points de terminaison à l'intérieur de l'application, vous pourriez être en mesure de provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), **prise de contrôle de compte** (si vous pouvez modifier les détails des utilisateurs sans token CSRF et que le point de terminaison vulnérable utilise la bonne méthode) et toute autre vulnérabilité. Plus [d'infos à ce sujet ici](http://dphoeniixx.com/2020/12/13-2/).

 **Plus d'exemples**

-Un [rapport de bug bounty intéressant](https://hackerone.com/reports/855618) concernant des liens (_/.well-known/assetlinks.json_).
+Un [rapport de bug bounty intéressant](https://hackerone.com/reports/855618) sur les liens (_/.well-known/assetlinks.json_).

 ### Échecs d'inspection et de vérification de la couche de transport

@ -448,9 +448,15 @@ Si vous souhaitez effectuer un pentesting sur des applications Android, vous dev
 - Vous pouvez trouver des scripts Frida intéressants ici : [**https://codeshare.frida.re/**](https://codeshare.frida.re)
 - Essayez de contourner les mécanismes anti-debugging / anti-frida en chargeant Frida comme indiqué dans [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (outil [linjector](https://github.com/erfur/linjector-rs))

+#### Flux de travail de contournement de l'anti-instrumentation & SSL pinning
+
+{{#ref}}
+android-anti-instrumentation-and-ssl-pinning-bypass.md
+{{#endref}}
+
 ### **Dump de mémoire - Fridump**

-Vérifiez si l'application stocke des informations sensibles dans la mémoire qu'elle ne devrait pas stocker, comme des mots de passe ou des mnémoniques.
+Vérifiez si l'application stocke des informations sensibles dans la mémoire qu'elle ne devrait pas stocker, comme des mots de passe ou des mnémotechniques.

 En utilisant [**Fridump3**](https://github.com/rootbsd/fridump3), vous pouvez dumper la mémoire de l'application avec :
 ```bash
@ -508,7 +514,7 @@ Le danger réside dans le fait de permettre aux attaquants de déclencher des co
 - **Injection d'Intent** est similaire au problème de Redirection Ouverte sur le web.
 - Les exploits impliquent de passer des objets `Intent` en tant qu'extras, qui peuvent être redirigés pour exécuter des opérations non sécurisées.
 - Cela peut exposer des composants non exportés et des fournisseurs de contenu aux attaquants.
- La conversion d'URL en `Intent` par `WebView` peut faciliter des actions non intentionnelles.
+- La conversion d'URL en `Intent` de `WebView` peut faciliter des actions non intentionnelles.

 ### Injections Côté Client Android et autres

@ -517,7 +523,7 @@ Vous connaissez probablement ce type de vulnérabilités sur le Web. Vous devez
 - **Injection SQL :** Lors de la gestion de requêtes dynamiques ou de Content-Providers, assurez-vous d'utiliser des requêtes paramétrées.
 - **Injection JavaScript (XSS) :** Vérifiez que le support JavaScript et Plugin est désactivé pour tous les WebViews (désactivé par défaut). [Plus d'infos ici](webview-attacks.md#javascript-enabled).
 - **Inclusion de Fichiers Locaux :** Les WebViews ne devraient pas avoir accès au système de fichiers (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'infos ici](webview-attacks.md#javascript-enabled).
- **Cookies éternels** : Dans plusieurs cas, lorsque l'application Android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque.
+- **Cookies éternels** : Dans plusieurs cas, lorsque l'application android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque.
 - [**Drapeau Sécurisé** dans les cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)

 ---
@ -542,7 +548,7 @@ MobSF permet également d'effectuer une analyse **diff/Compare** et d'intégrer

 ### Analyse dynamique assistée avec MobSF

-**MobSF** peut également être très utile pour l'**analyse dynamique** sur **Android**, mais dans ce cas, vous devrez installer MobSF et **genymotion** sur votre hôte (une VM ou Docker ne fonctionnera pas). _Remarque : Vous devez **d'abord démarrer une VM dans genymotion** et **ensuite MobSF.**_\
+**MobSF** peut également être très utile pour l'**analyse dynamique** sur **Android**, mais dans ce cas, vous devrez installer MobSF et **genymotion** sur votre hôte (une VM ou Docker ne fonctionnera pas). _Remarque : Vous devez **d'abord démarrer une VM dans genymotion** puis **MobSF.**_\
 L'**analyseur dynamique MobSF** peut :

 - **Extraire les données de l'application** (URLs, journaux, presse-papiers, captures d'écran réalisées par vous, captures d'écran réalisées par "**Exported Activity Tester**", e-mails, bases de données SQLite, fichiers XML et autres fichiers créés). Tout cela se fait automatiquement sauf pour les captures d'écran, vous devez appuyer lorsque vous souhaitez une capture d'écran ou vous devez appuyer sur "**Exported Activity Tester**" pour obtenir des captures d'écran de toutes les activités exportées.
@ -585,7 +591,7 @@ receivers
 ```
 **Outils HTTP**

-Lorsque le trafic http est capturé, vous pouvez voir une vue peu esthétique du trafic capturé en bas sur "**HTTP(S) Traffic**" ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\
+Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé en bas sur "**HTTP(S) Traffic**" ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\
 Pour ce faire, _allumez Burp -->_ _désactivez Intercept --> dans MobSB HTTPTools, sélectionnez la requête_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).

 Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer sur "**Start Web API Fuzzer**" pour **fuzz les requêtes http** et rechercher des vulnérabilités.
@ -610,7 +616,7 @@ C'est un **excellent outil pour effectuer une analyse statique avec une interfac

 ### [Qark](https://github.com/linkedin/qark)

-Cet outil est conçu pour rechercher plusieurs **vulnérabilités liées à la sécurité des applications Android**, que ce soit dans le **code source** ou les **APKs empaquetés**. L'outil est également **capable de créer un APK déployable "Proof-of-Concept"** et des **commandes ADB**, pour exploiter certaines des vulnérabilités trouvées (activités exposées, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test.
+Cet outil est conçu pour rechercher plusieurs **vulnérabilités liées à la sécurité des applications Android**, que ce soit dans le **code source** ou les **APKs empaquetés**. L'outil est également **capable de créer un APK déployable "Proof-of-Concept"** et des **commandes ADB**, pour exploiter certaines des vulnérabilités trouvées (Activités exposées, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@ -646,13 +652,13 @@ StaCoAn est un outil **multiplateforme** qui aide les développeurs, les chasseu

 Le concept est que vous faites glisser et déposer votre fichier d'application mobile (un fichier .apk ou .ipa) sur l'application StaCoAn et elle générera un rapport visuel et portable pour vous. Vous pouvez ajuster les paramètres et les listes de mots pour obtenir une expérience personnalisée.

-Télécharger[ dernière version](https://github.com/vincentcox/StaCoAn/releases):
+Téléchargez[ la dernière version](https://github.com/vincentcox/StaCoAn/releases):
 ```
 ./stacoan
 ```
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)

-AndroBugs Framework est un système d'analyse de vulnérabilités Android qui aide les développeurs ou les hackers à trouver des vulnérabilités de sécurité potentielles dans les applications Android.\
+Le framework AndroBugs est un système d'analyse de vulnérabilités Android qui aide les développeurs ou les hackers à trouver des vulnérabilités de sécurité potentielles dans les applications Android.\
 [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
@ -689,7 +695,7 @@ Utile pour détecter les malwares : [https://koodous.com/](https://koodous.com)

 ## Obfuscating/Deobfuscating code

-Notez que selon le service et la configuration que vous utilisez pour obfusquer le code, les secrets peuvent ou non être obfusqués.
+Notez qu'en fonction du service et de la configuration que vous utilisez pour obfusquer le code, les secrets peuvent ou non être obfusqués.

 ### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)

@ -715,7 +721,7 @@ Trouvez un guide étape par étape pour déobfusquer l'apk sur [https://blog.lex

 Vous pouvez télécharger un APK obfusqué sur leur plateforme.

-### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
+### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)

 C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans les applications android et déobfusquer le code des applications android. Utilise l'API publique Gemini de Google.

@ -735,7 +741,7 @@ APKiD vous donne des informations sur **comment un APK a été créé**. Il iden

 ### [Androl4b](https://github.com/sh4hin/Androl4b)

-AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut la collection des derniers frameworks, tutoriels et laboratoires de différents geeks et chercheurs en sécurité pour l'ingénierie inverse et l'analyse de malware.
+AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut la collection des derniers frameworks, tutoriels et laboratoires de différents geeks et chercheurs en sécurité pour l'ingénierie inverse et l'analyse de malwares.

 ## References

--- a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
+++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
@ -0,0 +1,203 @@
+# Android Anti-Instrumentation & SSL Pinning Bypass (Frida/Objection)
+
+{{#include ../../banners/hacktricks-training.md}}
+
+Cette page fournit un flux de travail pratique pour regagner une analyse dynamique contre les applications Android qui détectent/bloquent l'instrumentation ou appliquent le pinning TLS. Elle se concentre sur un triage rapide, des détections courantes et des hooks/tactiques copiables pour les contourner sans recompilation lorsque cela est possible.
+
+## Surface de détection (ce que les applications vérifient)
+
+- Vérifications de root : binaire su, chemins Magisk, valeurs getprop, paquets root courants
+- Vérifications Frida/debugger (Java) : Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), analyse de /proc, classpath, libs chargées
+- Anti-debug natif : ptrace(), syscalls, anti-attach, breakpoints, hooks en ligne
+- Vérifications d'initialisation précoce : Application.onCreate() ou hooks de démarrage de processus qui plantent si l'instrumentation est présente
+- Pinning TLS : TrustManager/HostnameVerifier personnalisé, OkHttp CertificatePinner, pinning Conscrypt, pins natifs
+
+## Étape 1 — Gain rapide : cacher le root avec Magisk DenyList
+
+- Activer Zygisk dans Magisk
+- Activer DenyList, ajouter le paquet cible
+- Redémarrer et retester
+
+De nombreuses applications ne recherchent que des indicateurs évidents (chemins su/Magisk/getprop). DenyList neutralise souvent les vérifications naïves.
+
+Références :
+- Magisk (Zygisk & DenyList) : https://github.com/topjohnwu/Magisk
+
+## Étape 2 — Tests Frida Codeshare de 30 secondes
+
+Essayez des scripts courants avant de plonger en profondeur :
+
+- anti-root-bypass.js
+- anti-frida-detection.js
+- hide_frida_gum.js
+
+Exemple :
+```bash
+frida -U -f com.example.app -l anti-frida-detection.js
+```
+Ces vérifications Java root/debug, les analyses de processus/services et native ptrace() sont généralement contournées. Utile sur des applications légèrement protégées ; les cibles renforcées peuvent nécessiter des hooks sur mesure.
+
+- Codeshare: https://codeshare.frida.re/
+
+## Étape 3 — Contourner les détecteurs au moment de l'initialisation en s'attachant tard
+
+De nombreuses détections ne s'exécutent que lors de la création du processus/onCreate(). L'injection au moment de la création (-f) ou les gadgets sont détectés ; s'attacher après le chargement de l'interface utilisateur peut passer inaperçu.
+```bash
+# Launch the app normally (launcher/adb), wait for UI, then attach
+frida -U -n com.example.app
+# Or with Objection to attach to running process
+aobjection --gadget com.example.app explore  # if using gadget
+```
+Si cela fonctionne, maintenez la session stable et procédez à la cartographie et aux vérifications de stub.
+
+## Étape 4 — Cartographier la logique de détection via Jadx et la recherche de chaînes
+
+Mots-clés de triage statique dans Jadx :
+- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger"
+
+Modèles Java typiques :
+```java
+public boolean isFridaDetected() {
+return getRunningServices().contains("frida");
+}
+```
+APIs courantes à examiner/accrocher :
+- android.os.Debug.isDebuggerConnected
+- android.app.ActivityManager.getRunningAppProcesses / getRunningServices
+- java.lang.System.loadLibrary / System.load (pont natif)
+- java.lang.Runtime.exec / ProcessBuilder (commandes de sondage)
+- android.os.SystemProperties.get (heuristiques root/emulateur)
+
+## Étape 5 — Stub de runtime avec Frida (Java)
+
+Remplacer les gardes personnalisés pour retourner des valeurs sûres sans recompilation :
+```js
+Java.perform(() => {
+const Checks = Java.use('com.example.security.Checks');
+Checks.isFridaDetected.implementation = function () { return false; };
+
+// Neutralize debugger checks
+const Debug = Java.use('android.os.Debug');
+Debug.isDebuggerConnected.implementation = function () { return false; };
+
+// Example: kill ActivityManager scans
+const AM = Java.use('android.app.ActivityManager');
+AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); };
+});
+```
+Triager les premiers plantages ? Dump des classes juste avant qu'il ne meure pour repérer les espaces de noms de détection probables :
+```js
+Java.perform(() => {
+Java.enumerateLoadedClasses({
+onMatch: n => console.log(n),
+onComplete: () => console.log('Done')
+});
+});
+```
+Journaliser et neutraliser les méthodes suspectes pour confirmer le flux d'exécution :
+```js
+Java.perform(() => {
+const Det = Java.use('com.example.security.DetectionManager');
+Det.checkFrida.implementation = function () {
+console.log('checkFrida() called');
+return false;
+};
+});
+```
+## Étape 6 — Suivez la piste JNI/native lorsque les hooks Java échouent
+
+Tracez les points d'entrée JNI pour localiser les chargeurs natifs et l'initialisation de détection :
+```bash
+frida-trace -n com.example.app -i "JNI_OnLoad"
+```
+Triage rapide natif des fichiers .so regroupés :
+```bash
+# List exported symbols & JNI
+nm -D libfoo.so | head
+objdump -T libfoo.so | grep Java_
+strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root'
+```
+Reversing interactif/natif :
+- Ghidra: https://ghidra-sre.org/
+- r2frida: https://github.com/nowsecure/r2frida
+
+Exemple : neutrer ptrace pour vaincre un anti‑debug simple dans libc :
+```js
+const ptrace = Module.findExportByName(null, 'ptrace');
+if (ptrace) {
+Interceptor.replace(ptrace, new NativeCallback(function () {
+return -1; // pretend failure
+}, 'int', ['int', 'int', 'pointer', 'pointer']));
+}
+```
+Voir aussi : {{#ref}}
+reversing-native-libraries.md
+{{#endref}}
+
+## Étape 7 — Patching Objection (intégrer gadget / bases de strip)
+
+Lorsque vous préférez le repacking aux hooks d'exécution, essayez :
+```bash
+objection patchapk --source app.apk
+```
+Notes:
+- Nécessite apktool ; assurez-vous d'avoir une version actuelle selon le guide officiel pour éviter les problèmes de construction : https://apktool.org/docs/install
+- L'injection de gadget permet l'instrumentation sans root mais peut toujours être détectée par des vérifications plus strictes au moment de l'initialisation.
+
+References:
+- Objection : https://github.com/sensepost/objection
+
+## Step 8 — Fallback : Patch TLS pinning pour la visibilité réseau
+
+Si l'instrumentation est bloquée, vous pouvez toujours inspecter le trafic en supprimant le pinning de manière statique :
+```bash
+apk-mitm app.apk
+# Then install the patched APK and proxy via Burp/mitmproxy
+```
+- Outil : https://github.com/shroudedcode/apk-mitm
+- Pour les astuces de confiance CA de configuration réseau (et la confiance CA utilisateur Android 7+), voir :
+{{#ref}}
+make-apk-accept-ca-certificate.md
+{{#endref}}
+{{#ref}}
+install-burp-certificate.md
+{{#endref}}
+
+## Feuille de triche de commandes pratiques
+```bash
+# List processes and attach
+frida-ps -Uai
+frida -U -n com.example.app
+
+# Spawn with a script (may trigger detectors)
+frida -U -f com.example.app -l anti-frida-detection.js
+
+# Trace native init
+frida-trace -n com.example.app -i "JNI_OnLoad"
+
+# Objection runtime
+objection --gadget com.example.app explore
+
+# Static TLS pinning removal
+apk-mitm app.apk
+```
+## Conseils et mises en garde
+
+- Préférez attacher tard plutôt que de créer un processus lorsque les applications plantent au lancement
+- Certaines détections se relancent dans des flux critiques (par exemple, paiement, authentification) — gardez les hooks actifs pendant la navigation
+- Mélangez statique et dynamique : chasse aux chaînes dans Jadx pour établir une liste restreinte de classes ; puis accrochez les méthodes pour vérifier à l'exécution
+- Les applications durcies peuvent utiliser des packers et un pinning TLS natif — attendez-vous à inverser le code natif
+
+## Références
+
+- [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/)
+- [Frida Codeshare](https://codeshare.frida.re/)
+- [Objection](https://github.com/sensepost/objection)
+- [apk-mitm](https://github.com/shroudedcode/apk-mitm)
+- [Jadx](https://github.com/skylot/jadx)
+- [Ghidra](https://ghidra-sre.org/)
+- [r2frida](https://github.com/nowsecure/r2frida)
+- [Apktool install guide](https://apktool.org/docs/install)
+- [Magisk](https://github.com/topjohnwu/Magisk)
+
+{{#include ../../banners/hacktricks-training.md}}