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

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)
+- [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)

src/generic-methodologies-and-resources/basic-forensic-methodology/adaptixc2-config-extraction-and-ttps.md

@@ -0,0 +1,243 @@
+# AdaptixC2 Configuration Extraction and TTPs
+
+{{#include ../../banners/hacktricks-training.md}}
+
+AdaptixC2 es un framework modular de código abierto de post‑exploitation/C2 con beacons Windows x86/x64 (EXE/DLL/service EXE/raw shellcode) y soporte BOF. Esta página documenta:
+- Cómo su configuración empaquetada con RC4 está incrustada y cómo extraerla de los beacons
+- Indicadores de red/perfil para listeners HTTP/SMB/TCP
+- TTPs comunes de loader y persistence observados en el mundo real, con enlaces a páginas de técnicas relevantes de Windows
+
+## Beacon profiles and fields
+
+AdaptixC2 soporta tres tipos principales de beacon:
+- BEACON_HTTP: web C2 con servers/ports/SSL configurables, method, URI, headers, user‑agent y un nombre de parameter personalizado
+- BEACON_SMB: C2 peer‑to‑peer por named‑pipe (intranet)
+- BEACON_TCP: sockets directos, opcionalmente con un marker prepended para ofuscar el inicio del protocolo
+
+Campos típicos de perfil observados en configs de beacon HTTP (después del descifrado):
+- 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) – usados para parsear los tamaños de respuesta
+- kill_date (u32), working_time (u32)
+- sleep_delay (u32), jitter_delay (u32)
+- listener_type (u32)
+- download_chunk_size (u32)
+
+Example default HTTP profile (from a beacon build):
+```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
+}
+```
+## Empaquetado de configuración cifrada y ruta de carga
+
+Cuando el operator hace clic en Create en el builder, AdaptixC2 inserta el perfil cifrado como un tail blob al final del beacon. El formato es:
+- 4 bytes: tamaño de la configuración (uint32, little‑endian)
+- N bytes: datos de configuración cifrados con RC4
+- 16 bytes: RC4 key
+
+El beacon loader copia la clave de 16 bytes desde el final y descifra con RC4 el bloque de N bytes en su lugar:
+```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);
+```
+Implicaciones prácticas:
+- Toda la estructura suele vivir dentro de la sección .rdata del PE.
+- La extracción es determinista: leer size, leer el ciphertext de ese tamaño, leer la clave de 16‑bytes colocada inmediatamente después, y luego RC4‑decrypt.
+
+## Flujo de extracción de configuración (defensores)
+
+Escribe un extractor que imite la lógica del beacon:
+1) Localiza el blob dentro del PE (comúnmente .rdata). Un enfoque pragmático es escanear .rdata en busca de una disposición plausible [size|ciphertext|16‑byte key] y probar con RC4.
+2) Leer los primeros 4 bytes → size (uint32 LE).
+3) Leer los siguientes N=size bytes → ciphertext.
+4) Leer los últimos 16 bytes → RC4 key.
+5) Descifrar con RC4 el ciphertext. A continuación, analizar el perfil en claro como:
+- u32/boolean scalars como se indicó arriba
+- length‑prefixed strings (u32 length seguido de bytes; puede estar presente un NUL final)
+- arrays: servers_count seguido por esa cantidad de pares [string, u32 port]
+
+Prueba de concepto mínima en Python (standalone, sin dependencias externas) que funciona con un blob pre‑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)
+```
+Consejos:
+- Cuando automatices, usa un PE parser para leer .rdata y luego aplica una ventana deslizante: para cada offset o, intenta size = u32(.rdata[o:o+4]), ct = .rdata[o+4:o+4+size], candidate key = next 16 bytes; RC4‑decrypt y verifica que los campos string se decodifiquen como UTF‑8 y que las longitudes sean razonables.
+- Parse SMB/TCP profiles siguiendo las mismas convenciones con prefijo de longitud.
+
+## Detección de red y búsqueda
+
+HTTP
+- Común: POST a URIs seleccionadas por el operador (p. ej., /uri.php, /endpoint/api)
+- Parámetro de cabecera personalizado usado para el beacon ID (p. ej., X‑Beacon‑Id, X‑App‑Id)
+- User‑agents que imitan Firefox 20 o builds contemporáneos de Chrome
+- Cadencia de polling visible vía sleep_delay/jitter_delay
+
+SMB/TCP
+- Listeners en named‑pipe SMB para C2 intranet cuando el egress web está restringido
+- Los beacons TCP pueden anteponer unos bytes antes del tráfico para ofuscar el inicio del protocolo
+
+## TTPs de loader y persistencia observados en incidentes
+
+Loaders de PowerShell en memoria
+- Descargan payloads Base64/XOR (Invoke‑RestMethod / WebClient)
+- Allocan memoria unmanaged, copian shellcode, cambian la protección a 0x40 (PAGE_EXECUTE_READWRITE) vía VirtualProtect
+- Ejecutan vía invocación dinámica .NET: Marshal.GetDelegateForFunctionPointer + delegate.Invoke()
+
+Consulta estas páginas para ejecución en memoria y consideraciones AMSI/ETW:
+
+{{#ref}}
+../../windows-hardening/av-bypass.md
+{{#endref}}
+
+Mecanismos de persistencia observados
+- Acceso directo en Startup folder (.lnk) para relanzar un loader al iniciar sesión
+- Registry Run keys (HKCU/HKLM ...\CurrentVersion\Run), frecuentemente con nombres que suenan benignos como "Updater" para iniciar loader.ps1
+- DLL search‑order hijack dejando msimg32.dll bajo %APPDATA%\Microsoft\Windows\Templates para procesos susceptibles
+
+Deep‑dives y comprobaciones de técnicas:
+
+{{#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}}
+
+Ideas para hunting
+- Transiciones RW→RX originadas por PowerShell: VirtualProtect a PAGE_EXECUTE_READWRITE dentro de powershell.exe
+- Patrones de invocación dinámica (GetDelegateForFunctionPointer)
+- .lnk en Startup del usuario o en carpetas Startup comunes
+- Run keys sospechosas (p. ej., "Updater"), y nombres de loaders como update.ps1/loader.ps1
+- Rutas de DLL escriturables por el usuario bajo %APPDATA%\Microsoft\Windows\Templates que contengan msimg32.dll
+
+## Notas sobre campos de OpSec
+
+- KillDate: timestamp después del cual el agente se auto‑expira
+- WorkingTime: horas en las que el agente debería estar activo para mezclarse con la actividad laboral
+
+Estos campos pueden usarse para clustering y para explicar periodos de inactividad observados.
+
+## YARA y pistas estáticas
+
+Unit 42 publicó YARA básica para beacons (C/C++ y Go) y constantes de API‑hashing de loaders. Considera complementar con reglas que busquen el layout [size|ciphertext|16‑byte‑key] cerca del final de PE .rdata y las cadenas del perfil HTTP por defecto.
+
+## 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}}

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

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Hojas de referencia forense
+## Hojas de referencia Forensics
 
 [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
 
@@ -14,7 +14,7 @@
 - [Intezer](https://analyze.intezer.com)
 - [Any.Run](https://any.run/)
 
-## Herramientas antivirus y de detección sin conexión
+## Herramientas Offline de Antivirus y Detección
 
 ### Yara
 
@@ -24,7 +24,7 @@ sudo apt-get install -y yara
 ```
 #### Preparar reglas
 
-Usa este script para descargar y fusionar todas las reglas yara de malware desde github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
+Usa este script para descargar y fusionar todas las reglas yara para malware desde github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9]\  
 Crea el directorio _**rules**_ y ejecútalo. Esto creará un archivo llamado _**malware_rules.yar**_ que contiene todas las reglas yara para malware.
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
@@ -57,25 +57,25 @@ clamscan folderpath #Scan the whole folder
 ```
 ### [Capa](https://github.com/mandiant/capa)
 
-**Capa** detecta **capacidades** potencialmente maliciosas en ejecutables: PE, ELF, .NET. Por lo tanto encontrará cosas como Att\&ck tactics, o capacidades sospechosas como:
+**Capa** detecta **capabilities** potencialmente maliciosas en ejecutables: PE, ELF, .NET. Así encontrará cosas como Att\&ck tactics, o capacidades sospechosas como:
 
 - comprobar error de OutputDebugString
-- ejecutarse como un servicio
+- ejecutarse como servicio
 - crear proceso
 
 Consíguelo en el [**Github repo**](https://github.com/mandiant/capa).
 
 ### IOCs
 
-IOC significa Indicator Of Compromise. Un IOC es un conjunto de **condiciones que identifican** algún software potencialmente no deseado o confirmado **malware**. Los Blue Teams usan este tipo de definiciones para **buscar este tipo de archivos maliciosos** en sus **sistemas** y **redes**.\
+IOC significa Indicator Of Compromise. Un IOC es un conjunto de **condiciones que identifican** algún software potencialmente no deseado o el **malware** confirmado. Los Blue Teams usan este tipo de definiciones para **buscar este tipo de archivos maliciosos** en sus **sistemas** y **redes**.\
-Compartir estas definiciones es muy útil, ya que cuando se identifica malware en un equipo y se crea un IOC para ese malware, otros Blue Teams pueden usarlo para identificar el malware más rápido.
+Compartir estas definiciones es muy útil: cuando se identifica malware en un equipo y se crea un IOC para ese malware, otros Blue Teams pueden usarlo para identificar el malware más rápido.
 
 Una herramienta para crear o modificar IOCs es [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
 Puedes usar herramientas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **buscar IOCs definidos en un dispositivo**.
 
 ### Loki
 
-[**Loki**](https://github.com/Neo23x0/Loki) es un scanner para Simple Indicators of Compromise.\
+[**Loki**](https://github.com/Neo23x0/Loki) es un scanner para Indicadores simples de compromiso.\
 La detección se basa en cuatro métodos de detección:
 ```
 1. File Name IOC
@@ -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/) es un escáner de malware para Linux publicado bajo la licencia GNU GPLv2, diseñado en torno a las amenazas que se enfrentan en entornos de hosting compartido. Utiliza datos de amenazas procedentes de sistemas de detección de intrusiones en el perímetro de la red para extraer malware que se está usando activamente en ataques y genera firmas para su detección. Además, los datos de amenazas también provienen de envíos de usuarios mediante la función LMD checkout y de recursos de la comunidad de malware.
+[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) es un escáner de malware para Linux publicado bajo la licencia GNU GPLv2, diseñado en torno a las amenazas que enfrentan los entornos de hosting compartido. Utiliza datos de amenazas de sistemas de detección de intrusiones en el borde de la red para extraer malware que se está usando activamente en ataques y genera firmas para su detección. Además, los datos de amenazas también se obtienen de envíos de usuarios mediante la LMD checkout feature y de recursos de la comunidad 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) es una herramienta que intentará encontrar cadenas ofuscadas dentro de ejecutables usando diferentes técnicas.
+[**FLOSS**](https://github.com/mandiant/flare-floss) es una herramienta que intentará encontrar obfuscated strings dentro de ejecutables usando diferentes técnicas.
 
 ### PEpper
 
-[PEpper ](https://github.com/Th3Hurrican3/PEpper) comprueba algunas cosas básicas dentro del ejecutable (datos binarios, entropía, URLs e IPs, algunas yara rules).
+[PEpper ](https://github.com/Th3Hurrican3/PEpper) comprueba algunas cosas básicas dentro del ejecutable (binary data, entropy, URLs and IPs, some yara rules).
 
 ### PEstudio
 
-[PEstudio](https://www.winitor.com/download) es una herramienta que permite obtener información de ejecutables de Windows como imports, exports, headers, pero también consultará virus total y encontrará posibles técnicas Att\&ck.
+[PEstudio](https://www.winitor.com/download) es una herramienta que permite obtener información de ejecutables Windows tales como imports, exports, headers, pero también comprobará virus total y encontrará posibles técnicas Att\&ck.
 
 ### Detect It Easy(DiE)
 
-[**DiE**](https://github.com/horsicq/Detect-It-Easy/) es una herramienta para detectar si un archivo está **cifrado** y también encontrar **packers**.
+[**DiE**](https://github.com/horsicq/Detect-It-Easy/) es una herramienta para detectar si un archivo está **encrypted** y también encontrar **packers**.
 
 ### NeoPI
 
-[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) es un script Python que utiliza una variedad de **métodos estadísticos** para detectar contenido **ofuscado** y **cifrado** dentro de archivos de texto/script. El propósito previsto de NeoPI es ayudar en la **detección de código de web shell oculto**.
+[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) es un script Python que usa una variedad de **statistical methods** para detectar contenido **obfuscated** y **encrypted** dentro de archivos de texto/script. El propósito de NeoPI es ayudar en la **detection of hidden web shell code**.
 
 ### **php-malware-finder**
 
-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) hace todo lo posible por detectar **ofuscado**/**código sospechoso** así como archivos que usan funciones **PHP** frecuentemente usadas en **malwares**/webshells.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) hace su mejor esfuerzo para detectar **obfuscated**/**dodgy code** así como archivos que usan funciones **PHP** que a menudo son usadas en **malwares**/webshells.
 
 ### Apple Binary Signatures
 
-Al analizar alguna **malware sample** siempre deberías **comprobar la firma** del binario, ya que el **desarrollador** que lo firmó puede ya estar **relacionado** con **malware.**
+Al revisar alguna **malware sample**, siempre debes **check the signature** del binario, ya que el **developer** que lo firmó podría ya estar **related** con **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
 
 ### File Stacking
 
-Si sabes que alguna carpeta que contiene los **archivos** de un **servidor web** fue **actualizada por última vez en cierta fecha**, **comprueba** la **fecha** en la que todos los **archivos** en el **servidor web** fueron creados y modificados; si alguna fecha es **sospechosa**, revisa ese archivo.
+Si sabes que una carpeta que contiene los **archivos** de un servidor web fue **actualizada por última vez en cierta fecha**. **Comprueba** la **fecha** en que todos los **archivos** en el **servidor web fueron creados y modificados** y si alguna fecha es **sospechosa**, revisa ese archivo.
 
 ### Baselines
 
@@ -149,13 +149,13 @@ Si los archivos de una carpeta **no deberían haber sido modificados**, puedes c
 
 ### Statistical Analysis
 
-Cuando la información se guarda en logs puedes **verificar estadísticas como cuántas veces se accedió a cada archivo del servidor web, ya que un web shell podría ser uno de los más**.
+Cuando la información se guarda en logs, puedes **consultar estadísticas**, por ejemplo cuántas veces se accedió a cada archivo del servidor web, ya que un web shell podría ser uno de los más accedidos.
 
 ---
 
-### Android: telemetría nativa dentro de la app (sin root)
+### Telemetría nativa in-app en Android (sin root)
 
-En Android, puedes instrumentar código nativo dentro del proceso de la app objetivo precargando una pequeña librería logger antes de que otras librerías JNI se inicialicen. Esto ofrece visibilidad temprana del comportamiento nativo sin hooks a nivel de sistema ni root. Un enfoque popular es SoTap: coloca libsotap.so para el ABI correcto dentro del APK e injerta una llamada System.loadLibrary("sotap") temprano (p. ej., en un static initializer o Application.onCreate), luego recoge logs desde rutas internas/externas o, como fallback, Logcat.
+En Android, puedes instrumentar código nativo dentro del proceso de la app objetivo precargando una pequeña librería logger antes de que otras libs JNI se inicialicen. Esto proporciona visibilidad temprana del comportamiento nativo sin hooks a nivel de sistema ni root. Un enfoque popular es SoTap: coloca libsotap.so para el ABI correcto dentro del APK e injerta una llamada System.loadLibrary("sotap") temprano (p. ej., inicializador estático o Application.onCreate), luego recoge los logs desde rutas internas/externas o, en su defecto, Logcat.
 
 See the Android native reversing page for setup details and log paths:
 
@@ -167,11 +167,11 @@ See the Android native reversing page for setup details and log paths:
 
 ## Deobfuscating Dynamic Control-Flow (JMP/CALL RAX Dispatchers)
 
-Modern malware families heavily abuse Control-Flow Graph (CFG) obfuscation: instead of a direct jump/call they compute the destination at run-time and execute a `jmp rax` or `call rax`.  A small *dispatcher* (typically nine instructions) sets the final target depending on the CPU `ZF`/`CF` flags, completely breaking static CFG recovery.
+Las familias de malware modernas abusan en gran medida de la obfuscación del Control-Flow Graph (CFG): en lugar de un salto/llamada directa calculan el destino en tiempo de ejecución y ejecutan un `jmp rax` o `call rax`. Un pequeño *dispatcher* (típicamente nueve instrucciones) establece el destino final dependiendo de las banderas de la CPU `ZF`/`CF`, rompiendo completamente la recuperación estática del CFG.
 
 The technique – showcased by the SLOW#TEMPEST loader – can be defeated with a three-step workflow that only relies on IDAPython and the Unicorn CPU emulator.
 
-### 1. Localiza todos los saltos/llamadas indirectos
+### 1. Localiza cada salto/call indirecto
 ```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. Extraer el dispatcher byte-code
+### 2. Extraer el byte-code del 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)
 ```
-Ejecuta `run(code,0,0)` y `run(code,1,1)` para obtener los objetivos de las ramas *falsa* y *verdadera*.
+Ejecute `run(code,0,0)` y `run(code,1,1)` para obtener los destinos de las ramas *false* y *true*.
 
-### 4. Parchear de nuevo un salto/llamada directa
+### 4. Parchear de nuevo un jump / call
 ```python
 import struct, ida_bytes
 
@@ -222,7 +222,7 @@ 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))
 ```
-Después de parchear, fuerza a IDA a volver a analizar la función para que se restaure el CFG completo y la salida de Hex-Rays:
+Después del patching, fuerza a IDA a reanalizar la función para que se restablezcan el CFG completo y la salida de Hex-Rays:
 ```python
 import ida_auto, idaapi
 idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
@@ -236,14 +236,23 @@ idc.set_callee_name(call_ea, resolved_addr, 0)  # IDA 8.3+
 ### Beneficios prácticos
 
 * Restaura el CFG real → la decompilación pasa de *10* líneas a miles.
-* Habilita string-cross-reference & xrefs, haciendo la reconstrucción del comportamiento trivial.
+* Permite string-cross-reference & xrefs, haciendo la reconstrucción del comportamiento trivial.
-* Los scripts son reutilizables: colócalos en cualquier loader protegido por el mismo truco.
+* Los scripts son reutilizables: insértalos en cualquier loader protegido por el mismo truco.
 
 ---
 
-## References
+## AdaptixC2: Extracción de configuración y TTPs
+
+Ver la página dedicada:
+
+{{#ref}}
+adaptixc2-config-extraction-and-ttps.md
+{{#endref}}
+
+## Referencias
 
 - [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 ligero de comportamiento 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}}