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

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

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Fiches de Triche en Criminalistique
+## Fiches de Référence en Criminalistique
 
 [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
 
@@ -49,7 +49,7 @@ python3.exe yarGen.py --excludegood -m  ../../mals/
 ```
 sudo apt-get install -y clamav
 ```
-#### Analyse
+#### Scanner
 ```bash
 sudo freshclam      #Update rules
 clamscan filepath   #Scan 1 file
@@ -71,7 +71,7 @@ IOC signifie Indicateur de Compromission. Un IOC est un ensemble de **conditions
 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.
 
 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 dans 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 appareil**.
 
 ### Loki
 
@@ -92,7 +92,7 @@ Compares process connection endpoints with C2 IOCs (new since version v.10)
 ```
 ### 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 les 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 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.
 
 ### rkhunter
 
@@ -110,7 +110,7 @@ sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--sk
 
 ### 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 Att\&ck potentielles.
+[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.
 
 ### Detect It Easy(DiE)
 
@@ -149,6 +149,88 @@ Si les fichiers d'un dossier **n'auraient pas dû être modifiés**, vous pouvez
 
 ### Analyse Statistique
 
-Lorsque l'information est enregistrée dans des journaux, vous pouvez **vérifier des statistiques comme le nombre de fois que chaque fichier d'un serveur web a été accédé, car un web shell pourrait être l'un des plus**.
+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**.
+
+---
+
+## Déobfuscation du Flux de Contrôle Dynamique (Dispatcheurs JMP/CALL RAX)
+
+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.
+
+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.
+
+### 1. Localiser chaque saut / appel indirect
+```python
+import idautils, idc
+
+for ea in idautils.FunctionItems(idc.here()):
+mnem = idc.print_insn_mnem(ea)
+if mnem in ("jmp", "call") and idc.print_operand(ea, 0) == "rax":
+print(f"[+] Dispatcher found @ {ea:X}")
+```
+### 2. Extraire le byte-code du dispatcher
+```python
+import idc
+
+def get_dispatcher_start(jmp_ea, count=9):
+s = jmp_ea
+for _ in range(count):
+s = idc.prev_head(s, 0)
+return s
+
+start = get_dispatcher_start(jmp_ea)
+size  = jmp_ea + idc.get_item_size(jmp_ea) - start
+code  = idc.get_bytes(start, size)
+open(f"{start:X}.bin", "wb").write(code)
+```
+### 3. Émulez-le deux fois avec Unicorn
+```python
+from unicorn import *
+from unicorn.x86_const import *
+import struct
+
+def run(code, zf=0, cf=0):
+BASE = 0x1000
+mu = Uc(UC_ARCH_X86, UC_MODE_64)
+mu.mem_map(BASE, 0x1000)
+mu.mem_write(BASE, code)
+mu.reg_write(UC_X86_REG_RFLAGS, (zf << 6) | cf)
+mu.reg_write(UC_X86_REG_RAX, 0)
+mu.emu_start(BASE, BASE+len(code))
+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*.
+
+### 4. Rétablir un saut / appel direct
+```python
+import struct, ida_bytes
+
+def patch_direct(ea, target, is_call=False):
+op   = 0xE8 if is_call else 0xE9           # CALL rel32 or JMP rel32
+disp = target - (ea + 5) & 0xFFFFFFFF
+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 :
+```python
+import ida_auto, idaapi
+idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
+```
+### 5. Étiqueter les appels API indirects
+
+Une fois que la véritable destination de chaque `call rax` est connue, vous pouvez indiquer à IDA ce que c'est afin que les types de paramètres et les noms de variables soient récupérés automatiquement :
+```python
+idc.set_callee_name(call_ea, resolved_addr, 0)  # IDA 8.3+
+```
+### Avantages pratiques
+
+* 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.
+* Les scripts sont réutilisables : il suffit de les placer dans n'importe quel chargeur protégé par le même truc.
+
+---
+
+## Références
+
+- [Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques](https://unit42.paloaltonetworks.com/slow-tempest-malware-obfuscation/)
 
 {{#include ../../banners/hacktricks-training.md}}