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

2025-10-10 18:36:50 +00:00 · 2025-09-30 09:10:35 +00:00 · 2025-09-30 09:10:35 +00:00 · 00367f873b
commit 00367f873b
parent 9cdad0d77e
3 changed files with 302 additions and 50 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)
@ -938,5 +941,3 @@
 - [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)
--- 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 @@
+# AdaptixC2 Ekstrakcja konfiguracji i TTPs
+
+{{#include ../../banners/hacktricks-training.md}}
+
+AdaptixC2 to modułowy, open‑source framework post‑exploitation/C2 z Windows x86/x64 beacons (EXE/DLL/service EXE/raw shellcode) i wsparciem BOF. Ta strona opisuje:
+- Jak jego konfiguracja spakowana RC4 jest osadzana i jak ją wyodrębnić z beacons
+- Wskaźniki sieciowe/profilowe dla listenerów HTTP/SMB/TCP
+- Typowe TTPs dotyczące loaderów i persistence obserwowane w rzeczywistych atakach, z linkami do odpowiednich stron technik Windows
+
+## Profile i pola Beacon
+
+AdaptixC2 obsługuje trzy główne typy beacon:
+- BEACON_HTTP: web C2 z konfigurowalnymi serwerami/portami/SSL, metodą, URI, nagłówkami, user‑agent i niestandardową nazwą parametru
+- BEACON_SMB: named‑pipe peer‑to‑peer C2 (intranet)
+- BEACON_TCP: direct sockets, opcjonalnie z prefiksowanym markerem do zacierania początku protokołu
+
+Typowe pola profilu obserwowane w konfiguracjach HTTP beacon (po odszyfrowaniu):
+- 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)
+
+Przykładowy domyślny profil HTTP (z 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
+}
+```
+Zaobserwowany złośliwy profil HTTP (rzeczywisty atak):
+```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
+}
+```
+## Szyfrowane pakowanie konfiguracji i ścieżka ładowania
+
+Gdy operator kliknie Create w builderze, AdaptixC2 osadza zaszyfrowany profil jako tail blob w beaconie. Format jest następujący:
+- 4 bajty: rozmiar konfiguracji (uint32, little‑endian)
+- N bajtów: dane konfiguracji zaszyfrowane RC4
+- 16 bajtów: klucz RC4
+
+Beacon loader kopiuje 16‑bajtowy klucz z końca i deszyfruje RC4 blok N‑bajtów na miejscu:
+```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);
+```
+Implikacje praktyczne:
+- Cała struktura często znajduje się w sekcji PE .rdata.
+- Ekstrakcja jest deterministyczna: odczytaj size, odczytaj ciphertext o tej wielkości, odczytaj 16‑byte key umieszczony bezpośrednio po nim, a następnie RC4‑decrypt.
+
+## Proces ekstrakcji konfiguracji (obrońcy)
+
+Napisz extractor, który naśladuje logikę beacon:
+1) Zlokalizuj blob wewnątrz PE (zwykle .rdata). Pragmatyczne podejście to przeskanowanie .rdata w poszukiwaniu prawdopodobnego układu [size|ciphertext|16‑byte key] i próba RC4.
+2) Odczytaj pierwsze 4 bajty → size (uint32 LE).
+3) Odczytaj następne N=size bajtów → ciphertext.
+4) Odczytaj ostatnie 16 bajtów → RC4 key.
+5) RC4‑decrypt ciphertext. Następnie sparsuj odszyfrowany profil jako:
+- u32/boolean scalars zgodnie z powyższym
+- length‑prefixed strings (u32 length followed by bytes; trailing NUL can be present)
+- arrays: servers_count followed by that many [string, u32 port] pairs
+
+Minimalny proof‑of‑concept w Pythonie (samodzielny, bez zewnętrznych zależności), który działa z wstępnie wyodrębnionym blobem:
+```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:
+- Przy automatyzacji użyj parsera PE do odczytu .rdata, następnie zastosuj sliding window: dla każdego offsetu o spróbuj size = u32(.rdata[o:o+4]), ct = .rdata[o+4:o+4+size], candidate key = next 16 bytes; RC4‑decrypt i sprawdź, czy pola string dekodują się jako UTF‑8 i czy długości są sensowne.
+- Parsuj profile SMB/TCP stosując te same konwencje z prefiksem długości.
+
+## Network fingerprinting and hunting
+
+HTTP
+- Common: POST to operator‑selected URIs (e.g., /uri.php, /endpoint/api)
+- Niestandardowy parametr nagłówka używany jako beacon ID (e.g., X‑Beacon‑Id, X‑App‑Id)
+- User‑agents podszywające się pod Firefox 20 lub współczesne buildy Chrome
+- Polling cadence widoczna przez sleep_delay/jitter_delay
+
+SMB/TCP
+- SMB named‑pipe listeners dla intranetowego C2, gdy egress webowy jest ograniczony
+- TCP beacons mogą dołączać kilka bajtów przed ruchem, aby zniekształcić początek protokołu
+
+## Loader and persistence TTPs seen in incidents
+
+In‑memory PowerShell loaders
+- Pobierają payloady Base64/XOR (Invoke‑RestMethod / WebClient)
+- Alokują unmanaged memory, kopiują shellcode, zmieniają ochronę na 0x40 (PAGE_EXECUTE_READWRITE) via VirtualProtect
+- Wykonanie przez .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}}
+
+Zaobserwowane mechanizmy persistence
+- Skrót w folderze Startup (.lnk) do ponownego uruchomienia loadera przy logon
+- Registry Run keys (HKCU/HKLM ...\CurrentVersion\Run), często z nazwami brzmiącymi benign‑owo jak "Updater" uruchamiającymi loader.ps1
+- DLL search‑order hijack przez upuszczenie msimg32.dll pod %APPDATA%\Microsoft\Windows\Templates dla podatnych procesów
+
+Szczegółowe opisy technik i kontrole:
+
+{{#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}}
+
+Pomysły na hunting
+- Przejścia RW→RX w powershell.exe: VirtualProtect do PAGE_EXECUTE_READWRITE
+- Wzorce dynamic invocation (GetDelegateForFunctionPointer)
+- Skróty .lnk w folderach Startup użytkownika lub wspólnym Startup
+- Podejrzane Run keys (np. "Updater") oraz nazwy loaderów jak update.ps1/loader.ps1
+- Ścieżki DLL zapisywalne przez użytkownika pod %APPDATA%\Microsoft\Windows\Templates zawierające msimg32.dll
+
+## Notes on OpSec fields
+
+- KillDate: znacznik czasu, po którym agent sam wygasa
+- WorkingTime: godziny, w których agent powinien być aktywny, by wtopić się w aktywność biznesową
+
+Pola te można wykorzystać do klastrowania i wyjaśniania obserwowanych okresów ciszy.
+
+## YARA and static leads
+
+Unit 42 opublikował podstawowe reguły YARA dla beaconów (C/C++ i Go) oraz stałe API‑hashingu loaderów. Rozważ uzupełnienie reguł o wzorce szukające układu [size|ciphertext|16‑byte‑key] w pobliżu końca PE .rdata oraz domyślnych stringów profilu HTTP.
+
+## 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
@ -1,8 +1,8 @@
-# Analiza Malware
+# Malware Analysis

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

-## Ściągi Forensics
+## Forensics 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/)

-## Narzędzia antywirusowe i detekcyjne (offline)
+## Offline — narzędzia antywirusowe i wykrywania

 ### Yara

@ -24,8 +24,8 @@ sudo apt-get install -y yara
 ```
 #### Przygotuj reguły

-Użyj tego skryptu, aby pobrać i scalić wszystkie yara malware rules z github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\  
-Utwórz katalog _**rules**_ i uruchom skrypt. Spowoduje to utworzenie pliku o nazwie _**malware_rules.yar**_, który zawiera wszystkie yara rules dla malware.
+Użyj tego skryptu, aby pobrać i scalić wszystkie reguły yara dotyczące malware z GitHub: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
+Utwórz katalog _**rules**_ i uruchom go. Spowoduje to utworzenie pliku o nazwie _**malware_rules.yar**_, który zawiera wszystkie reguły yara dla malware.
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
 mkdir rules
@ -36,9 +36,9 @@ python malware_yara_rules.py
 yara -w malware_rules.yar image  #Scan 1 file
 yara -w malware_rules.yar folder #Scan the whole folder
 ```
-#### YaraGen: Sprawdź malware i utwórz reguły
+#### YaraGen: Sprawdź malware i twórz yara rules

-Możesz użyć narzędzia [**YaraGen**](https://github.com/Neo23x0/yarGen), aby wygenerować yara rules z pliku binarnego. Zobacz te poradniki: [**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/)
+Możesz użyć narzędzia [**YaraGen**](https://github.com/Neo23x0/yarGen) aby wygenerować yara rules z pliku binarnego. Zobacz te samouczki: [**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/
@ -57,26 +57,25 @@ clamscan folderpath #Scan the whole folder
 ```
 ### [Capa](https://github.com/mandiant/capa)

-**Capa** wykrywa potencjalnie złośliwe **możliwości** w plikach wykonywalnych: PE, ELF, .NET. Wykryje więc rzeczy takie jak Att\&ck tactics, lub podejrzane możliwości takie jak:
+**Capa** wykrywa potencjalnie złośliwe **możliwości** w plikach wykonywalnych: PE, ELF, .NET. Dzięki temu znajdzie rzeczy takie jak Att\&ck tactics, albo podejrzane możliwości takie jak:

- check for OutputDebugString error
+- sprawdzenie błędu OutputDebugString
 - run as a service
 - create process

-Pobierz go z [**Github repo**](https://github.com/mandiant/capa).
+Pobierz go w [**Github repo**](https://github.com/mandiant/capa).

 ### IOCs

-IOC oznacza Indicator Of Compromise. IOC to zbiór **warunków, które identyfikują** potencjalnie niechciane oprogramowanie lub potwierdzone **malware**.\
-Blue Teams używają tego rodzaju definicji do **wyszukiwania tego typu złośliwych plików** w swoich **systemach** i **sieciach**.\
-Udostępnianie tych definicji jest bardzo przydatne — gdy malware zostanie zidentyfikowane na komputerze i zostanie utworzony dla niego IOC, inne Blue Teams mogą go wykorzystać do szybszej identyfikacji.
+IOC oznacza Indicator Of Compromise. IOC to zestaw **warunków, które identyfikują** potencjalnie niechciane oprogramowanie lub potwierdzone **malware**. Blue Teams używają tego rodzaju definicji, aby **wyszukiwać tego typu złośliwe pliki** w swoich **systemach** i **sieciach**.\
+Współdzielenie tych definicji jest bardzo przydatne — gdy malware zostanie zidentyfikowane na komputerze i utworzony zostanie IOC dla tego malware, inne Blue Teams mogą użyć go do szybszej identyfikacji zagrożenia.

-Narzędziem do tworzenia lub modyfikowania IOC jest [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
-Możesz użyć narzędzi takich jak [**Redline**](https://www.fireeye.com/services/freeware/redline.html) do **wyszukiwania zdefiniowanych IOC na urządzeniu**.
+Narzędziem do tworzenia lub modyfikowania IOCs jest [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
+Możesz użyć narzędzi takich jak [**Redline**](https://www.fireeye.com/services/freeware/redline.html) aby **wyszukać zdefiniowane IOC na urządzeniu**.

 ### Loki

-[**Loki**](https://github.com/Neo23x0/Loki) to skaner prostych wskaźników kompromitacji.\
+[**Loki**](https://github.com/Neo23x0/Loki) to skaner dla Simple Indicators of Compromise.\
 Wykrywanie opiera się na czterech metodach detekcji:
 ```
 1. File Name IOC
@ -93,41 +92,41 @@ 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/) to skaner malware dla Linux wydany na licencji GNU GPLv2, zaprojektowany z myślą o zagrożeniach występujących w środowiskach współdzielonego hostingu. Wykorzystuje dane o zagrożeniach z network edge intrusion detection systems do wydobywania malware, które są aktywnie używane w atakach, i generuje sygnatury do wykrywania. Dodatkowo dane o zagrożeniach pochodzą również z user submissions za pomocą LMD checkout feature oraz z zasobów społeczności malware.
+[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) to skaner malware dla Linuxa wydany na licencji GNU GPLv2, zaprojektowany z myślą o zagrożeniach występujących w środowiskach hostingu współdzielonego. Wykorzystuje dane o zagrożeniach z systemów IDS na krawędzi sieci do ekstrakcji malware, które są aktywnie wykorzystywane w atakach, i generuje sygnatury do wykrywania. Dodatkowo dane o zagrożeniach pochodzą także ze zgłoszeń użytkowników za pomocą LMD checkout feature oraz z malware community resources.

 ### rkhunter

-Narzędzia takie jak [**rkhunter**](http://rkhunter.sourceforge.net) mogą być użyte do sprawdzenia systemu plików pod kątem możliwych **rootkits** i malware.
+Narzędzia takie jak [**rkhunter**](http://rkhunter.sourceforge.net) można użyć do sprawdzenia systemu plików w poszukiwaniu możliwych **rootkits** i malware.
 ```bash
 sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
 ```
 ### FLOSS

-[**FLOSS**](https://github.com/mandiant/flare-floss) to narzędzie, które spróbuje znaleźć obfuscated strings w executables, używając różnych techniques.
+[**FLOSS**](https://github.com/mandiant/flare-floss) jest narzędziem, które spróbuje znaleźć **obfuscated strings** wewnątrz **executables** używając różnych technik.

 ### PEpper

-[PEpper ](https://github.com/Th3Hurrican3/PEpper) sprawdza podstawowe rzeczy w executable (binary data, entropy, URLs and IPs, some yara rules).
+[PEpper ](https://github.com/Th3Hurrican3/PEpper)sprawdza podstawowe rzeczy w **executable** (binary data, entropy, URLs and IPs, some yara rules).

 ### PEstudio

-[PEstudio](https://www.winitor.com/download) to narzędzie pozwalające uzyskać informacje o Windows executables, takich jak imports, exports, headers, ale także sprawdzi virus total i znajdzie potencjalne Att\&ck techniques.
+[PEstudio](https://www.winitor.com/download) to narzędzie pozwalające uzyskać informacje o Windows **executables** takich jak imports, exports, headers, ale także sprawdzi virus total i znajdzie potencjalne Att\&ck techniques.

 ### Detect It Easy(DiE)

-[**DiE**](https://github.com/horsicq/Detect-It-Easy/) to narzędzie do wykrywania, czy plik jest **encrypted** i także znajdowania **packers**.
+[**DiE**](https://github.com/horsicq/Detect-It-Easy/) to narzędzie do wykrywania, czy plik jest **encrypted** oraz do znajdowania **packers**.

 ### NeoPI

-[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) to skrypt Python, który używa różnych **statistical methods** do wykrywania **obfuscated** i **encrypted** content w plikach tekstowych/skryptach. Celem NeoPI jest pomoc w **detection of hidden web shell code**.
+[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is skrypt w Pythonie, który używa różnych **statistical methods** do wykrywania **obfuscated** i **encrypted** treści w plikach tekstowych/skryptach. Celem NeoPI jest pomoc w **detection of hidden web shell code**.

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

-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) robi co może, aby wykryć **obfuscated**/**dodgy code** oraz pliki wykorzystujące funkcje **PHP** często używane w **malwares**/webshells.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) stara się jak najlepiej wykryć **obfuscated**/**dodgy code**, a także pliki używające funkcji **PHP** często stosowanych w **malwares**/webshells.

 ### Apple Binary Signatures

-Sprawdzając próbkę **malware sample** powinieneś zawsze **check the signature** binarki, ponieważ **developer**, który ją podpisał, może być już **related** z **malware.**
+Przy sprawdzaniu jakiegoś **malware sample** zawsze powinieneś **check the signature** binarnego pliku, ponieważ **developer**, który go podpisał, może być już **related** z **malware.**
 ```bash
 #Get signer
 codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -142,23 +141,23 @@ spctl --assess --verbose /Applications/Safari.app

 ### File Stacking

-Jeżeli wiesz, że jakiś folder zawierający **pliki** web servera był **ostatnio zaktualizowany w pewnym dniu**. **Sprawdź** **datę**, kiedy wszystkie **pliki** w **web serverze** zostały utworzone i zmodyfikowane — jeśli któraś data wygląda **podejrzanie**, sprawdź ten plik.
+Jeśli wiesz, że jakiś folder zawierający **pliki** serwera WWW został **ostatnio zaktualizowany w określonym terminie**. **Sprawdź** **daty** utworzenia i modyfikacji wszystkich **plików** na **serwerze WWW** i jeśli jakaś data jest **podejrzana**, sprawdź ten plik.

-### Baselines
+### Linia bazowa

-Jeżeli pliki w folderze **nie powinny być modyfikowane**, możesz obliczyć **hash** **oryginalnych plików** folderu i **porównać** je z **aktualnymi**. Wszystko zmodyfikowane będzie **podejrzane**.
+Jeśli pliki w folderze **nie powinny były być modyfikowane**, możesz policzyć **hash** **oryginalnych plików** folderu i **porównać** je z **aktualnymi**. Wszystko, co zostało zmodyfikowane, będzie **podejrzane**.

-### Statistical Analysis
+### Analiza statystyczna

-Kiedy informacje są zapisywane w logach, możesz **sprawdzić statystyki**, np. ile razy każdy plik web servera był dostępny — web shell może być jednym z najczęściej.
+Gdy informacje są zapisywane w logach, możesz **sprawdzić statystyki**, np. ile razy każdy plik serwera WWW był dostępny — web shell może być jednym z najczęściej występujących.

 ---

-### Android in-app native telemetry (no root)
+### Natywna telemetryka in-app na Androidzie (no root)

-Na Androidzie możesz instrumentować natywny kod wewnątrz procesu docelowej aplikacji przez wstępne załadowanie małej biblioteki loggera zanim inne JNI libs się zainicjalizują. To daje wczesną widoczność natywnego zachowania bez system-wide hooks ani roota. Popularne podejście to SoTap: wrzuć libsotap.so dla odpowiedniego ABI do APK i wstrzyknij wywołanie System.loadLibrary("sotap") wcześnie (np. static initializer lub Application.onCreate), następnie zbieraj logi z internal/external ścieżek lub użyj Logcat jako fallback.
+Na Androidzie możesz instrumentować kod natywny wewnątrz procesu docelowej aplikacji, preloadując małą bibliotekę loggera przed zainicjalizowaniem innych bibliotek JNI. Daje to wczesną widoczność zachowania natywnego bez hooków systemowych czy roota. Popularne podejście to SoTap: wrzuć libsotap.so dla właściwego ABI do APK i wstrzyknij wywołanie System.loadLibrary("sotap") wcześnie (np. static initializer lub Application.onCreate), następnie zbieraj logi ze ścieżek wewnętrznych/zewnętrznych lub jako fallback Logcat.

-See the Android native reversing page for setup details and log paths:
+Zobacz stronę Android native reversing po szczegóły konfiguracji i ścieżki logów:

 {{#ref}}
 ../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
@ -166,13 +165,13 @@ See the Android native reversing page for setup details and log paths:

 ---

-## Deobfuscating Dynamic Control-Flow (JMP/CALL RAX Dispatchers)
+## Deobfuskacja dynamicznego przepływu sterowania (JMP/CALL RAX Dispatchers)

-Współczesne rodziny malware intensywnie nadużywają Control-Flow Graph (CFG) obfuskacji: zamiast bezpośredniego skoku/wywołania obliczają cel w czasie wykonania i wykonują `jmp rax` lub `call rax`. Mały *dispatcher* (zazwyczaj dziewięć instrukcji) ustawia docelowy adres zależnie od flag CPU `ZF`/`CF`, całkowicie łamiąc statyczne odzyskiwanie CFG.
+Nowoczesne rodziny malware intensywnie nadużywają obfuskacji Control-Flow Graph (CFG): zamiast bezpośredniego jump/call obliczają cel w czasie wykonania i wykonują `jmp rax` lub `call rax`. Mały *dispatcher* (zwykle dziewięć instrukcji) ustawia końcowy target w zależności od flag CPU `ZF`/`CF`, całkowicie łamiąc statyczne odzyskiwanie CFG.

-Technika – zaprezentowana przez loader SLOW#TEMPEST – może być pokonana trzema krokami wykorzystując wyłącznie IDAPython i emulator CPU Unicorn.
+Technika — pokazana przez loader SLOW#TEMPEST — może zostać pokonana za pomocą trzyetapowego procesu, który opiera się wyłącznie na IDAPython i emulatorze CPU Unicorn.

-### 1. Zlokalizuj wszystkie pośrednie skoki / wywołania
+### 1. Zlokalizuj każdy pośredni jump / call
 ```python
 import idautils, idc

@ -181,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. Wyodrębnij kod bajtowy dispatchera
+### 2. Wyodrębnij dispatcher byte-code
 ```python
 import idc

@ -196,7 +195,7 @@ 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. Emuluj to dwukrotnie za pomocą Unicorn
+### 3. Emuluj to dwukrotnie przy użyciu Unicorn
 ```python
 from unicorn import *
 from unicorn.x86_const import *
@ -212,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)
 ```
-Uruchom `run(code,0,0)` i `run(code,1,1)`, aby uzyskać *false* i *true* cele gałęzi.
+Uruchom `run(code,0,0)` i `run(code,1,1)`, aby uzyskać cele gałęzi *false* i *true*.

-### 4. Przywróć bezpośredni skok / wywołanie
+### 4. Przywrócenie bezpośredniego skoku / wywołania
 ```python
 import struct, ida_bytes

@ -223,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))
 ```
-Po patchingu wymuś w IDA ponowną analizę funkcji, aby pełny CFG i wynik Hex-Rays zostały przywrócone:
+Po patching, wymuś w IDA ponowną analizę funkcji, aby przywrócić pełny CFG i Hex-Rays output:
 ```python
 import ida_auto, idaapi
 idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
 ```
 ### 5. Oznacz pośrednie wywołania API

-Gdy znane jest rzeczywiste miejsce docelowe każdego `call rax`, możesz powiedzieć IDA, co to jest, aby typy parametrów & nazwy zmiennych zostały odzyskane automatycznie:
+Gdy znane jest rzeczywiste przeznaczenie każdego `call rax`, możesz powiedzieć IDA, czym ono jest, aby typy parametrów & nazwy zmiennych zostały odzyskane automatycznie:
 ```python
 idc.set_callee_name(call_ea, resolved_addr, 0)  # IDA 8.3+
 ```
 ### Praktyczne korzyści

-* Przywraca prawdziwe CFG → decompilation przechodzi z *10* linii do tysięcy.
-* Umożliwia string-cross-reference i xrefs, dzięki czemu rekonstrukcja zachowania staje się trywialna.
-* Scripts są wielokrotnego użytku: umieść je w dowolnym loaderze chronionym tym samym trikiem.
+* Przywraca prawdziwy CFG → dekompilacja zmienia się z *10* linii do tysięcy.
+* Umożliwia string-cross-reference & xrefs, co czyni rekonstrukcję zachowania trywialną.
+* Skrypty są wielokrotnego użytku: umieść je w dowolnym loaderze chronionym tą samą sztuczką.

 ---

+## AdaptixC2: Ekstrakcja konfiguracji i TTPs
+
+Zobacz dedykowaną stronę:
+
+{{#ref}}
+adaptixc2-config-extraction-and-ttps.md
+{{#endref}}
+
 ## Źródła

 - [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}}