maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/generic-methodologies-and-resources/basic-forensic-meth

Browse Source
This commit is contained in:
Translator 2025-09-04 02:39:15 +00:00
parent 249bde0652
commit cda14993e0
3 changed files with 197 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md
View File

@ -1,12 +1,12 @@
# Analyse de Malware # Analyse de malware
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}
## Fiches de Référence en Criminalistique ## CheatSheets d'informatique légale
[https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/) [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
## Services en Ligne ## Services en ligne
- [VirusTotal](https://www.virustotal.com/gui/home/upload) - [VirusTotal](https://www.virustotal.com/gui/home/upload)
- [HybridAnalysis](https://www.hybrid-analysis.com) - [HybridAnalysis](https://www.hybrid-analysis.com)
@ -14,31 +14,31 @@
- [Intezer](https://analyze.intezer.com) - [Intezer](https://analyze.intezer.com)
- [Any.Run](https://any.run/) - [Any.Run](https://any.run/)
## Outils Antivirus et de Détection Hors Ligne ## Outils antivirus et de détection hors ligne
### Yara ### Yara
#### Installer #### Installation
```bash ```bash
sudo apt-get install -y yara sudo apt-get install -y yara
``` ```
#### Préparer les règles #### Préparer les règles
Utilisez ce script pour télécharger et fusionner toutes les règles yara de malware depuis github : [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\ Utilisez ce script pour télécharger et fusionner toutes les règles yara malware depuis github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Créez le répertoire _**rules**_ et exécutez-le. Cela créera un fichier appelé _**malware_rules.yar**_ qui contient toutes les règles yara pour les malwares. Créez le répertoire _**rules**_ et exécutez-le. Cela créera un fichier appelé _**malware_rules.yar**_ qui contient toutes les règles yara pour malware.
```bash ```bash
wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
mkdir rules mkdir rules
python malware_yara_rules.py python malware_yara_rules.py
``` ```
#### Scanner #### Scan
```bash ```bash
yara -w malware_rules.yar image #Scan 1 file yara -w malware_rules.yar image #Scan 1 file
yara -w malware_rules.yar folder #Scan the whole folder yara -w malware_rules.yar folder #Scan the whole folder
``` ```
#### YaraGen : Vérifiez la présence de malware et créez des règles #### YaraGen : Détecter les malware et créer des règles
Vous pouvez utiliser l'outil [**YaraGen**](https://github.com/Neo23x0/yarGen) pour générer des règles yara à partir d'un binaire. Consultez ces tutoriels : [**Partie 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Partie 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Partie 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/) Vous pouvez utiliser l'outil [**YaraGen**](https://github.com/Neo23x0/yarGen) pour générer des yara rules à partir d'un binary. Consultez ces tutoriels : [**Part 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Part 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Part 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
```bash ```bash
python3 yarGen.py --update python3 yarGen.py --update
python3.exe yarGen.py --excludegood -m ../../mals/ python3.exe yarGen.py --excludegood -m ../../mals/
@ -49,7 +49,7 @@ python3.exe yarGen.py --excludegood -m ../../mals/
``` ```
sudo apt-get install -y clamav sudo apt-get install -y clamav
``` ```
#### Scanner #### Analyse
```bash ```bash
sudo freshclam #Update rules sudo freshclam #Update rules
clamscan filepath #Scan 1 file clamscan filepath #Scan 1 file
@ -57,25 +57,25 @@ clamscan folderpath #Scan the whole folder
``` ```
### [Capa](https://github.com/mandiant/capa) ### [Capa](https://github.com/mandiant/capa)
**Capa** détecte des **capabilités** potentiellement malveillantes dans les exécutables : PE, ELF, .NET. Il trouvera donc des éléments tels que les tactiques Att\&ck, ou des capacités suspectes telles que : **Capa** détecte des **capabilities** potentiellement malveillantes dans les exécutables : PE, ELF, .NET. Il trouvera donc des éléments tels que les tactiques Att\&ck, ou des capacités suspectes telles que :
- vérifier l'erreur OutputDebugString - vérifier la présence d'une erreur OutputDebugString
- s'exécuter en tant que service - s'exécuter en tant que service
- créer un processus - créer un processus
Obtenez-le dans le [**Github repo**](https://github.com/mandiant/capa). Récupérez-le sur le [**Github repo**](https://github.com/mandiant/capa).
### IOCs ### IOCs
IOC signifie Indicateur de Compromission. Un IOC est un ensemble de **conditions qui identifient** un logiciel potentiellement indésirable ou un **malware** confirmé. Les Blue Teams utilisent ce type de définition pour **rechercher ce type de fichiers malveillants** dans leurs **systèmes** et **réseaux**.\ IOC signifie Indicator Of Compromise. Un IOC est un ensemble de **conditions qui identifient** un logiciel potentiellement indésirable ou un **malware** confirmé. Les Blue Teams utilisent ce type de définition pour **rechercher ce type de fichiers malveillants** dans leurs **systèmes** et **réseaux**.\
Partager ces définitions est très utile car lorsque le malware est identifié sur un ordinateur et qu'un IOC pour ce malware est créé, d'autres Blue Teams peuvent l'utiliser pour identifier le malware plus rapidement. Le partage de ces définitions est très utile : lorsqu'un malware est identifié sur un ordinateur et qu'un IOC pour ce malware est créé, d'autres Blue Teams peuvent l'utiliser pour identifier le malware plus rapidement.
Un outil pour créer ou modifier des IOCs est [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ Un outil pour créer ou modifier des IOCs est [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
Vous pouvez utiliser des outils tels que [**Redline**](https://www.fireeye.com/services/freeware/redline.html) pour **rechercher des IOCs définis sur un appareil**. Vous pouvez utiliser des outils tels que [**Redline**](https://www.fireeye.com/services/freeware/redline.html) pour **rechercher des IOCs définis sur un dispositif**.
### Loki ### Loki
[**Loki**](https://github.com/Neo23x0/Loki) est un scanner pour des Indicateurs de Compromission Simples.\ [**Loki**](https://github.com/Neo23x0/Loki) est un scanner pour les Simple Indicators of Compromise.\
La détection est basée sur quatre méthodes de détection : La détection est basée sur quatre méthodes de détection :
``` ```
1. File Name IOC 1. File Name IOC
@ -92,41 +92,41 @@ Compares process connection endpoints with C2 IOCs (new since version v.10)
``` ```
### Linux Malware Detect ### Linux Malware Detect
[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) est un scanner de malware pour Linux publié sous la licence GNU GPLv2, conçu autour des menaces rencontrées dans des environnements d'hébergement partagé. Il utilise des données de menaces provenant de systèmes de détection d'intrusion en bordure de réseau pour extraire les malwares qui sont activement utilisés dans des attaques et génère des signatures pour la détection. De plus, les données de menaces proviennent également des soumissions des utilisateurs avec la fonctionnalité de vérification LMD et des ressources de la communauté des malwares. [**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) est un scanner de malware pour Linux distribué sous licence GNU GPLv2, conçu pour les menaces rencontrées dans les environnements d'hébergement mutualisé. Il utilise des données de menace issues des systèmes de détection d'intrusion en bordure réseau pour extraire des malware utilisés activement dans des attaques et générer des signatures pour la détection. De plus, les données de menace proviennent aussi des soumissions d'utilisateurs via la fonctionnalité de checkout de LMD et des ressources communautaires sur les malware.
### rkhunter ### rkhunter
Des outils comme [**rkhunter**](http://rkhunter.sourceforge.net) peuvent être utilisés pour vérifier le système de fichiers à la recherche de **rootkits** et de malwares. Des outils comme [**rkhunter**](http://rkhunter.sourceforge.net) peuvent être utilisés pour vérifier le système de fichiers à la recherche de possibles **rootkits** et malware.
```bash ```bash
sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress] sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
``` ```
### FLOSS ### FLOSS
[**FLOSS**](https://github.com/mandiant/flare-floss) est un outil qui essaiera de trouver des chaînes obfusquées à l'intérieur des exécutables en utilisant différentes techniques. [**FLOSS**](https://github.com/mandiant/flare-floss) est un outil qui va tenter de trouver des strings obfuscated à l'intérieur d'executables en utilisant différentes techniques.
### PEpper ### PEpper
[PEpper ](https://github.com/Th3Hurrican3/PEpper) vérifie certaines informations de base à l'intérieur de l'exécutable (données binaires, entropie, URLs et IPs, certaines règles yara). [PEpper ](https://github.com/Th3Hurrican3/PEpper)vérifie quelques éléments basiques à l'intérieur de l'executable (binary data, entropy, URLs and IPs, some yara rules).
### PEstudio ### PEstudio
[PEstudio](https://www.winitor.com/download) est un outil qui permet d'obtenir des informations sur les exécutables Windows tels que les imports, les exports, les en-têtes, mais vérifiera également virus total et trouvera des techniques potentielles Att\&ck. [PEstudio](https://www.winitor.com/download) est un outil qui permet d'obtenir des informations sur les exécutables Windows telles que imports, exports, headers, mais il vérifiera aussi virus total et trouvera des potentielles Att\&ck techniques.
### Detect It Easy(DiE) ### Detect It Easy(DiE)
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) est un outil pour détecter si un fichier est **chiffré** et également trouver des **packers**. [**DiE**](https://github.com/horsicq/Detect-It-Easy/) est un outil pour détecter si un fichier est **encrypted** et aussi trouver des **packers**.
### NeoPI ### NeoPI
[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) est un script Python qui utilise une variété de **méthodes statistiques** pour détecter du contenu **obfusqué** et **chiffré** dans des fichiers texte/script. L'objectif de NeoPI est d'aider à la **détection de code de shell web caché**. [**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is un script Python qui utilise une variété de **statistical methods** pour détecter du contenu **obfuscated** et **encrypted** dans des fichiers texte/script. L'objectif de NeoPI est d'aider à la **detection of hidden web shell code**.
### **php-malware-finder** ### **php-malware-finder**
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fait de son mieux pour détecter du **code obfusqué**/**suspect** ainsi que des fichiers utilisant des fonctions **PHP** souvent utilisées dans des **malwares**/webshells. [**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fait de son mieux pour détecter du code **obfuscated**/**dodgy code** ainsi que des fichiers utilisant des fonctions **PHP** souvent employées dans des **malwares**/webshells.
### Apple Binary Signatures ### Apple Binary Signatures
Lors de la vérification d'un **échantillon de malware**, vous devez toujours **vérifier la signature** du binaire car le **développeur** qui l'a signé peut déjà être **lié** à des **malwares.** When checking some **malware sample** you should always **check the signature** of the binary as the **developer** that signed it may be already **related** with **malware.**
```bash ```bash
#Get signer #Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier" codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -137,29 +137,41 @@ codesign --verify --verbose /Applications/Safari.app
#Check if the signature is valid #Check if the signature is valid
spctl --assess --verbose /Applications/Safari.app spctl --assess --verbose /Applications/Safari.app
``` ```
## Techniques de Détection ## Detection Techniques
### Empilement de Fichiers ### File Stacking
Si vous savez qu'un dossier contenant les **fichiers** d'un serveur web a été **dernièrement mis à jour à une certaine date**. **Vérifiez** la **date** à laquelle tous les **fichiers** du **serveur web ont été créés et modifiés** et si une date est **suspecte**, vérifiez ce fichier. Si vous savez qu'un dossier contenant les **fichiers** d'un serveur web a été **mis à jour pour la dernière fois à une certaine date**. **Vérifiez** la **date** de création et de modification de tous les **fichiers** du **serveur web** et si une date est **suspicieuse**, examinez ce fichier.
### Lignes de Base ### Baselines
Si les fichiers d'un dossier **n'auraient pas dû être modifiés**, vous pouvez calculer le **hash** des **fichiers originaux** du dossier et **les comparer** avec les **actuels**. Tout ce qui a été modifié sera **suspect**. Si les fichiers d'un dossier **n'auraient pas dû être modifiés**, vous pouvez calculer le **hash** des **fichiers originaux** du dossier et les **comparer** avec ceux **actuels**. Tout ce qui a été modifié sera **suspicieux**.
### Analyse Statistique ### Statistical Analysis
Lorsque l'information est enregistrée dans des journaux, vous pouvez **vérifier des statistiques comme combien de fois chaque fichier d'un serveur web a été accédé, car un shell web pourrait être l'un des plus**. Quand l'information est enregistrée dans des logs, vous pouvez **vérifier des statistiques comme combien de fois chaque fichier d'un serveur web a été accédé, car un web shell pourrait être l'un des plus sollicités**.
--- ---
## Déobfuscation du Flux de Contrôle Dynamique (Dispatcheurs JMP/CALL RAX) ### Android in-app native telemetry (no root)
Les familles de malware modernes abusent fortement de l'obfuscation du Graphique de Flux de Contrôle (CFG) : au lieu d'un saut/appel direct, elles calculent la destination à l'exécution et exécutent un `jmp rax` ou `call rax`. Un petit *dispatcheur* (typiquement neuf instructions) définit la cible finale en fonction des drapeaux `ZF`/`CF` du CPU, brisant complètement la récupération statique du CFG. Sur Android, vous pouvez instrumenter du code natif à l'intérieur du processus de l'application cible en préchargeant une petite librairie de logging avant l'initialisation des autres libs JNI. Cela fournit une visibilité précoce sur le comportement natif sans hooks au niveau du système ni root. Une approche populaire est SoTap : placer libsotap.so pour le bon ABI dans l'APK et injecter un appel System.loadLibrary("sotap") tôt (e.g., static initializer or Application.onCreate), puis collecter les logs depuis des chemins internes/externes ou en fallback sur Logcat.
La technique – mise en avant par le chargeur SLOW#TEMPEST – peut être vaincue avec un flux de travail en trois étapes qui repose uniquement sur IDAPython et l'émulateur de CPU Unicorn. See the Android native reversing page for setup details and log paths:
### 1. Localiser chaque saut / appel indirect {{#ref}}
../../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
{{#endref}}
---
## Déobfuscation du Control-Flow dynamique (JMP/CALL RAX Dispatchers)
Les familles de malware modernes abusent fortement de l'obfuscation du Control-Flow Graph (CFG) : au lieu d'un jump/call direct, elles calculent la destination à l'exécution et exécutent un `jmp rax` ou `call rax`. Un petit *dispatcher* (typiquement neuf instructions) définit la cible finale en fonction des flags CPU `ZF`/`CF`, brisant complètement la récupération statique du CFG.
La technique — démontrée par le loader SLOW#TEMPEST — peut être contrecarrée par un workflow en trois étapes reposant uniquement sur IDAPython et l'émulateur CPU Unicorn.
### 1. Locate every indirect jump / call
```python ```python
import idautils, idc import idautils, idc
@ -199,9 +211,9 @@ mu.reg_write(UC_X86_REG_RAX, 0)
mu.emu_start(BASE, BASE+len(code)) mu.emu_start(BASE, BASE+len(code))
return mu.reg_read(UC_X86_REG_RAX) return mu.reg_read(UC_X86_REG_RAX)
``` ```
Exécutez `run(code,0,0)` et `run(code,1,1)` pour obtenir les cibles de branche *fausse* et *vraie*. Exécutez `run(code,0,0)` et `run(code,1,1)` pour obtenir les cibles de branche *false* et *true*.
### 4. Rétablir un saut / appel direct ### 4. Rétablir un jump / call direct
```python ```python
import struct, ida_bytes import struct, ida_bytes
@ -210,7 +222,7 @@ op = 0xE8 if is_call else 0xE9 # CALL rel32 or JMP rel32
disp = target - (ea + 5) & 0xFFFFFFFF disp = target - (ea + 5) & 0xFFFFFFFF
ida_bytes.patch_bytes(ea, bytes([op]) + struct.pack('<I', disp)) ida_bytes.patch_bytes(ea, bytes([op]) + struct.pack('<I', disp))
``` ```
Après avoir appliqué le correctif, forcez IDA à réanalyser la fonction afin que le CFG complet et la sortie Hex-Rays soient restaurés : Après avoir appliqué le patch, forcez IDA à réanalyser la fonction afin que le CFG complet et la sortie Hex-Rays soient restaurés :
```python ```python
import ida_auto, idaapi import ida_auto, idaapi
idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START)) idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
@ -224,13 +236,14 @@ idc.set_callee_name(call_ea, resolved_addr, 0) # IDA 8.3+
### Avantages pratiques ### Avantages pratiques
* Restaure le vrai CFG → la décompilation passe de *10* lignes à des milliers. * Restaure le vrai CFG → la décompilation passe de *10* lignes à des milliers.
* Permet la référence croisée de chaînes & xrefs, rendant la reconstruction du comportement triviale. * Permet les string-cross-reference & xrefs, rendant la reconstruction du comportement triviale.
* Les scripts sont réutilisables : il suffit de les placer dans n'importe quel chargeur protégé par le même truc. * Les scripts sont réutilisables : déposez-les dans n'importe quel loader protégé par la même astuce.
--- ---
## Références ## Références
- [Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques](https://unit42.paloaltonetworks.com/slow-tempest-malware-obfuscation/) - [Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques](https://unit42.paloaltonetworks.com/slow-tempest-malware-obfuscation/)
- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}

107
src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
View File

@ -1,47 +1,50 @@
# Reversing Native Libraries # Rétro-ingénierie des bibliothèques natives
{{#include ../../banners/hacktricks-training.md}} {{#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, consultez :** [**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, généralement écrites en C ou C++, pour des tâches critiques en termes de performance. Les créateurs de logiciels malveillants abusent également de ces bibliothèques car les objets partagés ELF sont encore plus difficiles à décompiler que le code byte DEX/OAT. Cette page se concentre sur des workflows *pratiques* et des améliorations d'outils *récentes* (2023-2025) qui facilitent le reverse engineering des fichiers `.so` Android. Les applications Android peuvent utiliser des bibliothèques natives, généralement écrites en C ou C++, pour des tâches critiques en performance. Les créateurs de malware abusent aussi de ces bibliothèques car les objets partagés ELF sont encore 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 facilitent la reversing des fichiers `.so` Android.
--- ---
### Workflow de triage rapide pour un `libfoo.so` fraîchement extrait ### Flux de triage rapide pour un `libfoo.so` fraîchement extrait
1. **Extraire la bibliothèque** 1. **Extraire la bibliothèque**
```bash ```bash
# À partir d'une application installée # From an installed application
adb shell "run-as <pkg> cat lib/arm64-v8a/libfoo.so" > libfoo.so adb shell "run-as <pkg> cat lib/arm64-v8a/libfoo.so" > libfoo.so
# Ou à partir de l'APK (zip) # Or from the APK (zip)
unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/ unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/
``` ```
2. **Identifier l'architecture et les protections** 2. **Identifier l'architecture et les protections**
```bash ```bash
file libfoo.so # arm64 ou arm32 / x86 file libfoo.so # arm64 or arm32 / x86
readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc. readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc.
checksec --file libfoo.so # (peda/pwntools) checksec --file libfoo.so # (peda/pwntools)
``` ```
3. **Lister les symboles exportés et les liaisons JNI** 3. **Lister les symboles exportés et les bindings JNI**
```bash ```bash
readelf -s libfoo.so | grep ' Java_' # JNI lié dynamiquement readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI
strings libfoo.so | grep -i "RegisterNatives" -n # JNI enregistré statiquement strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI
``` ```
4. **Charger dans un décompilateur** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper ou Cutter/Rizin) et exécuter l'analyse automatique. Les versions plus récentes de Ghidra ont introduit un décompilateur AArch64 qui reconnaît les stubs PAC/BTI et les balises MTE, améliorant considérablement l'analyse des bibliothèques construites avec le NDK Android 14. 4. **Charger dans un décompilateur** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) et lancer l'analyse automatique.
5. **Décider entre reverse engineering statique et dynamique :** le code obfusqué et supprimé nécessite souvent une *instrumentation* (Frida, ptrace/gdbserver, LLDB). 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. **Choisir entre reverse statique et dynamique :** du code stripped/obfusqué nécessite souvent de l'*instrumentation* (Frida, ptrace/gdbserver, LLDB).
--- ---
### Instrumentation Dynamique (Frida ≥ 16) ### 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 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`). * `thumb-relocator` peut désormais *hook tiny ARM/Thumb functions* générées par l'alignement agressif de LLD (`--icf=all`).
* L'énumération et le rebinding des *slots d'importation ELF* fonctionnent sur Android, permettant le patching `dlopen()`/`dlsym()` par module lorsque les hooks en ligne sont rejetés. * L'énumération et le rebinding des *ELF import slots* fonctionnent sur Android, permettant le patch par module via `dlopen()`/`dlsym()` lorsque les inline hooks sont rejetés.
* Le hooking Java a été corrigé pour le nouveau **point d'entrée rapide ART** utilisé lorsque les applications sont compilées avec `--enable-optimizations` sur Android 14. * Le Java hooking a été corrigé pour le nouveau **ART quick-entrypoint** utilisé lorsque les apps sont compilées avec `--enable-optimizations` sur Android 14.
Exemple : énumérer toutes les fonctions enregistrées via `RegisterNatives` et extraire leurs adresses à l'exécution : Exemple : énumérer toutes les fonctions enregistrées via `RegisterNatives` et dumper leurs adresses à l'exécution :
```javascript ```javascript
Java.perform(function () { Java.perform(function () {
var Runtime = Java.use('java.lang.Runtime'); var Runtime = Java.use('java.lang.Runtime');
@ -58,38 +61,76 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met
}); });
}); });
``` ```
Frida fonctionnera dès la sortie de la boîte sur les appareils activés PAC/BTI (Pixel 8/Android 14+) tant que vous utilisez frida-server 16.2 ou une version ultérieure – les versions antérieures n'ont pas réussi à localiser le padding pour les hooks en ligne. citeturn5search2turn5search0 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)
When full-featured instrumentation is overkill or blocked, you can still gain native-level visibility by preloading a small logger inside the target process. SoTap is a lightweight Android native (.so) library that logs the runtime behavior of other JNI (.so) libraries within the same app process (no root required).
Key properties:
- Initializes early and observes JNI/native interactions inside the process that loads it.
- Persists logs using multiple writable paths with graceful fallback to Logcat when storage is restricted.
- Source-customizable: edit sotap.c to extend/adjust what gets logged and rebuild per ABI.
Setup (repaquetage de l'APK):
1) Déposez le build ABI approprié dans l'APK afin que le loader puisse résoudre libsotap.so :
- lib/arm64-v8a/libsotap.so (for arm64)
- lib/armeabi-v7a/libsotap.so (for arm32)
2) Assurez-vous que SoTap se charge avant les autres libs JNI. Injectez un appel tôt (par ex., static initializer de la sous-classe Application ou onCreate) afin que le logger soit initialisé en premier. Exemple de snippet Smali :
```smali
const-string v0, "sotap"
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
```
3) Rebuild/sign/install, lancez l'app, puis collectez les logs.
Log paths (checked in order):
```
/data/user/0/%s/files/sotap.log
/data/data/%s/files/sotap.log
/sdcard/Android/data/%s/files/sotap.log
/sdcard/Download/sotap-%s.log
# If all fail: fallback to Logcat only
```
Notes et dépannage:
- L'alignement de l'ABI est obligatoire. Un désalignement déclenchera 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 toujours via Logcat.
- Le comportement/la verbosité est conçu·e pour être personnalisé·e ; recompilez depuis la source après avoir édité 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 processus est critique mais que des hooks root/système globaux ne sont pas disponibles.
--- ---
### Vulnérabilités récentes à rechercher dans les APK ### Recent vulnerabilities worth hunting for in APKs
| Année | CVE | Bibliothèque affectée | Remarques | | Année | CVE | Bibliothèque affectée | Remarques |
|------|-----|------------------|-------| |------|-----|------------------|-------|
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Dépassement de tampon de tas accessible depuis le code natif qui décode les images WebP. Plusieurs applications Android regroupent des versions vulnérables. Lorsque vous voyez un `libwebp.so` à l'intérieur d'un APK, vérifiez sa version et tentez l'exploitation ou le patching.| citeturn2search0| |2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow reachable from native code that decodes WebP images. Plusieurs applications Android embarquent des versions vulnérables. Lorsque vous voyez un `libwebp.so` dans un APK, vérifiez sa version et tentez une exploitation ou un correctif.| |
|2024|Multiple|Série OpenSSL 3.x|Plusieurs problèmes de sécurité mémoire et d'oracle de padding. De nombreux bundles Flutter & ReactNative expédient leur propre `libcrypto.so`.| |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` *tiers* à l'intérieur d'un APK, vérifiez toujours leur hash par rapport aux avis en amont. L'analyse de composition logicielle (SCA) est rare sur mobile, donc les builds vulnérables obsolètes sont répandus. Lorsque vous repérez des fichiers `.so` *third-party* à l'intérieur d'un APK, vérifiez toujours leur hash par rapport aux avis upstream. SCA (Software Composition Analysis) est peu courant sur mobile, donc des builds vulnérables et obsolètes sont répandus.
--- ---
### Tendances Anti-Reversing & Hardening (Android 13-15) ### Anti-Reversing & Hardening trends (Android 13-15)
* **Authentification de pointeur (PAC) & Identification de cible de branche (BTI) :** Android 14 active PAC/BTI dans les bibliothèques système sur les silicons ARMv8.3+ pris en charge. Les décompilateurs affichent désormais des pseudo-instructions liées à PAC ; pour l'analyse dynamique, Frida injecte des trampolines *après* avoir supprimé PAC, mais vos trampolines personnalisés doivent appeler `pacda`/`autibsp` si nécessaire. * **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 active PAC/BTI dans les bibliothèques système sur les puces ARMv8.3+ compatibles. Les décompilateurs affichent maintenant des pseudo-instructions liées à PAC ; pour l'analyse dynamique Frida injecte des trampolines *après* avoir enlevé PAC, mais vos trampolines personnalisés devraient appeler `pacda`/`autibsp` lorsque nécessaire.
* **MTE & Allocateur durci Scudo :** le tagging de mémoire est opt-in mais de nombreuses applications conscientes de Play-Integrity sont construites avec `-fsanitize=memtag` ; utilisez `setprop arm64.memtag.dump 1` plus `adb shell am start ...` pour capturer les fautes de tag. * **MTE & Scudo hardened allocator:** le memory-tagging est opt-in 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.
* **Obfuscateur LLVM (prédicats opaques, aplatissement de flux de contrôle) :** les packers commerciaux (par exemple, Bangcle, SecNeo) protègent de plus en plus le code *natif*, pas seulement Java ; attendez-vous à des flux de contrôle faux et à des blobs de chaînes chiffrées dans `.rodata`. * **LLVM Obfuscator (opaque predicates, control-flow flattening):** des packers commerciaux (e.g., Bangcle, SecNeo) protègent de plus en plus le code *native*, pas seulement Java ; attendez-vous à du control-flow bidon et des blobs de chaînes chiffrés dans `.rodata`.
--- ---
### Ressources ### Resources
- **Apprendre l'assemblage ARM :** [Azeria Labs – Notions de base sur l'assemblage ARM](https://azeria-labs.com/writing-arm-assembly-part-1/) - **Learning ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
- **Documentation JNI & NDK :** [Spécification JNI d'Oracle](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Conseils JNI Android](https://developer.android.com/training/articles/perf-jni) · [Guides NDK](https://developer.android.com/ndk/guides/) - **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/)
- **Débogage des bibliothèques natives :** [Déboguer les bibliothèques natives Android à l'aide de JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) - **Debugging Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)
### Références ### References
- Journal des modifications de Frida 16.x (hooking Android, relocation de fonction minuscule) – [frida.re/news](https://frida.re/news/) citeturn5search0 - Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
- Avis NVD pour le dépassement de `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) citeturn2search0 - 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)
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}

99
src/mobile-pentesting/android-app-pentesting/smali-changes.md
View File

@ -1,8 +1,9 @@
# Smali - Décompilation/\[Modification]/Compilation # Smali - Décompilation/[Modification]/Recompilation
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}
Parfois, il est intéressant de modifier le code de l'application pour accéder à des informations cachées pour vous (peut-être des mots de passe ou des drapeaux bien obfusqués). Ensuite, il pourrait être intéressant de décompiler l'apk, de modifier le code et de le recompiler.
Parfois il est intéressant de modifier le code de l'application pour accéder à des informations cachées pour vous (peut‑être 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 le recompiler.
**Référence des opcodes :** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) **Référence des opcodes :** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html)
@ -10,68 +11,68 @@ Parfois, il est intéressant de modifier le code de l'application pour accéder
En utilisant **Visual Studio Code** et l'extension [APKLab](https://github.com/APKLab/APKLab), vous pouvez **décompiler automatiquement**, modifier, **recompiler**, signer et installer l'application sans exécuter de commande. En utilisant **Visual Studio Code** et l'extension [APKLab](https://github.com/APKLab/APKLab), vous pouvez **décompiler automatiquement**, modifier, **recompiler**, signer et installer l'application sans exécuter de commande.
Un autre **script** qui facilite beaucoup cette tâche est [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh) Un autre **script** qui facilite grandement cette tâche est [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh)
## Décompiler l'APK ## Décompiler l'APK
En utilisant APKTool, vous pouvez accéder au **code smali et aux ressources** : Avec APKTool vous pouvez accéder au **smali code et aux resources** :
```bash ```bash
apktool d APP.apk apktool d APP.apk
``` ```
Si **apktool** vous donne une erreur, essayez d'[installer la **dernière version**](https://ibotpeaches.github.io/Apktool/install/) Si **apktool** vous donne une erreur, essayez[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/)
Certains **fichiers intéressants à examiner sont** : Some **interesting files you should look are**:
- _res/values/strings.xml_ (et tous les xml à l'intérieur de res/values/\*) - _res/values/strings.xml_ (et tous les xml à l'intérieur de res/values/*)
- _AndroidManifest.xml_ - _AndroidManifest.xml_
- Tout fichier avec l'extension _.sqlite_ ou _.db_ - Any file with extension _.sqlite_ or _.db_
Si `apktool` a des **problèmes pour décoder l'application**, jetez un œil à [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) ou essayez d'utiliser l'argument **`-r`** (Ne pas décoder les ressources). Ensuite, si le problème était dans une ressource et non dans le code source, vous n'aurez pas le problème (vous ne décompilerez pas non plus les ressources). If `apktool` has **problems decoding the application** take a look to [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) or try using the argument **`-r`** (Ne pas décoder les ressources).
## Modifier le code smali ## Modifier le code smali
Vous pouvez **modifier** les **instructions**, changer la **valeur** de certaines variables ou **ajouter** de nouvelles instructions. Je modifie le code Smali en utilisant [**VS Code**](https://code.visualstudio.com), vous devez ensuite installer l'**extension smalise** et l'éditeur vous indiquera si une **instruction est incorrecte**.\ Vous pouvez **modifier** les **instructions**, changer la **valeur** de certaines variables ou **ajouter** de nouvelles instructions. Je modifie le code Smali en utilisant [**VS Code**](https://code.visualstudio.com), installez ensuite l'**extension smalise** et l'éditeur vous indiquera si une **instruction est incorrecte**.\
Quelques **exemples** peuvent être trouvés ici : Some **examples** can be found here:
- [Exemples de modifications Smali](smali-changes.md) - [Smali changes examples](smali-changes.md)
- [Google CTF 2018 - Shall We Play a Game?](google-ctf-2018-shall-we-play-a-game.md) - [Google CTF 2018 - Shall We Play a Game?](google-ctf-2018-shall-we-play-a-game.md)
Ou vous pouvez [**vérifier ci-dessous quelques modifications Smali expliquées**](smali-changes.md#modifying-smali). Or you can [**check below some Smali changes explained**](smali-changes.md#modifying-smali).
## Recompiler l'APK ## Recompiler l'APK
Après avoir modifié le code, vous pouvez **recompiler** le code en utilisant : Après avoir modifié le code, vous pouvez **recompiler** le code en utilisant:
```bash ```bash
apktool b . #In the folder generated when you decompiled the application apktool b . #In the folder generated when you decompiled the application
``` ```
Il **compilera** le nouveau APK **dans** le dossier _**dist**_. Cela va **compiler** le nouvel APK **dans** le dossier _**dist**_.
Si **apktool** génère une **erreur**, essayez d'installer la **dernière version**. Si **apktool** renvoie une **erreur**, essayez [d'installer la **dernière version**](https://ibotpeaches.github.io/Apktool/install/)
### **Signer le nouveau APK** ### **Signer le nouvel APK**
Ensuite, vous devez **générer une clé** (on vous demandera un mot de passe et quelques informations que vous pouvez remplir au hasard) : Ensuite, vous devez **générer une clé** (on vous demandera un mot de passe et quelques informations que vous pouvez remplir aléatoirement) :
```bash ```bash
keytool -genkey -v -keystore key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias <your-alias> keytool -genkey -v -keystore key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias <your-alias>
``` ```
Enfin, **signez** le nouvel APK : Enfin, **signez** le nouvel APK:
```bash ```bash
jarsigner -keystore key.jks path/to/dist/* <your-alias> jarsigner -keystore key.jks path/to/dist/* <your-alias>
``` ```
### Optimiser la nouvelle application ### Optimiser la nouvelle application
**zipalign** est un outil d'alignement d'archive qui fournit une optimisation importante aux fichiers d'application Android (APK). [More information here](https://developer.android.com/studio/command-line/zipalign). **zipalign** est un outil d'alignement d'archives qui apporte une optimisation importante aux fichiers d'application Android (APK). [Plus d'informations ici](https://developer.android.com/studio/command-line/zipalign).
```bash ```bash
zipalign [-f] [-v] <alignment> infile.apk outfile.apk zipalign [-f] [-v] <alignment> infile.apk outfile.apk
zipalign -v 4 infile.apk zipalign -v 4 infile.apk
``` ```
### **Signer le nouvel APK (encore ?)** ### **Signer le nouvel APK (encore ?)**
Si vous **préférez** utiliser [**apksigner**](https://developer.android.com/studio/command-line/) au lieu de jarsigner, **vous devez signer l'apk** après avoir appliqué **l'optimisation avec** zipalign. MAIS REMARQUEZ QUE VOUS DEVEZ **SIGNER L'APPLICATION UNE SEULE FOIS** AVEC jarsigner (avant zipalign) OU AVEC aspsigner (après zipalign). Si vous **préférez** utiliser [**apksigner**](https://developer.android.com/studio/command-line/) au lieu de jarsigner, **vous devriez signer l'apk** après avoir appliqué **l'optimisation avec** zipaling. MAIS REMARQUEZ QUE VOUS N'AVEZ QU'À **SIGNER L'APPLICATION UNE SEULE FOIS** AVEC jarsigner (avant zipalign) OU AVEC aspsigner (après zipaling).
```bash ```bash
apksigner sign --ks key.jks ./dist/mycompiled.apk apksigner sign --ks key.jks ./dist/mycompiled.apk
``` ```
## Modification de Smali ## Modifier Smali
Pour le code Java Hello World suivant : Pour le code Java Hello World suivant :
```java ```java
@ -89,13 +90,13 @@ invoke-virtual {v0,v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
return-void return-void
.end method .end method
``` ```
L'ensemble d'instructions Smali est disponible [ici](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions). Le jeu d'instructions Smali est disponible [here](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions).
### Changements légers ### Modifications légères
### Modifier les valeurs initiales d'une variable à l'intérieur d'une fonction ### Modifier les valeurs initiales d'une variable dans une fonction
Certaines variables sont définies au début de la fonction en utilisant l'opcode _const_, vous pouvez modifier ses valeurs, ou vous pouvez en définir de nouvelles : Certaines variables sont définies au début de la fonction en utilisant l'opcode _const_; vous pouvez modifier leurs valeurs, ou en définir de nouvelles :
```bash ```bash
#Number #Number
const v9, 0xf4240 const v9, 0xf4240
@ -126,7 +127,7 @@ iput v0, p0, Lcom/google/ctf/shallweplayagame/GameActivity;->o:I #Save v0 inside
if-ne v0, v9, :goto_6 #If not equals, go to: :goto_6 if-ne v0, v9, :goto_6 #If not equals, go to: :goto_6
goto :goto_6 #Always go to: :goto_6 goto :goto_6 #Always go to: :goto_6
``` ```
### Changements Plus Importants ### Modifications majeures
### Journalisation ### Journalisation
```bash ```bash
@ -139,17 +140,17 @@ invoke-static {v5, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/Strin
``` ```
Recommandations : Recommandations :
- Si vous allez utiliser des variables déclarées à l'intérieur de la fonction (déclarées v0,v1,v2...), placez ces lignes entre le _.local \<number>_ et les déclarations des variables (_const v0, 0x1_) - Si vous allez utiliser des variables déclarées à l'intérieur de la fonction (déclarées v0,v1,v2...) placez ces lignes entre le _.local <number>_ et les déclarations des variables (_const v0, 0x1_)
- Si vous souhaitez insérer le code de journalisation au milieu du code d'une fonction : - Si vous voulez insérer le logging code au milieu du code d'une fonction :
- Ajoutez 2 au nombre de variables déclarées : Ex : de _.locals 10_ à _.locals 12_ - Ajoutez 2 au nombre de variables déclarées : Ex : de _.locals 10_ à _.locals 12_
- Les nouvelles variables doivent être les prochains numéros des variables déjà déclarées (dans cet exemple, cela devrait être _v10_ et _v11_, rappelez-vous que cela commence à v0). - Les nouvelles variables doivent utiliser les numéros suivants des variables déjà déclarées (dans cet exemple elles doivent être _v10_ et _v11_, souvenez-vous que la numérotation commence à v0).
- Modifiez le code de la fonction de journalisation et utilisez _v10_ et _v11_ au lieu de _v5_ et _v1_. - Modifiez le code de la fonction de logging et utilisez _v10_ et _v11_ à la place de _v5_ et _v1_.
### Toasting ### Toasting
N'oubliez pas d'ajouter 3 au nombre de _.locals_ au début de la fonction. N'oubliez pas d'ajouter 3 au nombre de _.locals_ au début de la fonction.
Ce code est préparé pour être inséré dans le **milieu d'une fonction** (**changez** le nombre des **variables** si nécessaire). Il prendra la **valeur de this.o**, **la transformera** en **String** et ensuite **fera** un **toast** avec sa valeur. Ce code est prêt à être inséré dans le **milieu d'une fonction** (**changez** le nombre des **variables** si nécessaire). Il prendra la **valeur de this.o**, la **transformera** en **String** et ensuite **fera** un **toast** avec sa valeur.
```bash ```bash
const/4 v10, 0x1 const/4 v10, 0x1
const/4 v11, 0x1 const/4 v11, 0x1
@ -161,4 +162,38 @@ invoke-static {p0, v11, v12}, Landroid/widget/Toast;->makeText(Landroid/content/
move-result-object v12 move-result-object v12
invoke-virtual {v12}, Landroid/widget/Toast;->show()V invoke-virtual {v12}, Landroid/widget/Toast;->show()V
``` ```
### Chargement d'une bibliothèque native au démarrage (System.loadLibrary)
Parfois vous devez précharger une bibliothèque native afin qu'elle s'initialise avant les autres libs JNI (p. ex. pour activer la télémétrie/journalisation locale du processus). Vous pouvez injecter un appel à System.loadLibrary() dans un initialiseur statique ou tôt dans Application.onCreate(). Exemple smali pour un initialiseur de classe statique (<clinit>):
```smali
.class public Lcom/example/App;
.super Landroid/app/Application;
.method static constructor <clinit>()V
.registers 1
const-string v0, "sotap" # library name without lib...so prefix
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
return-void
.end method
```
Alternativement, placez les mêmes deux instructions au début de votre Application.onCreate() pour garantir que la bibliothèque se charge le plus tôt possible :
```smali
.method public onCreate()V
.locals 1
const-string v0, "sotap"
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
invoke-super {p0}, Landroid/app/Application;->onCreate()V
return-void
.end method
```
Remarques :
- Assurez-vous que la variante ABI correcte de la bibliothèque existe sous lib/<abi>/ (par ex., arm64-v8a/armeabi-v7a) pour éviter UnsatisfiedLinkError.
- Le chargement très tôt (initialiseur statique de classe) garantit que le logger natif peut observer l'activité JNI ultérieure.
## Références
- SoTap : logger léger in-app du comportement JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}