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 Ekstrakcija konfiguracije i TTPs
+
+{{#include ../../banners/hacktricks-training.md}}
+
+AdaptixC2 je modularan, open‑source post‑exploitation/C2 framework sa Windows x86/x64 beaconima (EXE/DLL/service EXE/raw shellcode) i podrškom za BOF. Ova stranica dokumentuje:
+- Kako je njegova RC4‑packed konfiguracija ugrađena i kako je izvući iz beacons
+- Mrežni/profile indikatori za HTTP/SMB/TCP listeners
+- Uobičajene loader i persistence TTPs primećene u prirodi, sa linkovima ka relevantnim stranicama tehnika za Windows
+
+## Beacon profili i polja
+
+AdaptixC2 podržava tri primarna tipa beacon-a:
+- BEACON_HTTP: web C2 sa podesivim servers/ports/SSL, method, URI, headers, user‑agent i prilagođenim imenom parametra
+- BEACON_SMB: named‑pipe peer‑to‑peer C2 (intranet)
+- BEACON_TCP: direktni sockets, opciono sa prepended markerom za obfuscation starta protokola
+
+Tipična polja profila zabeležena u HTTP beacon konfiguracijama (posle dekripcije):
+- 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
+}
+```
+Uočen zlonamerni HTTP profil (stvarni napad):
+```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
+}
+```
+## Pakovanje šifrovane konfiguracije i put učitavanja
+
+Kada operator klikne Create u builderu, AdaptixC2 ugradi šifrovani profil kao tail blob u beacon. Format je:
+- 4 bajta: veličina konfiguracije (uint32, little‑endian)
+- N bajtova: RC4‑šifrovani podaci konfiguracije
+- 16 bajtova: RC4 ključ
+
+Beacon loader kopira 16‑bajtni ključ sa kraja i RC4 dekriptuje N‑bajtni blok na mestu:
+```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:
+- The entire structure often lives inside the PE .rdata section.
+- Extraction is deterministic: read size, read ciphertext of that size, read the 16‑byte key placed immediately after, then RC4‑decrypt.
+
+## Tok ekstrakcije konfiguracije (odbrambeni timovi)
+
+Napišite extractor koji oponaša beacon logic:
+1) Pronađite blob unutar PE (obično .rdata). Pragmatičan pristup je skenirati .rdata za verovatnim [size|ciphertext|16‑byte key] rasporedom i pokušati RC4.
+2) Pročitajte prvih 4 bajta → size (uint32 LE).
+3) Pročitajte narednih N=size bajtova → ciphertext.
+4) Pročitajte zadnjih 16 bajtova → RC4 key.
+5) RC4‑decrypt the ciphertext. Zatim parsirajte plain profile kao:
+- u32/boolean scalari kao što je gore navedeno
+- length‑prefixed strings (u32 length followed by bytes; trailing NUL can be present)
+- arrays: servers_count followed by that many [string, u32 port] pairs
+
+Minimalni Python proof‑of‑concept (samostalan, bez eksternih zavisnosti) koji radi sa pre‑ekstrahovanim blob-om:
+```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:
+- Kada automatizujete, koristite PE parser da pročitate .rdata pa primenite sliding window: za svaki offset o, probajte size = u32(.rdata[o:o+4]), ct = .rdata[o+4:o+4+size], kandidat ključ = narednih 16 bajtova; RC4‑decrypt i proverite da li string polja dekodiraju kao UTF‑8 i da su dužine razumske.
+- Parse‑ujte SMB/TCP profile prateći iste length‑prefixed konvencije.
+
+## Mrežno fingerprintovanje i lov
+
+HTTP
+- Uobičajeno: POST ka operator‑selektovanim URI‑jevima (npr. /uri.php, /endpoint/api)
+- Custom header parametar koji se koristi za beacon ID (npr. X‑Beacon‑Id, X‑App‑Id)
+- User‑agenti koji imitiraju Firefox 20 ili savremene Chrome buildove
+- Polling cadence vidljiv kroz sleep_delay/jitter_delay
+
+SMB/TCP
+- SMB named‑pipe slušači za intranet C2 gde je web egress ograničen
+- TCP beacons mogu prepended nekoliko bajtova pre saobraćaja da zamaskiraju početak protokola
+
+## Loader and persistence TTPs viđeni u incidentima
+
+In‑memory PowerShell loaders
+- Download Base64/XOR payloads (Invoke‑RestMethod / WebClient)
+- Allocate unmanaged memory, copy shellcode, switch protection to 0x40 (PAGE_EXECUTE_READWRITE) via VirtualProtect
+- Execute via .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 folder shortcut (.lnk) za ponovni launch loader‑a pri logon‑u
+- Registry Run keys (HKCU/HKLM ...\CurrentVersion\Run), često sa benigno‑zvučnim imenima kao "Updater" za startovanje loader.ps1
+- DLL search‑order hijack postavljanjem msimg32.dll pod %APPDATA%\Microsoft\Windows\Templates za ranjive procese
+
+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}}
+
+Ideje za lov
+- PowerShell procesi koji prave RW→RX prelaze: VirtualProtect na PAGE_EXECUTE_READWRITE unutar powershell.exe
+- Dynamic invocation obrasci (GetDelegateForFunctionPointer)
+- Startup .lnk u korisničkim ili zajedničkim Startup folderima
+- Sumnjivi Run ključevi (npr. "Updater"), i imena loadera kao update.ps1/loader.ps1
+- User‑writable DLL putanje pod %APPDATA%\Microsoft\Windows\Templates koje sadrže msimg32.dll
+
+## Napomene o OpSec poljima
+
+- KillDate: timestamp posle kojeg se agent samouništava / isključuje
+- WorkingTime: sati kada agent treba da bude aktivan da bi se uklopio sa poslovnom aktivnošću
+
+Ova polja se mogu koristiti za klasterovanje i za objašnjenje primećenih mirnih perioda.
+
+## YARA i statički tragovi
+
+Unit 42 je objavio osnovne YARA za beacons (C/C++ i Go) i konstante za loader API‑hashing. Razmotrite dopunu pravilima koja traže [size|ciphertext|16‑byte‑key] raspored blizu kraja PE .rdata i podrazumevanih HTTP profile stringova.
+
+## 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
+# Analiza malvera
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Forensics CheatSheets
+## Priručnici za forenziku
 
 [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
 
@@ -24,8 +24,8 @@ sudo apt-get install -y yara
 ```
 #### Pripremite pravila
 
-Koristite ovaj skript da preuzmete i spojite sva yara malware pravila sa github-a: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
+Upotrebite ovaj skript da preuzmete i spojite sve yara malware rules sa github-a: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
-Kreirajte direktorijum _**rules**_ i pokrenite skript. To će kreirati fajl pod nazivom _**malware_rules.yar**_ koji sadrži sva yara pravila za malware.
+Kreirajte direktorijum _**rules**_ i pokrenite skript. Ovo će kreirati fajl pod imenom _**malware_rules.yar**_ koji sadrži sve yara rules za malware.
 ```bash
 wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
 mkdir rules
@@ -38,7 +38,7 @@ yara -w malware_rules.yar folder #Scan the whole folder
 ```
 #### YaraGen: Provera za malware i kreiranje pravila
 
-Možete koristiti alat [**YaraGen**](https://github.com/Neo23x0/yarGen) za generisanje yara rules iz binarne datoteke. Pogledajte ove tutorijale: [**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žete koristiti alat [**YaraGen**](https://github.com/Neo23x0/yarGen) za generisanje yara rules iz binarnog fajla. Pogledajte ove tutorijale: [**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,26 @@ clamscan folderpath #Scan the whole folder
 ```
 ### [Capa](https://github.com/mandiant/capa)
 
-**Capa** otkriva potencijalno zlonamerne **sposobnosti** u izvršnim fajlovima: PE, ELF, .NET. Dakle, pronaći će stvari kao što su Att\&ck tactics, ili sumnjive **sposobnosti** kao što su:
+**Capa** otkriva potencijalno maliciozne **capabilities** u izvršnim fajlovima: PE, ELF, .NET. Dakle, pronaći će stvari kao što su Att\&ck tactics, ili sumnjive capabilities kao što su:
 
-- provera OutputDebugString greške
+- proverava OutputDebugString grešku
-- pokretanje kao servis
+- pokreće se kao servis
-- kreiranje procesa
+- kreira proces
 
-Preuzmi ga iz [**Github repo**](https://github.com/mandiant/capa).
+Preuzmite ga na [**Github repo**](https://github.com/mandiant/capa).
 
 ### IOCs
 
-IOC znači Indicator Of Compromise. IOC je skup **uslova koji identifikuju** neki potencijalno neželjeni softver ili potvrđeni **malware**. Blue Teams koriste ovu vrstu definicije da bi **pretražili ovu vrstu malicioznih fajlova** u svojim **sistemima** i **mrežama**.\
+IOC means Indicator Of Compromise. IOC je skup **uslova koji identifikuju** neki potencijalno neželjeni softver ili potvrđeni **malware**. Blue Teams koriste ovu vrstu definicije da **pretraže ovu vrstu malicioznih fajlova** u svojim **sistemima** i **mrežama**.\
-Delijenje ovih definicija je veoma korisno, jer kada se malware identifikuje na računaru i za njega se kreira IOC, druge Blue Teams mogu koristiti taj IOC da brže identifikuju malware.
+Deljenje ovih definicija je veoma korisno: kada se malware identifikuje na računaru i kreira IOC za taj malware, druge Blue Teams mogu koristiti taj IOC da brže identifikuju malware.
 
-Alat za kreiranje ili modifikovanje IOC-ova je [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html).\
+Alat za kreiranje ili izmenu IOCs je [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
-Možete koristiti alate kao što je [**Redline**](https://www.fireeye.com/services/freeware/redline.html) da **pretražite definisane IOC-ove na uređaju**.
+Možete koristiti alate kao što su [**Redline**](https://www.fireeye.com/services/freeware/redline.html) da **pretražite definisane IOCs na uređaju**.
 
 ### Loki
 
 [**Loki**](https://github.com/Neo23x0/Loki) je skener za Simple Indicators of Compromise.\
-Detekcija se zasniva na četiri metode detekcije:
+Detekcija se zasniva na četiri detection methods:
 ```
 1. File Name IOC
 Regex match on full file path/name
@@ -92,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/) je malware skener za Linux objavljen pod licencom GNU GPLv2, koji je dizajniran za pretnje sa kojima se susreću okruženja deljenog hostinga. Koristi podatke o pretnjama iz sistema za detekciju upada na mrežnoj ivici da bi izdvojio malware koji se aktivno koristi u napadima i generisao potpise za detekciju. Pored toga, podaci o pretnjama se takođe izvlače iz korisničkih prijava pomoću LMD checkout feature i iz resursa malware zajednice.
+[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) je malware skener za Linux izdat pod GNU GPLv2 licencom, dizajniran za pretnje sa kojima se suočavaju okruženja sa deljenim hostingom. Koristi podatke o pretnjama iz sistema za detekciju upada na ivici mreže da bi izdvojio malware koji se aktivno koristi u napadima i generiše signatures za detekciju. Pored toga, podaci o pretnjama se takođe dobijaju iz korisničkih prijava preko LMD checkout feature i iz malware community resources.
 
 ### rkhunter
 
-Alati poput [**rkhunter**](http://rkhunter.sourceforge.net) mogu se koristiti za proveru datotečnog sistema u potrazi za mogućim rootkits i malware.
+Alati poput [**rkhunter**](http://rkhunter.sourceforge.net) mogu se koristiti za proveru datotečnog sistema zbog mogućih **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) je alat koji pokušava da pronađe obfuscated strings unutar executables koristeći različite tehnike.
+[**FLOSS**](https://github.com/mandiant/flare-floss) je alat koji pokušava da pronađe obfuskovane stringove unutar izvršnih datoteka koristeći različite tehnike.
 
 ### PEpper
 
-[PEpper ](https://github.com/Th3Hurrican3/PEpper)checks some basic stuff inside the executable (binary data, entropy, URLs and IPs, some yara rules).
+[PEpper ](https://github.com/Th3Hurrican3/PEpper)checks neke osnovne informacije unutar izvršne datoteke (binarni podaci, entropija, URLs and IPs, some yara rules).
 
 ### PEstudio
 
-[PEstudio](https://www.winitor.com/download) je alat koji omogućava dobijanje informacija o Windows executables kao što su imports, exports, headers, ali će takođe proveriti virus total i pronaći potencijalne Att\&ck tehnike.
+[PEstudio](https://www.winitor.com/download) je alat koji omogućava dobijanje informacija o Windows izvršnim datotekama kao što su imports, exports, headers, ali takođe će proveriti virus total i pronaći potencijalne Att\&ck tehnike.
 
 ### Detect It Easy(DiE)
 
-[**DiE**](https://github.com/horsicq/Detect-It-Easy/) je alat za detekciju da li je fajl encrypted i takođe pronalaženje packers.
+[**DiE**](https://github.com/horsicq/Detect-It-Easy/) je alat koji detektuje da li je fajl **šifrovan** i takođe pronalazi **packers**.
 
 ### NeoPI
 
-[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)je Python skript koji koristi različite statistical methods da bi detektovao obfuscated i encrypted sadržaj unutar text/script files. Namena NeoPI-ja je da pomogne pri detekciji hidden web shell code.
+[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is Python skripta koja koristi razne **statističke metode** za detekciju **obfuskovanog** i **šifrovanog** sadržaja u tekstualnim/skript fajlovima. Namena NeoPI-ja je da pomogne u **detekciji skrivenog web shell koda**.
 
 ### **php-malware-finder**
 
-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) čini sve što može da detektuje obfuscated/dodgy code kao i fajlove koji koriste PHP funkcije često korišćene u malwares/webshells.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) se trudi da detektuje **obfuskovan**/**sumnjiv kod** kao i fajlove koji koriste **PHP** funkcije često korišćene u **malwares**/webshells.
 
 ### Apple Binary Signatures
 
-Prilikom provere nekog malware sample-a uvek treba proveriti signature binarnog fajla, jer developer koji ga je potpisao može već biti povezan sa malware-om.
+Kada proveravate neki **malware sample** uvek bi trebalo da **proverite potpis** binarija, jer autor koji ga je potpisao može već biti **povezan** sa **malware**.
 ```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
 
-Ako znate da je neki direktorijum koji sadrži **fajlove** web servera bio **poslednji put ažuriran na neki datum**, **proverite** **datum** kada su svi **fajlovi** na **web serveru** kreirani i izmenjeni, i ako je neki datum **sumnjiv**, proverite taj fajl.
+Ako znate da je neki folder koji sadrži **fajlove** web servera bio **poslednji put ažuriran na neki datum**, **proverite** **datume** kada su svi **fajlovi** na **web serveru** kreirani i izmenjeni, i ako je neki datum **sumnjiv**, proverite taj fajl.
 
-### Baselines
+### Referentno stanje
 
-Ako fajlovi u direktorijumu **ne bi trebalo da budu izmenjeni**, možete izračunati **hash** **originalnih fajlova** direktorijuma i **uporediti** ih sa **trenutnim**. Sve što je izmenjeno biće **sumnjivo**.
+Ako **fajlovi** u folderu **ne bi trebalo da budu izmenjeni**, možete izračunati **hash** **originalnih fajlova** foldera i **uporediti** ih sa **trenutnim**. Sve što je izmenjeno biće **sumnjivo**.
 
-### Statistical Analysis
+### Statistička analiza
 
-Kada se informacije čuvaju u logovima, možete **proveriti statistiku, npr. koliko puta je svaki fajl na web serveru bio pristupan — web shell može biti jedan od najčešće pristupanih**.
+Kada se informacije čuvaju u logovima možete **proveriti statistiku, npr. koliko puta je pristupljeno svakom fajlu web servera**, jer web shell može biti jedan od najčešće pristupanih.
 
 ---
 
-### Android in-app native telemetry (no root)
+### Android telemetrija native koda unutar aplikacije (bez root-a)
 
-On Android, you can instrument native code inside the target app process by preloading a tiny logger library before other JNI libs initialize. This gives early visibility into native behavior without system-wide hooks or root. A popular approach is SoTap: drop libsotap.so for the right ABI into the APK and inject a System.loadLibrary("sotap") call early (e.g., static initializer or Application.onCreate), then collect logs from internal/external paths or Logcat fallback.
+Na Androidu možete instrumentisati native kod unutar procesa ciljane aplikacije tako što ćete unapred učitati malu biblioteku za logovanje pre nego što se ostale JNI biblioteke inicijalizuju. Ovo daje ranu vidljivost native ponašanja bez sistemskih hookova ili root pristupa. Popularan pristup je SoTap: ubacite libsotap.so za odgovarajući ABI u APK i injektujte poziv System.loadLibrary("sotap") rano (npr. static initializer ili Application.onCreate), zatim prikupite logove iz internog/eksternog puta ili koristite Logcat kao fallback.
 
-See the Android native reversing page for setup details and log paths:
+Pogledajte stranicu za Android native reversing za detalje podešavanja i putanje logova:
 
 {{#ref}}
 ../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
@@ -165,11 +165,11 @@ See the Android native reversing page for setup details and log paths:
 
 ---
 
-## Deobfuskovanje dinamičkog kontrolnog toka (JMP/CALL RAX Dispatchers)
+## Deobfuskacija dinamičkog 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.
+Moderne porodice malvera intenzivno zloupotrebljavaju Control-Flow Graph (CFG) obfuscation: umesto direktnog jump/call oni izračunavaju destinaciju u runtime-u i izvršavaju `jmp rax` ili `call rax`. Mali *dispatcher* (obično devet instrukcija) postavlja finalni cilj u zavisnosti od CPU `ZF`/`CF` zastavica, što potpuno razbija statički oporavak CFG-a.
 
-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.
+Tehniku — prikazanu u SLOW#TEMPEST loaderu — moguće je razbiti trostepenim tokom rada koji se oslanja samo na IDAPython i Unicorn CPU emulator.
 
 ### 1. Pronađite svaki indirektni jump / call
 ```python
@@ -195,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. Emulirajte ga dva puta koristeći Unicorn
+### 3. Emuliraj to dvaput pomoću Unicorn
 ```python
 from unicorn import *
 from unicorn.x86_const import *
@@ -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)
 ```
-Pokrenite `run(code,0,0)` i `run(code,1,1)` да бисте добили *false* и *true* циљеве грана.
+Pokreni `run(code,0,0)` i `run(code,1,1)` da dobiješ ciljeve grana *false* i *true*.
 
-### 4. Вратите (patch back) директни jump / call
+### 4. Vraćanje direktnog jump / call-a
 ```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))
 ```
-Nakon patching-a, naterajte IDA da ponovo analizira funkciju kako bi se kompletan CFG i Hex-Rays izlaz obnovili:
+Nakon patching, naterajte IDA da ponovo analizira funkciju tako da se kompletan CFG i Hex-Rays izlaz vrate:
 ```python
 import ida_auto, idaapi
 idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
 ```
-### 5. Obeležite indirektne API pozive
+### 5. Označavanje indirektnih API poziva
 
-Kada je stvarna destinacija svakog `call rax` poznata, možete reći IDA-u šta je to tako da se tipovi parametara i imena promenljivih automatski rekonstrušu:
+Kada je stvarna destinacija svakog `call rax` poznata, možete reći IDA-u šta je to, tako da se tipovi parametara & imena promenljivih automatski obnove:
 ```python
 idc.set_callee_name(call_ea, resolved_addr, 0)  # IDA 8.3+
 ```
 ### Praktične prednosti
 
-* Vraća stvarni CFG → dekompilacija prelazi sa *10* linija na na hiljade.
+* Vraća stvarni CFG → decompilation prelazi sa *10* linija na hiljade.
 * Omogućava string-cross-reference & xrefs, čineći rekonstrukciju ponašanja trivijalnom.
-* Scripts su ponovo upotrebljive: ubaci ih u bilo koji loader zaštićen istim trikom.
+* Scripts su ponovo upotrebljivi: ubaci ih u bilo koji loader zaštićen istim trikom.
 
 ---
 
-## References
+## AdaptixC2: Ekstrakcija konfiguracije i TTPs
+
+Pogledajte posvećenu stranicu:
+
+{{#ref}}
+adaptixc2-config-extraction-and-ttps.md
+{{#endref}}
+
+## Referencije
 
 - [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}}