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

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

@@ -57,13 +57,13 @@ clamscan folderpath #Scan the whole folder
 ```
 ### [Capa](https://github.com/mandiant/capa)
 
-**Capa** detecta **capacidades** potencialmente maliciosas em executáveis: PE, ELF, .NET. Assim, encontrará coisas como táticas do Att\&ck, ou capacidades suspeitas como:
+**Capa** detecta **capacidades** potencialmente maliciosas em executáveis: PE, ELF, .NET. Assim, encontrará coisas como táticas do Att\&ck ou capacidades suspeitas, como:
 
 - verificar erro de OutputDebugString
 - executar como um serviço
 - criar processo
 
-Obtenha no [**Github repo**](https://github.com/mandiant/capa).
+Obtenha no [**repositório do Github**](https://github.com/mandiant/capa).
 
 ### IOCs
 
@@ -118,15 +118,15 @@ sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--sk
 
 ### NeoPI
 
-[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) é um script Python que usa uma variedade de **métodos estatísticos** para detectar conteúdo **ofuscado** e **criptografado** dentro de arquivos de texto/script. O objetivo pretendido do NeoPI é ajudar na **detecção de código de shell web oculto**.
+[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) é um script em Python que utiliza uma variedade de **métodos estatísticos** para detectar conteúdo **ofuscado** e **criptografado** dentro de arquivos de texto/script. O objetivo pretendido do NeoPI é ajudar na **detecção de código de web shell oculto**.
 
 ### **php-malware-finder**
 
-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) faz o seu melhor para detectar **código ofuscado**/**suspeito**, bem como arquivos que usam funções **PHP** frequentemente utilizadas em **malwares**/webshells.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) faz o seu melhor para detectar **código ofuscado**/**suspeito**, bem como arquivos que utilizam funções **PHP** frequentemente usadas em **malwares**/webshells.
 
 ### Apple Binary Signatures
 
-Ao verificar alguma **amostra de malware**, você deve sempre **verificar a assinatura** do binário, pois o **desenvolvedor** que o assinou pode já estar **relacionado** com **malware.**
+Ao verificar alguma **amostra de malware**, você deve sempre **verificar a assinatura** do binário, pois o **desenvolvedor** que a assinou pode já estar **relacionado** com **malware.**
 ```bash
 #Get signer
 codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@@ -141,7 +141,7 @@ spctl --assess --verbose /Applications/Safari.app
 
 ### Empilhamento de Arquivos
 
-Se você souber que alguma pasta contendo os **arquivos** de um servidor web foi **atualizada pela última vez em alguma data**. **Verifique** a **data** em que todos os **arquivos** no **servidor web foram criados e modificados** e se alguma data é **suspeita**, verifique esse arquivo.
+Se você sabe que alguma pasta contendo os **arquivos** de um servidor web foi **atualizada pela última vez em uma data específica**. **Verifique** a **data** em que todos os **arquivos** no **servidor web foram criados e modificados** e se alguma data é **suspeita**, verifique esse arquivo.
 
 ### Linhas de Base
 
@@ -149,6 +149,88 @@ Se os arquivos de uma pasta **não deveriam ter sido modificados**, você pode c
 
 ### Análise Estatística
 
-Quando as informações são salvas em logs, você pode **verificar estatísticas como quantas vezes cada arquivo de um servidor web foi acessado, pois um web shell pode ser um dos mais**.
+Quando as informações são salvas em logs, você pode **verificar estatísticas como quantas vezes cada arquivo de um servidor web foi acessado, pois um shell web pode ser um dos mais**.
+
+---
+
+## Deobfuscação de Fluxo de Controle Dinâmico (Despachantes JMP/CALL RAX)
+
+Famílias modernas de malware abusam fortemente da ofuscação do Grafo de Fluxo de Controle (CFG): em vez de um salto/chamada direto, eles computam o destino em tempo de execução e executam um `jmp rax` ou `call rax`. Um pequeno *despachante* (tipicamente nove instruções) define o alvo final dependendo das flags `ZF`/`CF` da CPU, quebrando completamente a recuperação estática do CFG.
+
+A técnica – demonstrada pelo carregador SLOW#TEMPEST – pode ser derrotada com um fluxo de trabalho em três etapas que depende apenas do IDAPython e do emulador de CPU Unicorn.
+
+### 1. Localizar cada salto / chamada indireta
+```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. Extraia o byte-code do despachante
+```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. Emule-o duas vezes com 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)
+```
+Execute `run(code,0,0)` e `run(code,1,1)` para obter os alvos dos ramos *falso* e *verdadeiro*.
+
+### 4. Repare um salto / chamada direta
+```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))
+```
+Após aplicar o patch, force o IDA a reanalisar a função para que o CFG completo e a saída do Hex-Rays sejam restaurados:
+```python
+import ida_auto, idaapi
+idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
+```
+### 5. Rotule chamadas de API indiretas
+
+Uma vez que o verdadeiro destino de cada `call rax` é conhecido, você pode informar ao IDA qual é, para que os tipos de parâmetros e nomes de variáveis sejam recuperados automaticamente:
+```python
+idc.set_callee_name(call_ea, resolved_addr, 0)  # IDA 8.3+
+```
+### Benefícios práticos
+
+* Restaura o CFG real → a descompilação passa de *10* linhas para milhares.
+* Permite referência cruzada de strings & xrefs, tornando a reconstrução de comportamento trivial.
+* Scripts são reutilizáveis: basta colocá-los em qualquer loader protegido pelo mesmo truque.
+
+---
+
+## Referências
+
+- [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}}