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 Konfigurations-Extraktion und TTPs
+
+{{#include ../../banners/hacktricks-training.md}}
+
+AdaptixC2 ist ein modulares, Open‑Source Post‑Exploitation/C2‑Framework mit Windows x86/x64 beacons (EXE/DLL/service EXE/raw shellcode) und BOF‑Support. Diese Seite dokumentiert:
+- Wie seine RC4‑verpackte Konfiguration eingebettet ist und wie man sie aus Beacons extrahiert
+- Netzwerk-/Profilindikatoren für HTTP/SMB/TCP Listener
+- Häufige Loader- und Persistence‑TTPs, die in der Wildnis beobachtet wurden, mit Links zu relevanten Windows‑Technikseiten
+
+## Beacon-Profile und Felder
+
+AdaptixC2 unterstützt drei Haupt‑Beacon‑Typen:
+- BEACON_HTTP: web C2 mit konfigurierbaren Servern/Ports/SSL, Methode, URI, Headern, User‑Agent und einem benutzerdefinierten Parameternamen
+- BEACON_SMB: named‑pipe Peer‑to‑Peer C2 (Intranet)
+- BEACON_TCP: direkte Sockets, optional mit einem vorangestellten Marker, um den Protokollstart zu verschleiern
+
+Typische Profilfelder, die in HTTP‑Beacon‑Konfigurationen beobachtet werden (nach der Entschlüsselung):
+- 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) – used to parse response sizes
+- 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
+}
+```
+Beobachtetes bösartiges HTTP-Profil (echter Angriff):
+```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
+}
+```
+## Verschlüsselte Konfigurationsverpackung und Ladepfad
+
+Wenn der Operator im builder auf Create klickt, bettet AdaptixC2 das verschlüsselte Profil als tail blob in den beacon ein. Das Format ist:
+- 4 Bytes: Größe der Konfiguration (uint32, little‑endian)
+- N Bytes: RC4‑verschlüsselte Konfigurationsdaten
+- 16 Bytes: RC4‑Schlüssel
+
+Der beacon loader kopiert den 16‑Byte‑Schlüssel vom Ende und RC4‑entschlüsselt den N‑Byte‑Block an Ort und Stelle:
+```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);
+```
+Practical implications:
+- Die gesamte Struktur liegt oft im PE-.rdata-Abschnitt.
+- Die Extraktion ist deterministisch: Größe lesen, den ciphertext dieser Größe lesen, den unmittelbar danach platzierten 16‑Byte‑Key lesen und dann mit RC4 entschlüsseln.
+
+## Workflow zur Konfigurations-Extraktion (Verteidiger)
+
+Schreibe einen Extractor, der die beacon-Logik nachahmt:
+1) Finde den Blob innerhalb der PE (häufig .rdata). Ein pragmatischer Ansatz ist, .rdata nach einem plausiblen [size|ciphertext|16‑byte key]-Layout zu scannen und RC4 zu versuchen.
+2) Lese die ersten 4 Bytes → size (uint32 LE).
+3) Lese die nächsten N=size Bytes → ciphertext.
+4) Lese die letzten 16 Bytes → RC4 key.
+5) RC4‑entschlüssele den ciphertext. Dann parse das plain profile als:
+- u32/boolean scalars wie oben beschrieben
+- length‑prefixed strings (u32 length gefolgt von Bytes; trailing NUL kann vorhanden sein)
+- arrays: servers_count gefolgt von entsprechend vielen [string, u32 port]-Paaren
+
+Minimaler Python proof‑of‑concept (standalone, ohne externe Abhängigkeiten), das mit einem vorab extrahierten Blob funktioniert:
+```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:
+- Beim Automatisieren einen PE‑Parser verwenden, .rdata auslesen und ein Sliding‑Window anwenden: für jeden Offset o versuche size = u32(.rdata[o:o+4]), ct = .rdata[o+4:o+4+size], candidate key = next 16 bytes; RC4‑decrypt und prüfen, ob String‑Felder als UTF‑8 decodieren und Längen plausibel sind.
+- SMB/TCP‑Profile nach denselben length‑prefixed Konventionen parsen.
+
+## Network fingerprinting and hunting
+
+HTTP
+- Common: POST an vom Operator ausgewählte URIs (z. B. /uri.php, /endpoint/api)
+- Custom header parameter verwendet für beacon ID (z. B. X‑Beacon‑Id, X‑App‑Id)
+- User‑agents, die Firefox 20 oder zeitgenössische Chrome‑Builds nachahmen
+- Polling‑Cadence sichtbar via sleep_delay/jitter_delay
+
+SMB/TCP
+- SMB named‑pipe Listener für intranet C2, wenn Web‑Egress eingeschränkt ist
+- TCP‑Beacons können einige Bytes vor dem Traffic voranstellen, um den Protokollstart zu verschleiern
+
+## Loader and persistence TTPs seen in incidents
+
+In‑memory PowerShell loaders
+- Laden Base64/XOR Payloads (Invoke‑RestMethod / WebClient)
+- Unmanaged Memory allokieren, Shellcode kopieren, Protection via VirtualProtect auf 0x40 (PAGE_EXECUTE_READWRITE) setzen
+- Ausführen über .NET dynamic invocation: 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
+- Startup‑Ordner Shortcut (.lnk), um einen Loader beim Logon neu zu starten
+- Registry Run Keys (HKCU/HKLM ...\CurrentVersion\Run), oft mit harmlos klingenden Namen wie "Updater", um loader.ps1 zu starten
+- DLL Search‑Order Hijack durch Ablegen von msimg32.dll unter %APPDATA%\Microsoft\Windows\Templates für anfällige Prozesse
+
+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‑Ideen
+- PowerShell‑Spawns mit RW→RX‑Transitions: VirtualProtect zu PAGE_EXECUTE_READWRITE innerhalb von powershell.exe
+- Dynamic invocation‑Muster (GetDelegateForFunctionPointer)
+- Startup .lnk unter user oder common Startup‑Ordnern
+- Suspicious Run Keys (z. B. "Updater") und Loader‑Namen wie update.ps1/loader.ps1
+- User‑writable DLL‑Pfad unter %APPDATA%\Microsoft\Windows\Templates, der msimg32.dll enthält
+
+## Notes on OpSec fields
+
+- KillDate: Timestamp, nach dem der Agent sich selbst deaktiviert
+- WorkingTime: Stunden, in denen der Agent aktiv sein sollte, um sich an Geschäftstätigkeit anzupassen
+
+Diese Felder können für Clustering genutzt werden und helfen, beobachtete ruhige Perioden zu erklären.
+
+## YARA and static leads
+
+Unit 42 veröffentlichte grundlegende YARA für beacons (C/C++ und Go) und Loader API‑hashing Konstanten. In Erwägung ziehen, Regeln zu ergänzen, die nach dem [size|ciphertext|16‑byte‑key] Layout in der Nähe des PE .rdata‑Endes und den Default HTTP‑Profilstrings suchen.
+
+## 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

@@ -1,8 +1,8 @@
-# Malware Analysis
+# Malware-Analyse
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Forensik-Cheat-Sheets
+## Forensik-CheatSheets
 
 [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/)
 
-## Offline-Antivirus- und Erkennungstools
+## Offline-Antivirus- und Erkennungs-Tools
 
 ### Yara
 
@@ -25,20 +25,20 @@ sudo apt-get install -y yara
 #### Regeln vorbereiten
 
 Verwende dieses Skript, um alle yara malware rules von github herunterzuladen und zusammenzuführen: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
-Erstelle das _**rules**_ Verzeichnis und führe es aus. Dadurch wird eine Datei mit dem Namen _**malware_rules.yar**_ erstellt, die alle yara rules für malware enthält.
+Erstelle das _**rules**_ Verzeichnis und führe das Skript aus. Dadurch wird eine Datei namens _**malware_rules.yar**_ erstellt, die alle yara rules für malware enthält.
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
 mkdir rules
 python malware_yara_rules.py
 ```
-#### Scan
+#### Scannen
 ```bash
 yara -w malware_rules.yar image  #Scan 1 file
 yara -w malware_rules.yar folder #Scan the whole folder
 ```
-#### YaraGen: Auf Malware prüfen und Regeln erstellen
+#### YaraGen: Auf malware prüfen und Regeln erstellen
 
-Du kannst das Tool [**YaraGen**](https://github.com/Neo23x0/yarGen) verwenden, um yara rules aus einem binary zu generieren. Schau dir diese Tutorials an: [**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/)
+Du kannst das Tool [**YaraGen**](https://github.com/Neo23x0/yarGen) verwenden, um yara rules aus einer Binärdatei zu generieren. Schau dir diese Tutorials an: [**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
 python3 yarGen.py --update
 python3.exe yarGen.py --excludegood -m  ../../mals/
@@ -49,7 +49,7 @@ python3.exe yarGen.py --excludegood -m  ../../mals/
 ```
 sudo apt-get install -y clamav
 ```
-#### Scan
+#### Scannen
 ```bash
 sudo freshclam      #Update rules
 clamscan filepath   #Scan 1 file
@@ -57,26 +57,26 @@ clamscan folderpath #Scan the whole folder
 ```
 ### [Capa](https://github.com/mandiant/capa)
 
-**Capa** erkennt potenziell bösartige **capabilities** in ausführbaren Dateien: PE, ELF, .NET. Es findet also Dinge wie Att\&ck tactics, oder verdächtige capabilities wie:
+**Capa** erkennt potenziell bösartige **capabilities** in ausführbaren Dateien: PE, ELF, .NET. Es findet auch Dinge wie Att\&ck tactics, oder verdächtige capabilities wie:
 
 - check for OutputDebugString error
 - run as a service
 - create process
 
-Hol es dir im [**Github repo**](https://github.com/mandiant/capa).
+Hol es im [**Github repo**](https://github.com/mandiant/capa).
 
 ### IOCs
 
-IOC bedeutet Indicator Of Compromise. Ein IOC ist eine Menge von **Bedingungen, die** potenziell unerwünschte Software oder bestätigte **malware** identifizieren. Blue Teams verwenden diese Art von Definition, um **nach dieser Art bösartiger Dateien** in ihren **Systemen** und **Netzwerken** zu suchen.\
+IOC bedeutet Indicator Of Compromise. Ein IOC ist eine Reihe von **Bedingungen, die** einige potenziell unerwünschte Software oder bestätigte **malware** identifizieren. Blue Teams verwenden diese Art von Definition, um in ihren **systems** und **networks** nach solchen bösartigen Dateien zu suchen.\
-Das Teilen dieser Definitionen ist sehr nützlich, denn wenn auf einem Rechner malware identifiziert wird und dafür ein IOC erstellt wird, können andere Blue Teams es nutzen, um die malware schneller zu erkennen.
+Das Teilen dieser Definitionen ist sehr nützlich, denn wenn malware auf einem Computer identifiziert wird und ein IOC für diese malware erstellt wird, können andere Blue Teams es verwenden, um die malware schneller zu identifizieren.
 
-Ein Tool, um IOCs zu erstellen oder zu bearbeiten, ist [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html).\
+Ein Tool zum Erstellen oder Ändern von IOCs ist [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
-Man kann Werkzeuge wie [**Redline**](https://www.fireeye.com/services/freeware/redline.html) verwenden, um **nach definierten IOCs auf einem Gerät zu suchen**.
+Sie können Tools wie [**Redline**](https://www.fireeye.com/services/freeware/redline.html) verwenden, um **nach definierten IOCs auf einem Gerät zu suchen**.
 
 ### Loki
 
 [**Loki**](https://github.com/Neo23x0/Loki) ist ein Scanner für Simple Indicators of Compromise.\
-Die Erkennung basiert auf vier Erkennungsmethoden:
+Die Erkennung basiert auf vier Detection-Methoden:
 ```
 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/) ist ein Malware-Scanner für Linux, veröffentlicht unter der GNU GPLv2-Lizenz, der auf die Bedrohungen ausgelegt ist, denen Shared-Hosting-Umgebungen ausgesetzt sind. Er nutzt Bedrohungsdaten aus Netzwerk-Edge-Intrusion-Detection-Systemen, um Malware zu extrahieren, die aktiv in Angriffen verwendet wird, und erzeugt Signaturen zur Erkennung. Zusätzlich stammen Bedrohungsdaten auch aus Nutzer-Einsendungen über die LMD checkout-Funktion und aus Ressourcen der Malware-Community.
+[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) ist ein Malware-Scanner für Linux, veröffentlicht unter der GNU GPLv2-Lizenz, der auf die Bedrohungen in gemeinsam gehosteten Umgebungen ausgelegt ist. Er nutzt Bedrohungsdaten aus netzwerkseitigen Intrusion-Detection-Systemen, um Malware zu extrahieren, die aktiv in Angriffen verwendet wird, und erzeugt Signaturen zur Erkennung. Zusätzlich stammen Bedrohungsdaten aus Benutzereinsendungen über die LMD-Checkout-Funktion und aus Ressourcen der Malware-Community.
 
 ### 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) ist ein Tool, das versucht, obfuskierte Strings in ausführbaren Dateien mithilfe verschiedener Techniken zu finden.
+[**FLOSS**](https://github.com/mandiant/flare-floss) ist ein Tool, das versucht, **obfuscated strings** in ausführbaren Dateien mithilfe verschiedener Techniken zu finden.
 
 ### PEpper
 
-[PEpper ](https://github.com/Th3Hurrican3/PEpper) prüft grundlegende Dinge in der ausführbaren Datei (Binärdaten, Entropie, URLs und IPs, einige yara-Regeln).
+[PEpper ](https://github.com/Th3Hurrican3/PEpper)prüft einige grundlegende Dinge in der ausführbaren Datei (binäre Daten, Entropie, URLs und IPs, einige yara rules).
 
 ### PEstudio
 
-[PEstudio](https://www.winitor.com/download) ist ein Tool, das Informationen zu Windows-Executables wie Imports, Exports, Headern liefert, aber auch Virus Total prüft und potenzielle Att\&ck-Techniken findet.
+[PEstudio](https://www.winitor.com/download) ist ein Tool, das Informationen zu Windows-Executables liefert, wie Importe, Exporte und Header; außerdem prüft es VirusTotal und findet potenzielle Att\&ck-Techniken.
 
 ### Detect It Easy(DiE)
 
-[**DiE**](https://github.com/horsicq/Detect-It-Easy/) ist ein Tool, um zu erkennen, ob eine Datei **verschlüsselt** ist, und um **Packer** zu finden.
+[**DiE**](https://github.com/horsicq/Detect-It-Easy/) ist ein Tool, um zu erkennen, ob eine Datei **encrypted** ist und außerdem **packers** zu finden.
 
 ### NeoPI
 
-[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) ist ein Python-Skript, das verschiedene **statistische Methoden** verwendet, um **obfuskierte** und **verschlüsselte** Inhalte in Text-/Script-Dateien zu erkennen. Der Zweck von NeoPI ist es, bei der **Erkennung von verstecktem Webshell-Code** zu unterstützen.
+[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)ist ein Python-Skript, das verschiedene **statistische Methoden** verwendet, um **obfuscated** und **encrypted** Inhalte in Text-/Script-Dateien zu erkennen. Der beabsichtigte Zweck von NeoPI ist die Unterstützung bei der **Erkennung von verstecktem web shell code**.
 
 ### **php-malware-finder**
 
-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) versucht bestmöglich, **obfuskierten**/**verdächtigen Code** sowie Dateien mit **PHP**-Funktionen zu erkennen, die häufig in **Malware**/Webshells verwendet werden.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) versucht bestmöglich, **obfuscated**/**dodgy code** zu erkennen sowie Dateien, die **PHP**-Funktionen verwenden, die häufig in **malwares**/webshells genutzt werden.
 
 ### Apple Binary Signatures
 
-Beim Prüfen einer **Malware sample** sollten Sie immer die **Signatur** der Binärdatei prüfen, da der **developer**, der sie signiert hat, möglicherweise bereits mit **malware** in Verbindung steht.
+Beim Prüfen einer **malware sample** sollten Sie immer **die Signatur überprüfen** der Binärdatei, da der **Entwickler**, der sie signiert hat, bereits **in Verbindung** mit **malware.** stehen könnte.
 ```bash
 #Get signer
 codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@@ -141,23 +141,23 @@ spctl --assess --verbose /Applications/Safari.app
 
 ### File Stacking
 
-Wenn Sie wissen, dass ein Ordner, der die **Dateien** eines Webservers enthält, **zu einem bestimmten Datum zuletzt aktualisiert wurde**, **prüfen** Sie das **Datum**, an dem alle **Dateien** auf dem **Webserver** erstellt und geändert wurden, und wenn ein Datum **verdächtig** ist, untersuchen Sie diese Datei.
+Wenn Sie wissen, dass ein Ordner, der die **Dateien** eines Webservers enthält, **zu einem bestimmten Datum zuletzt aktualisiert wurde**. **Prüfen** Sie das **Datum**, an dem alle **Dateien** des **Webservers erstellt und geändert wurden**, und wenn ein Datum **verdächtig** ist, untersuchen Sie diese Datei.
 
 ### Baselines
 
-Wenn die **Dateien** eines Ordners **nicht hätten verändert werden dürfen**, können Sie den **hash** der **originalen Dateien** des Ordners berechnen und **mit** den **aktuellen** vergleichen. Alles, was verändert wurde, ist **verdächtig**.
+Wenn die Dateien eines Ordners **nicht hätten verändert werden dürfen**, können Sie den **Hash** der **Originaldateien** des Ordners berechnen und mit den **aktuellen** vergleichen. Alles, was verändert wurde, ist **verdächtig**.
 
-### Statistische Analyse
+### Statistical Analysis
 
-Wenn die Informationen in Logs gespeichert sind, können Sie **Statistiken prüfen**, z. B. wie oft jede Datei eines Webservers aufgerufen wurde — eine web shell könnte zu den am häufigsten aufgerufenen gehören.
+Wenn die Informationen in Logs gespeichert sind, können Sie **Statistiken prüfen**, z. B. wie oft jede Datei eines Webservers aufgerufen wurde, da eine web shell möglicherweise eine der meistgenutzten ist.
 
 ---
 
-### Android in-app native Telemetrie (no root)
+### Android in-app native Telemetrie (kein Root)
 
-Auf Android können Sie nativen Code innerhalb des Ziel-App-Prozesses instrumentieren, indem Sie vor der Initialisierung anderer JNI libs eine kleine Logger-Library vorladen. Das ermöglicht frühe Einsicht in natives Verhalten ohne systemweite Hooks oder root. Ein verbreiteter Ansatz ist SoTap: legen Sie libsotap.so für das passende ABI in das APK und fügen Sie früh einen System.loadLibrary("sotap")-Aufruf ein (z. B. im static initializer oder in Application.onCreate), danach sammeln Sie Logs aus internen/externen Pfaden oder als Fallback Logcat.
+Auf Android können Sie nativen Code innerhalb des Ziel-App-Prozesses instrumentieren, indem Sie eine kleine Logger-Bibliothek vorladen, bevor andere JNI libs initialisiert werden. Das bietet frühzeitige Einsicht in natives Verhalten ohne systemweite Hooks oder Root. Ein verbreiteter Ansatz ist SoTap: legen Sie libsotap.so für die passende ABI in das APK und fügen Sie früh einen System.loadLibrary("sotap")-Aufruf ein (z. B. static initializer oder Application.onCreate), und sammeln Sie dann Logs aus internen/externen Pfaden oder als Logcat-Fallback.
 
-Siehe die Android native reversing Seite für Details zur Einrichtung und zu den Log-Pfaden:
+Siehe die Android native reversing-Seite für Setup-Details und Log-Pfade:
 
 {{#ref}}
 ../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
@@ -165,13 +165,13 @@ Siehe die Android native reversing Seite für Details zur Einrichtung und zu den
 
 ---
 
-## Deobfuskation dynamischer Control-Flow (JMP/CALL RAX Dispatchers)
+## Deobfuskation dynamischer Kontrollflüsse (JMP/CALL RAX Dispatchers)
 
-Moderne Malware-Familien missbrauchen stark die Control-Flow Graph (CFG)-Obfuskation: anstatt eines direkten jump/call berechnen sie das Ziel zur Laufzeit und führen einen `jmp rax` oder `call rax` aus. Ein kleiner *dispatcher* (typischerweise neun Instruktionen) legt das endgültige Ziel abhängig von den CPU-Flags `ZF`/`CF` fest und bricht damit die statische CFG-Wiederherstellung vollständig.
+Moderne malware-Familien missbrauchen stark die Kontrollflussgraph (CFG)-Obfuskation: anstatt eines direkten jump/call berechnen sie das Ziel zur Laufzeit und führen ein `jmp rax` oder `call rax` aus. Ein kleiner *Dispatcher* (typischerweise neun Instruktionen) setzt das finale Ziel abhängig von den CPU-Flags `ZF`/`CF` und bricht damit die statische CFG-Rekonstruktion vollständig.
 
-Die Technik – demonstriert vom SLOW#TEMPEST loader – lässt sich mit einem dreistufigen Workflow umgehen, der nur auf IDAPython und dem Unicorn CPU emulator basiert.
+Die Technik – demonstriert am SLOW#TEMPEST loader – lässt sich mit einem dreistufigen Workflow umgehen, der nur auf IDAPython und dem Unicorn CPU emulator basiert.
 
-### 1. Alle indirekten jump / call lokalisieren
+### 1. Lokalisieren Sie jeden indirekten jump / call
 ```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. Extrahiere den dispatcher byte-code
+### 2. Dispatcher-Bytecode extrahieren
 ```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)
 ```
-Führe `run(code,0,0)` und `run(code,1,1)` aus, um die *false*- bzw. *true*-Branch-Ziele zu ermitteln.
+Führe `run(code,0,0)` und `run(code,1,1)` aus, um die Ziele des *false*- und *true*-Zweigs zu erhalten.
 
-### 4. Direkten jump / call zurückpatchen
+### 4. Einen direkten jump / call zurückpatchen
 ```python
 import struct, ida_bytes
 
@@ -222,28 +222,37 @@ 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))
 ```
-Nach dem Patchen erzwingen, dass IDA die Funktion neu analysiert, damit das vollständige CFG und die Hex-Rays-Ausgabe wiederhergestellt werden:
+Nach dem Patchen IDA dazu zwingen, die Funktion neu zu analysieren, damit die vollständige CFG- und Hex-Rays-Ausgabe wiederhergestellt wird:
 ```python
 import ida_auto, idaapi
 idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
 ```
 ### 5. Indirekte API-Aufrufe kennzeichnen
 
-Sobald das tatsächliche Ziel jedes `call rax` bekannt ist, können Sie IDA mitteilen, was es ist, damit Parameter-Typen und Variablennamen automatisch wiederhergestellt werden:
+Sobald das reale Ziel jedes `call rax` bekannt ist, kannst du IDA mitteilen, was es ist, sodass Parametertypen & Variablennamen automatisch wiederhergestellt werden:
 ```python
 idc.set_callee_name(call_ea, resolved_addr, 0)  # IDA 8.3+
 ```
 ### Praktische Vorteile
 
-* Stellt die reale CFG wieder her → Dekomplilierung geht von *10* Zeilen auf Tausende.
+* Stellt den realen CFG wieder her → decompilation geht von *10* Zeilen auf Tausende.
-* Ermöglicht string-cross-reference & xrefs, macht die Rekonstruktion des Verhaltens trivial.
+* Ermöglicht string-cross-reference & xrefs und macht die Verhaltensrekonstruktion trivial.
-* Scripts sind wiederverwendbar: Platziere sie in jeden loader, der durch denselben Trick geschützt ist.
+* Skripte sind wiederverwendbar: lege sie in jeden loader, der durch denselben Trick geschützt ist.
 
 ---
 
+## AdaptixC2: Konfigurationsextraktion und TTPs
+
+Siehe die zugehörige Seite:
+
+{{#ref}}
+adaptixc2-config-extraction-and-ttps.md
+{{#endref}}
+
 ## Referenzen
 
 - [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)
+- [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}}