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

2025-10-10 18:36:50 +00:00 · 2025-09-30 09:11:08 +00:00 · 2025-09-30 09:11:08 +00:00 · 8a50d0bba5
commit 8a50d0bba5
parent 19e1775dfe
3 changed files with 295 additions and 42 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -37,6 +37,7 @@
  - [Mobile Phishing Malicious Apps](generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md)
  - [Phishing Files & Documents](generic-methodologies-and-resources/phishing-methodology/phishing-documents.md)
 - [Basic Forensic Methodology](generic-methodologies-and-resources/basic-forensic-methodology/README.md)
+  - [Adaptixc2 Config Extraction And Ttps](generic-methodologies-and-resources/basic-forensic-methodology/adaptixc2-config-extraction-and-ttps.md)
  - [Baseline Monitoring](generic-methodologies-and-resources/basic-forensic-methodology/file-integrity-monitoring.md)
  - [Anti-Forensic Techniques](generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md)
  - [Docker Forensics](generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.md)
@ -130,6 +131,7 @@
    - [Seccomp](linux-hardening/privilege-escalation/docker-security/seccomp.md)
    - [Weaponizing Distroless](linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md)
  - [Escaping from Jails](linux-hardening/privilege-escalation/escaping-from-limited-bash.md)
+  - [Posix Cpu Timers Toctou Cve 2025 38352](linux-hardening/privilege-escalation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
  - [euid, ruid, suid](linux-hardening/privilege-escalation/euid-ruid-suid.md)
  - [Interesting Groups - Linux Privesc](linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md)
    - [lxd/lxc Group - Privilege escalation](linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md)
@ -771,7 +773,7 @@
    - [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md)
  - [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
  - [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md)
-  - [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md)
+  - [ROP & JOP](binary-exploitation/rop-return-oriented-programing/README.md)
  - [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md)
  - [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md)
  - [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md)
@ -840,6 +842,7 @@
  - [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md)
  - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md)
 - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md)
+- [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
 - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
 - [iOS Exploiting](binary-exploitation/ios-exploiting/README.md)
  - [ios CVE-2020-27950-mach_msg_trailer_t](binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md)
@ -937,6 +940,4 @@
 - [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md)
 - [Post Exploitation](todo/post-exploitation.md)
 - [Investment Terms](todo/investment-terms.md)
- [Cookies Policy](todo/cookies-policy.md)
-
-  - [Posix Cpu Timers Toctou Cve 2025 38352](linux-hardening/privilege-escalation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
+- [Cookies Policy](todo/cookies-policy.md)
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/adaptixc2-config-extraction-and-ttps.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/adaptixc2-config-extraction-and-ttps.md
@ -0,0 +1,243 @@
+# Extração de Configuração do AdaptixC2 e TTPs
+
+{{#include ../../banners/hacktricks-training.md}}
+
+AdaptixC2 é um framework modular e open‑source de post‑exploitation/C2 com beacons Windows x86/x64 (EXE/DLL/service EXE/raw shellcode) e suporte a BOF. Esta página documenta:
+- Como a sua configuração empacotada com RC4 é embutida e como extraí‑la dos beacons
+- Indicadores de rede/perfil para listeners HTTP/SMB/TCP
+- TTPs comuns de loader e persistência observados no mundo real, com links para páginas de técnicas relevantes do Windows
+
+## Perfis e campos de beacon
+
+AdaptixC2 suporta três tipos primários de beacon:
+- BEACON_HTTP: web C2 com servidores/portas/SSL configuráveis, method, URI, headers, user‑agent, e um nome de parâmetro customizado
+- BEACON_SMB: named‑pipe peer‑to‑peer C2 (intranet)
+- BEACON_TCP: sockets diretos, opcionalmente com um marcador pré‑inserido para ofuscar o início do protocolo
+
+Campos típicos de perfil observados em configs de beacon HTTP (após descriptografia):
+- agent_type (u32)
+- use_ssl (bool)
+- servers_count (u32), servers (array of strings), ports (array of u32)
+- http_method, uri, parameter, user_agent, http_headers (length‑prefixed strings)
+- ans_pre_size (u32), ans_size (u32) – usado para analisar os tamanhos das respostas
+- kill_date (u32), working_time (u32)
+- sleep_delay (u32), jitter_delay (u32)
+- listener_type (u32)
+- download_chunk_size (u32)
+
+Exemplo de perfil HTTP padrão (de um build de beacon):
+```json
+{
+"agent_type": 3192652105,
+"use_ssl": true,
+"servers_count": 1,
+"servers": ["172.16.196.1"],
+"ports": [4443],
+"http_method": "POST",
+"uri": "/uri.php",
+"parameter": "X-Beacon-Id",
+"user_agent": "Mozilla/5.0 (Windows NT 6.2; rv:20.0) Gecko/20121202 Firefox/20.0",
+"http_headers": "\r\n",
+"ans_pre_size": 26,
+"ans_size": 47,
+"kill_date": 0,
+"working_time": 0,
+"sleep_delay": 2,
+"jitter_delay": 0,
+"listener_type": 0,
+"download_chunk_size": 102400
+}
+```
+Perfil HTTP malicioso observado (ataque real):
+```json
+{
+"agent_type": 3192652105,
+"use_ssl": true,
+"servers_count": 1,
+"servers": ["tech-system[.]online"],
+"ports": [443],
+"http_method": "POST",
+"uri": "/endpoint/api",
+"parameter": "X-App-Id",
+"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.6167.160 Safari/537.36",
+"http_headers": "\r\n",
+"ans_pre_size": 26,
+"ans_size": 47,
+"kill_date": 0,
+"working_time": 0,
+"sleep_delay": 4,
+"jitter_delay": 0,
+"listener_type": 0,
+"download_chunk_size": 102400
+}
+```
+## Empacotamento da configuração criptografada e caminho de carregamento
+
+Quando o operador clica em Criar no builder, o AdaptixC2 incorpora o perfil criptografado como um blob final no beacon. O formato é:
+- 4 bytes: tamanho da configuração (uint32, little‑endian)
+- N bytes: dados de configuração criptografados com RC4
+- 16 bytes: chave RC4
+
+O beacon loader copia a chave de 16‑byte do final e descriptografa com RC4 o bloco de N‑byte no próprio local:
+```c
+ULONG profileSize = packer->Unpack32();
+this->encrypt_key = (PBYTE) MemAllocLocal(16);
+memcpy(this->encrypt_key, packer->data() + 4 + profileSize, 16);
+DecryptRC4(packer->data()+4, profileSize, this->encrypt_key, 16);
+```
+Implicações práticas:
+- Toda a estrutura frequentemente vive dentro da seção PE .rdata.
+- A extração é determinística: leia o size, leia o ciphertext desse tamanho, leia a 16‑byte key colocada imediatamente depois, e então RC4‑decrypt.
+
+## Fluxo de extração de configuração (defensores)
+
+Implemente um extractor que imite a beacon logic:
+1) Localize o blob dentro do PE (comumente .rdata). Uma abordagem pragmática é escanear .rdata em busca de um layout plausível [size|ciphertext|16‑byte key] e tentar RC4.
+2) Leia os primeiros 4 bytes → size (uint32 LE).
+3) Leia os próximos N=size bytes → ciphertext.
+4) Leia os últimos 16 bytes → RC4 key.
+5) RC4‑decrypt o ciphertext. Em seguida, parse o plain profile como:
+- u32/boolean scalars conforme indicado acima
+- length‑prefixed strings (u32 length followed by bytes; trailing NUL can be present)
+- arrays: servers_count seguido por esse número de pares [string, u32 port]
+
+Prova de conceito mínima em Python (standalone, no external deps) que funciona com um blob pré-extraído:
+```python
+import struct
+from typing import List, Tuple
+
+def rc4(key: bytes, data: bytes) -> bytes:
+S = list(range(256))
+j = 0
+for i in range(256):
+j = (j + S[i] + key[i % len(key)]) & 0xFF
+S[i], S[j] = S[j], S[i]
+i = j = 0
+out = bytearray()
+for b in data:
+i = (i + 1) & 0xFF
+j = (j + S[i]) & 0xFF
+S[i], S[j] = S[j], S[i]
+K = S[(S[i] + S[j]) & 0xFF]
+out.append(b ^ K)
+return bytes(out)
+
+class P:
+def __init__(self, buf: bytes):
+self.b = buf; self.o = 0
+def u32(self) -> int:
+v = struct.unpack_from('<I', self.b, self.o)[0]; self.o += 4; return v
+def u8(self) -> int:
+v = self.b[self.o]; self.o += 1; return v
+def s(self) -> str:
+L = self.u32(); s = self.b[self.o:self.o+L]; self.o += L
+return s[:-1].decode('utf-8','replace') if L and s[-1] == 0 else s.decode('utf-8','replace')
+
+def parse_http_cfg(plain: bytes) -> dict:
+p = P(plain)
+cfg = {}
+cfg['agent_type']    = p.u32()
+cfg['use_ssl']       = bool(p.u8())
+n                    = p.u32()
+cfg['servers']       = []
+cfg['ports']         = []
+for _ in range(n):
+cfg['servers'].append(p.s())
+cfg['ports'].append(p.u32())
+cfg['http_method']   = p.s()
+cfg['uri']           = p.s()
+cfg['parameter']     = p.s()
+cfg['user_agent']    = p.s()
+cfg['http_headers']  = p.s()
+cfg['ans_pre_size']  = p.u32()
+cfg['ans_size']      = p.u32() + cfg['ans_pre_size']
+cfg['kill_date']     = p.u32()
+cfg['working_time']  = p.u32()
+cfg['sleep_delay']   = p.u32()
+cfg['jitter_delay']  = p.u32()
+cfg['listener_type'] = 0
+cfg['download_chunk_size'] = 0x19000
+return cfg
+
+# Usage (when you have [size|ciphertext|key] bytes):
+# blob = open('blob.bin','rb').read()
+# size = struct.unpack_from('<I', blob, 0)[0]
+# ct   = blob[4:4+size]
+# key  = blob[4+size:4+size+16]
+# pt   = rc4(key, ct)
+# cfg  = parse_http_cfg(pt)
+```
+Tips:
+- When automating, use a PE parser to read .rdata then apply a sliding window: for each offset o, try size = u32(.rdata[o:o+4]), ct = .rdata[o+4:o+4+size], candidate key = next 16 bytes; RC4‑decrypt and check that string fields decode as UTF‑8 and lengths are sane.
+- Parse SMB/TCP profiles by following the same length‑prefixed conventions.
+
+## Network fingerprinting and hunting
+
+HTTP
+- Comum: POST para URIs selecionadas pelo operador (e.g., /uri.php, /endpoint/api)
+- Parâmetro de header customizado usado para beacon ID (e.g., X‑Beacon‑Id, X‑App‑Id)
+- User‑agents imitando Firefox 20 ou builds contemporâneos do Chrome
+- Cadência de polling visível via sleep_delay/jitter_delay
+
+SMB/TCP
+- SMB named‑pipe listeners para C2 de intranet onde o web egress é restrito
+- TCP beacons podem prefixar alguns bytes antes do tráfego para ofuscar o início do protocolo
+
+## Loader and persistence TTPs seen in incidents
+
+In‑memory PowerShell loaders
+- Fazem download de payloads Base64/XOR (Invoke‑RestMethod / WebClient)
+- Alocam memória unmanaged, copiam shellcode, trocam proteção para 0x40 (PAGE_EXECUTE_READWRITE) via VirtualProtect
+- Executam via invocação dinâmica .NET: Marshal.GetDelegateForFunctionPointer + delegate.Invoke()
+
+Check these pages for in‑memory execution and AMSI/ETW considerations:
+
+{{#ref}}
+../../windows-hardening/av-bypass.md
+{{#endref}}
+
+Persistence mechanisms observed
+- Atalho na pasta Startup (.lnk) para relançar um loader no logon
+- Chaves Run do Registry (HKCU/HKLM ...\CurrentVersion\Run), frequentemente com nomes que soam benignos como "Updater" para iniciar loader.ps1
+- DLL search‑order hijack colocando msimg32.dll em %APPDATA%\Microsoft\Windows\Templates para processos suscetíveis
+
+Technique deep‑dives and checks:
+
+{{#ref}}
+../../windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
+{{#endref}}
+
+{{#ref}}
+../../windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
+{{#endref}}
+
+Hunting ideas
+- PowerShell gerando transições RW→RX: VirtualProtect para PAGE_EXECUTE_READWRITE dentro de powershell.exe
+- Padrões de invocação dinâmica (GetDelegateForFunctionPointer)
+- .lnk de Startup sob pastas Startup do usuário ou comuns
+- Chaves Run suspeitas (e.g., "Updater"), e nomes de loader como update.ps1/loader.ps1
+- Caminhos de DLL graváveis por usuário sob %APPDATA%\Microsoft\Windows\Templates contendo msimg32.dll
+
+## Notes on OpSec fields
+
+- KillDate: timestamp após o qual o agent expira automaticamente
+- WorkingTime: horas em que o agent deve estar ativo para se misturar com atividade empresarial
+
+Esses campos podem ser usados para agrupamento e para explicar períodos silenciosos observados.
+
+## YARA and static leads
+
+Unit 42 publicou YARA básicas para beacons (C/C++ and Go) e constantes de hashing de API do loader. Considere complementar com regras que procurem pelo layout [size|ciphertext|16‑byte‑key] próximo ao final de PE .rdata e pelas default HTTP profile strings.
+
+## References
+
+- [AdaptixC2: A New Open-Source Framework Leveraged in Real-World Attacks (Unit 42)](https://unit42.paloaltonetworks.com/adaptixc2-post-exploitation-framework/)
+- [AdaptixC2 GitHub](https://github.com/Adaptix-Framework/AdaptixC2)
+- [Adaptix Framework Docs](https://adaptix-framework.gitbook.io/adaptix-framework)
+- [Marshal.GetDelegateForFunctionPointer – Microsoft Docs](https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.getdelegateforfunctionpointer)
+- [VirtualProtect – Microsoft Docs](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect)
+- [Memory protection constants – Microsoft Docs](https://learn.microsoft.com/en-us/windows/win32/memory/memory-protection-constants)
+- [Invoke-RestMethod – PowerShell](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/invoke-restmethod)
+- [MITRE ATT&CK T1547.001 – Registry Run Keys/Startup Folder](https://attack.mitre.org/techniques/T1547/001/)
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md
@ -24,8 +24,8 @@ sudo apt-get install -y yara
 ```
 #### Preparar regras

-Use este script para baixar e mesclar todas as regras yara de malware do github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
-Crie o diretório _**rules**_ e execute-o. Isso criará um arquivo chamado _**malware_rules.yar**_ que contém todas as regras yara de malware.
+Use este script para baixar e mesclar todas as yara malware rules do github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
+Crie o diretório _**rules**_ e execute-o. Isso criará um arquivo chamado _**malware_rules.yar**_ que contém todas as yara rules para malware.
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
 mkdir rules
@ -57,26 +57,26 @@ clamscan folderpath #Scan the whole folder
 ```
 ### [Capa](https://github.com/mandiant/capa)

-**Capa** detecta potencialmente **capacidades** maliciosas em executáveis: PE, ELF, .NET. Assim, encontrará coisas como Att\&ck táticas, ou capacidades suspeitas como:
+**Capa** detecta potencialmente maliciosas **capabilities** em executáveis: PE, ELF, .NET. Assim, irá encontrar coisas como Att\&ck tactics, ou capacidades suspeitas como:

- verificar erro OutputDebugString
- executar como um serviço
- criar processo
+- check for OutputDebugString error
+- run as a service
+- create process

-Get it int he [**Github repo**](https://github.com/mandiant/capa).
+Obtenha-o no [**Github repo**](https://github.com/mandiant/capa).

 ### IOCs

-IOC significa Indicator Of Compromise. Um IOC é um conjunto de **condições que identificam** algum software potencialmente indesejado ou **malware** confirmado. As Blue Teams usam esse tipo de definição para **procurar por esse tipo de arquivos maliciosos** em seus **sistemas** e **redes**.\
-Compartilhar essas definições é muito útil, pois quando um malware é identificado em um computador e um IOC para esse malware é criado, outras Blue Teams podem usá‑lo para identificar o malware mais rapidamente.
+IOC significa Indicador de Comprometimento. Um IOC é um conjunto de **condições que identificam** algum software potencialmente indesejado ou confirmado **malware**. Blue Teams usam esse tipo de definição para **procurar por esse tipo de arquivos maliciosos** em seus **sistemas** e **redes**.\
+Compartilhar essas definições é muito útil, pois quando malware é identificado em um computador e um IOC para esse malware é criado, outras Blue Teams podem usá-lo para identificar o malware mais rapidamente.

 Uma ferramenta para criar ou modificar IOCs é [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
-Você pode usar ferramentas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **buscar por IOCs definidos em um dispositivo**.
+Você pode usar ferramentas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **buscar IOCs definidos em um dispositivo**.

 ### Loki

-[**Loki**](https://github.com/Neo23x0/Loki) é um scanner para Simple Indicators of Compromise.\
-A detecção é baseada em quatro métodos de detecção:
+[**Loki**](https://github.com/Neo23x0/Loki) é um scanner para Indicadores Simples de Comprometimento.\
+A detecção baseia-se em quatro métodos de detecção:
 ```
 1. File Name IOC
 Regex match on full file path/name
@ -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/) é um scanner de malware para Linux lançado sob a licença GNU GPLv2, projetado para as ameaças enfrentadas em ambientes de hospedagem compartilhada. Ele utiliza dados de ameaça de sistemas de detecção de intrusão na borda da rede para extrair malware que está sendo usado ativamente em ataques e gerar assinaturas para detecção. Além disso, os dados de ameaça também são derivados de envios de usuários com o recurso LMD checkout e de recursos da comunidade de malware.
+[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) é um scanner de malware para Linux lançado sob a licença GNU GPLv2, projetado para as ameaças enfrentadas em ambientes de hospedagem compartilhada. Ele usa dados de ameaça de sistemas de detecção de intrusão de borda de rede para extrair malware que está sendo usado ativamente em ataques e gera assinaturas para detecção. Além disso, dados de ameaça também são derivados de submissões de usuários com o recurso checkout do LMD e de recursos da comunidade de malware.

 ### rkhunter

@ -102,31 +102,31 @@ sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--sk
 ```
 ### FLOSS

-[**FLOSS**](https://github.com/mandiant/flare-floss) é uma ferramenta que tenta encontrar obfuscated strings dentro de executáveis usando diferentes técnicas.
+[**FLOSS**](https://github.com/mandiant/flare-floss) é uma ferramenta que tenta encontrar strings ofuscadas dentro de executáveis usando diferentes técnicas.

 ### PEpper

-[PEpper ](https://github.com/Th3Hurrican3/PEpper) verifica alguns aspetos básicos dentro do executável (binary data, entropy, URLs and IPs, some yara rules).
+[PEpper ](https://github.com/Th3Hurrican3/PEpper) verifica algumas coisas básicas dentro do executável (dados binários, entropia, URLs e IPs, algumas yara rules).

 ### PEstudio

-[PEstudio](https://www.winitor.com/download) é uma ferramenta que permite obter informação de executáveis Windows, como imports, exports, headers, mas também verifica VirusTotal e encontra potenciais Att\&ck techniques.
+[PEstudio](https://www.winitor.com/download) é uma ferramenta que permite obter informações de executáveis Windows, como imports, exports, headers, mas também verifica virus total e encontra potenciais técnicas Att\&ck.

 ### Detect It Easy(DiE)

-[**DiE**](https://github.com/horsicq/Detect-It-Easy/) é uma ferramenta para detectar se um ficheiro está **encrypted** e também para encontrar **packers**.
+[**DiE**](https://github.com/horsicq/Detect-It-Easy/) é uma ferramenta para detectar se um arquivo está **encrypted** e também encontrar **packers**.

 ### NeoPI

-[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) é um script Python que usa uma variedade de **métodos estatísticos** para detectar conteúdo **obfuscated** e **encrypted** em ficheiros de texto/script. O objetivo do NeoPI é auxiliar na **detecção de código web shell oculto**.
+[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is um script Python que utiliza uma variedade de **métodos estatísticos** para detectar conteúdo **ofuscado** e **criptografado** em arquivos de texto/script. O objetivo do NeoPI é auxiliar na **detecção de hidden web shell code**.

 ### **php-malware-finder**

-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) faz o seu melhor para detectar **obfuscated**/**dodgy code** assim como ficheiros que usam funções **PHP** frequentemente usadas em **malwares**/webshells.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) faz o possível para detectar código **ofuscado**/**dodgy code**, assim como arquivos que usam funções **PHP** frequentemente usadas em **malwares**/webshells.

 ### Apple Binary Signatures

-Ao analisar uma **malware sample** deve sempre **verificar a assinatura** do binário, pois o **developer** que a assinou pode já estar **related** com **malware.**
+Ao verificar alguma **malware sample** você deve sempre **checar a assinatura** do binário, pois o **developer** que a assinou pode já estar **relacionado** com **malware.**
 ```bash
 #Get signer
 codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -139,25 +139,25 @@ spctl --assess --verbose /Applications/Safari.app
 ```
 ## Técnicas de Detecção

-### File Stacking
+### 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 for **suspeita**, analise esse arquivo.
+Se você sabe que alguma pasta contendo os **arquivos** de um servidor web foi **atualizada pela última vez em certa data**, **verifique** a **data** em que todos os **arquivos** no **servidor web foram criados e modificados** e, se alguma data for **suspeita**, investigue esse arquivo.

 ### Baselines

-Se os arquivos de uma pasta **não deveriam ter sido modificados**, você pode calcular o **hash** dos **arquivos originais** da pasta e **compará-los** com os atuais. Qualquer coisa modificada será **suspeita**.
+Se os arquivos de uma pasta **não deveriam ter sido modificados**, você pode calcular o **hash** dos **arquivos originais** da pasta e **compará-los** com os **atuais**. Qualquer coisa modificada será **suspeita**.

-### Statistical Analysis
+### Análise Estatística

-Quando a informação é salva em logs, você pode **verificar estatísticas**, como quantas vezes cada arquivo de um servidor web foi acessado — já que um web shell pode ser um dos mais acessados.
+Quando a informação é salva em logs, você pode **verificar estatísticas**, como quantas vezes cada arquivo do servidor web foi acessado — um web shell pode ser um dos mais acessados.

 ---

 ### Telemetria nativa in-app no Android (sem root)

-No Android, você pode instrumentar código nativo dentro do processo do app alvo pré-carregando uma pequena biblioteca de logger antes que as outras libs JNI inicializem. Isso fornece visibilidade precoce do comportamento nativo sem hooks a nível de sistema ou root. Uma abordagem popular é SoTap: coloque o libsotap.so para a ABI correta dentro do APK e injete uma chamada System.loadLibrary("sotap") cedo (por exemplo, inicializador estático ou Application.onCreate), então colete logs de caminhos internos/externos ou usando Logcat como fallback.
+No Android, você pode instrumentar código nativo dentro do processo do app alvo pré-carregando uma pequena biblioteca de logger antes que outras libs JNI inicializem. Isso fornece visibilidade precoce do comportamento nativo sem hooks em nível de sistema ou root. Uma abordagem popular é SoTap: coloque libsotap.so para o ABI correto dentro do APK e injete uma chamada System.loadLibrary("sotap") cedo (por exemplo, inicializador estático ou Application.onCreate), depois colete logs de caminhos internos/externos ou use Logcat como fallback.

-Veja a página de reversing nativo para Android para detalhes de configuração e caminhos de log:
+See the Android native reversing page for setup details and log paths:

 {{#ref}}
 ../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
@ -165,13 +165,13 @@ Veja a página de reversing nativo para Android para detalhes de configuração

 ---

-## Desofuscação do Fluxo de Controle Dinâmico (JMP/CALL RAX Dispatchers)
+## Desofuscação de Fluxo de Controle Dinâmico (JMP/CALL RAX Dispatchers)

-As famílias de malware modernas abusam fortemente da ofuscação do Grafo de Fluxo de Controle (CFG): em vez de um jump/call direto, elas calculam o destino em tempo de execução e executam um `jmp rax` ou `call rax`. Um pequeno *dispatcher* (tipicamente nove instruções) define o alvo final dependendo das flags `ZF`/`CF` da CPU, quebrando completamente a recuperação estática do CFG.
+Famílias modernas de malware abusam fortemente da obfuscação do Control-Flow Graph (CFG): em vez de um jump/call direto, elas calculam o destino em tempo de execução e executam um `jmp rax` ou `call rax`. Um pequeno *dispatcher* (tipicamente nove instruções) define o alvo final dependendo das flags da CPU `ZF`/`CF`, quebrando completamente a recuperação estática do CFG.

 A técnica — demonstrada pelo loader SLOW#TEMPEST — pode ser derrotada com um fluxo de trabalho em três passos que depende apenas de IDAPython e do emulador de CPU Unicorn.

-### 1. Localizar cada indirect jump / call
+### 1. Localize cada jump / call indireto
 ```python
 import idautils, idc

@ -180,7 +180,7 @@ 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 dispatcher
+### 2. Extrair o byte-code do dispatcher
 ```python
 import idc

@ -211,9 +211,9 @@ 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 *false* e *true* branch targets.
+Execute `run(code,0,0)` e `run(code,1,1)` para obter os alvos de branch *false* e *true*.

-### 4. Patch back a direct jump / call
+### 4. Patch back um jump / call direto
 ```python
 import struct, ida_bytes

@ -227,23 +227,32 @@ Após patching, force o IDA a reanalisar a função para que o CFG completo e a
 import ida_auto, idaapi
 idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
 ```
-### 5. Rotular chamadas indiretas de API
+### 5. Rotular chamadas de API indiretas

-Uma vez que o destino real de cada `call rax` seja conhecido, você pode informar o IDA sobre ele para que os tipos de parâmetros & nomes de variáveis sejam recuperados automaticamente:
+Uma vez que o destino real de cada `call rax` seja conhecido, você pode dizer ao IDA qual é para que os tipos de parâmetros & nomes das 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 decompilação passa de *10* linhas para milhares.
-* Habilita string-cross-reference & xrefs, tornando a reconstrução do comportamento trivial.
+* Restaura o CFG real → a descompilação passa de *10* linhas para milhares.
+* Permite string-cross-reference & xrefs, tornando a reconstrução do comportamento trivial.
 * Scripts são reutilizáveis: coloque-os em qualquer loader protegido pelo mesmo truque.

 ---

+## AdaptixC2: Extração de Configuração e TTPs
+
+Veja a página dedicada:
+
+{{#ref}}
+adaptixc2-config-extraction-and-ttps.md
+{{#endref}}
+
 ## Referências

 - [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)
+- SoTap: Registrador leve de comportamento in-app JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
+- [Unit42 – AdaptixC2: A New Open-Source Framework Leveraged in Real-World Attacks](https://unit42.paloaltonetworks.com/adaptixc2-post-exploitation-framework/)

 {{#include ../../banners/hacktricks-training.md}}