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

2025-10-10 18:36:50 +00:00 · 2025-09-30 09:12:08 +00:00 · 2025-09-30 09:12:08 +00:00 · f2ee1ecbb6
commit f2ee1ecbb6
parent 9ba5c9abe4
3 changed files with 293 additions and 40 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -37,6 +37,7 @@
  - [Mobile Phishing Malicious Apps](generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md)
  - [Phishing Files & Documents](generic-methodologies-and-resources/phishing-methodology/phishing-documents.md)
 - [Basic Forensic Methodology](generic-methodologies-and-resources/basic-forensic-methodology/README.md)
+  - [Adaptixc2 Config Extraction And Ttps](generic-methodologies-and-resources/basic-forensic-methodology/adaptixc2-config-extraction-and-ttps.md)
  - [Baseline Monitoring](generic-methodologies-and-resources/basic-forensic-methodology/file-integrity-monitoring.md)
  - [Anti-Forensic Techniques](generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md)
  - [Docker Forensics](generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.md)
@ -130,6 +131,7 @@
    - [Seccomp](linux-hardening/privilege-escalation/docker-security/seccomp.md)
    - [Weaponizing Distroless](linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md)
  - [Escaping from Jails](linux-hardening/privilege-escalation/escaping-from-limited-bash.md)
+  - [Posix Cpu Timers Toctou Cve 2025 38352](linux-hardening/privilege-escalation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
  - [euid, ruid, suid](linux-hardening/privilege-escalation/euid-ruid-suid.md)
  - [Interesting Groups - Linux Privesc](linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md)
    - [lxd/lxc Group - Privilege escalation](linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md)
@ -771,7 +773,7 @@
    - [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md)
  - [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
  - [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md)
-  - [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md)
+  - [ROP & JOP](binary-exploitation/rop-return-oriented-programing/README.md)
  - [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md)
  - [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md)
  - [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md)
@ -840,6 +842,7 @@
  - [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md)
  - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md)
 - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md)
+- [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
 - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
 - [iOS Exploiting](binary-exploitation/ios-exploiting/README.md)
  - [ios CVE-2020-27950-mach_msg_trailer_t](binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md)
@ -937,6 +940,4 @@
 - [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md)
 - [Post Exploitation](todo/post-exploitation.md)
 - [Investment Terms](todo/investment-terms.md)
- [Cookies Policy](todo/cookies-policy.md)
-
-  - [Posix Cpu Timers Toctou Cve 2025 38352](linux-hardening/privilege-escalation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
+- [Cookies Policy](todo/cookies-policy.md)
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/adaptixc2-config-extraction-and-ttps.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/adaptixc2-config-extraction-and-ttps.md
@ -0,0 +1,243 @@
+# AdaptixC2 Yapılandırma Çıkarımı ve TTPs
+
+{{#include ../../banners/hacktricks-training.md}}
+
+AdaptixC2, Windows x86/x64 beacons (EXE/DLL/service EXE/raw shellcode) ve BOF desteğine sahip modüler, open‑source post‑exploitation/C2 framework'üdür. Bu sayfa şunları belgeliyor:
+- RC4‑packed yapılandırmasının beacons içine nasıl gömüldüğünü ve beacons'tan nasıl çıkarılacağını
+- HTTP/SMB/TCP listener'ları için ağ/profil göstergeleri
+- Gerçek dünyada gözlemlenen yaygın loader ve persistence TTPs'leri; ilgili Windows teknik sayfalarına bağlantılar ile
+
+## Beacon profilleri ve alanları
+
+AdaptixC2 üç ana beacon tipini destekler:
+- BEACON_HTTP: yapılandırılabilir servers/ports/SSL, method, URI, headers, user‑agent ve özel bir parameter name ile web C2
+- BEACON_SMB: named‑pipe peer‑to‑peer C2 (intranet)
+- BEACON_TCP: protokol başlangıcını gizlemek için isteğe bağlı olarak öne konan bir marker ile direct sockets
+
+HTTP beacon konfigürasyonlarında gözlemlenen tipik profil alanları (şifre çözme sonrasında):
+- 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) – response boyutlarını parse etmek için kullanılır
+- 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
+}
+```
+Gözlemlenen kötü amaçlı HTTP profili (gerçek saldırı):
+```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
+}
+```
+## Şifrelenmiş yapılandırma paketleme ve yükleme yolu
+
+Operatör builder'da Create'a tıkladığında, AdaptixC2 şifrelenmiş profili beacon'ın sonuna bir tail blob olarak gömer. Formatı:
+- 4 bayt: yapılandırma boyutu (uint32, little‑endian)
+- N bayt: RC4 ile şifrelenmiş yapılandırma verisi
+- 16 bayt: RC4 anahtarı
+
+Beacon loader sondan 16 baytlık anahtarı kopyalar ve N baytlık bloğu yerinde RC4 ile çözer:
+```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:
+- Tüm yapı genellikle PE .rdata bölümünün içinde bulunur.
+- Çıkarma işlemi deterministiktir: boyutu oku, o boyutta ciphertext oku, hemen ardından yerleştirilen 16‑byte anahtarı oku, ardından RC4‑decrypt uygula.
+
+## Konfigürasyon çıkarma iş akışı (savunucular)
+
+Write an extractor that mimics the beacon logic:
+1) PE içinde blob'u bulun (çoğunlukla .rdata). Pragmatik bir yaklaşım, .rdata'ı olası bir [size|ciphertext|16‑byte key] düzeni için taramak ve RC4 denemektir.
+2) İlk 4 bytes'ı oku → size (uint32 LE).
+3) Sonraki N=size bytes'ı oku → ciphertext.
+4) Son 16 bytes'ı oku → RC4 key.
+5) Ciphertext'i RC4‑decrypt edin. Sonra düz metin profili şu şekilde ayrıştırın:
+- u32/boolean scalars yukarıda belirtildiği gibi
+- length‑prefixed strings (u32 length followed by bytes; trailing NUL bulunabilir)
+- arrays: servers_count ardından o kadar [string, u32 port] çifti
+
+Önceden çıkarılmış bir blob ile çalışan minimal Python proof‑of‑concept (standalone, harici bağımlılık yok):
+```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)
+```
+İpuçları:
+- Otomasyon yaparken, .rdata okumak için bir PE parser kullanın ve ardından sliding window uygulayın: her offset o için size = u32(.rdata[o:o+4]) deneyin, ct = .rdata[o+4:o+4+size], aday anahtar = sonraki 16 byte; RC4‑decrypt uygulayıp string alanların UTF‑8 olarak çözüldüğünü ve uzunlukların makul olduğunu kontrol edin.
+- SMB/TCP profillerini aynı length‑prefixed kurallarını takip ederek parse edin.
+
+## Network fingerprinting and hunting
+
+HTTP
+- Yaygın: operator‑selected URI’lere POST (ör. /uri.php, /endpoint/api)
+- Beacon ID için kullanılan custom header parametresi (ör. X‑Beacon‑Id, X‑App‑Id)
+- Firefox 20 veya o dönemin Chrome build’lerini taklit eden User‑agents
+- sleep_delay/jitter_delay ile görülebilen polling cadence
+
+SMB/TCP
+- Web egress’in kısıtlı olduğu intranet C2 için SMB named‑pipe dinleyicileri
+- TCP beacon’lar protokol başlangıcını obfuscate etmek için trafik öncesi birkaç byte ekleyebilir
+
+## Loader and persistence TTPs seen in incidents
+
+In‑memory PowerShell loaders
+- Base64/XOR payload’lar indirir (Invoke‑RestMethod / WebClient)
+- unmanaged memory allocate eder, shellcode kopyalar, VirtualProtect ile korumayı 0x40 (PAGE_EXECUTE_READWRITE) olarak değiştirir
+- .NET dynamic invocation ile çalıştırır: Marshal.GetDelegateForFunctionPointer + delegate.Invoke()
+
+In‑memory execution ve AMSI/ETW ile ilgili hususlar için bu sayfaları kontrol edin:
+
+{{#ref}}
+../../windows-hardening/av-bypass.md
+{{#endref}}
+
+Gözlemlenen persistence mekanizmaları
+- Logon’da bir loader’ı yeniden başlatmak için Startup klasöründe shortcut (.lnk)
+- Registry Run anahtarları (HKCU/HKLM ...\CurrentVersion\Run), genellikle "Updater" gibi masum görünen isimlerle loader.ps1’i başlatmak için
+- msimg32.dll gibi DLL dosyasını %APPDATA%\Microsoft\Windows\Templates altına bırakıp susceptible process’lerde DLL search‑order hijack
+
+Tekniğe dair derinlemesine incelemeler ve kontrol listesi:
+
+{{#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 fikirleri
+- PowerShell içinde RW→RX geçişleri: powershell.exe içinde VirtualProtect ile PAGE_EXECUTE_READWRITE
+- Dynamic invocation pattern’ları (GetDelegateForFunctionPointer)
+- Kullanıcı veya common Startup klasörleri altındaki .lnk’ler
+- Şüpheli Run anahtarları (ör. "Updater") ve update.ps1/loader.ps1 gibi loader isimleri
+- %APPDATA%\Microsoft\Windows\Templates altında kullanıcı tarafından yazılabilir DLL yolları ve içinde msimg32.dll bulunan dosyalar
+
+## Notes on OpSec fields
+
+- KillDate: agent’in kendini geçersiz kılacağı zaman damgası
+- WorkingTime: agent’in iş aktivitesiyle karışmak için aktif olması gereken saatler
+
+Bu alanlar kümelendirme için kullanılabilir ve gözlemlenen sessiz dönemleri açıklamaya yardımcı olur.
+
+## YARA and static leads
+
+Unit 42, beacon’lar (C/C++ ve Go) ve loader API‑hashing sabitleri için temel YARA yayınladı. PE .rdata sonu yakınında [size|ciphertext|16‑byte‑key] düzenini ve varsayılan HTTP profile string’lerini arayan kurallarla tamamlamayı düşünün.
+
+## 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
@ -14,7 +14,7 @@
 - [Intezer](https://analyze.intezer.com)
 - [Any.Run](https://any.run/)

-## Çevrimdışı Antivirüs ve Tespit Araçları
+## Çevrimdışı Antivirus ve Tespit Araçları

 ### Yara

@ -24,8 +24,8 @@ sudo apt-get install -y yara
 ```
 #### Kuralları hazırla

-Bu scripti, github'dan tüm yara malware kurallarını indirmek ve birleştirmek için kullanın: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
-_**rules**_ dizinini oluşturun ve scripti çalıştırın. Bu, tüm yara malware kurallarını içeren _**malware_rules.yar**_ adlı bir dosya oluşturacaktır.
+Bu script'i kullanarak github'dan tüm yara malware kurallarını indirip birleştirin: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
+Create the _**rules**_ directory and execute it. This will create a file called _**malware_rules.yar**_ which contains all the yara rules for 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: malware kontrolü ve kural oluşturma
+#### YaraGen: malware kontrolü ve kurallar oluşturma

-Bir binary'den yara rules oluşturmak için [**YaraGen**](https://github.com/Neo23x0/yarGen) aracını kullanabilirsiniz. Bu öğreticilere göz atın: [**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/)
+Bir binary'den yara rules oluşturmak için [**YaraGen**](https://github.com/Neo23x0/yarGen) aracını kullanabilirsiniz. Bu eğitimlere göz atın: [**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**, yürütülebilir dosyalarda: PE, ELF, .NET, potansiyel olarak kötü amaçlı **capabilities** tespit eder. Böylece Att\&ck tactics gibi şeyleri veya şu tür şüpheli capabilities'leri bulur:
+**Capa** PE, ELF, .NET gibi çalıştırılabilirlerde potansiyel olarak kötü amaçlı **capabilities** tespit eder. Bu nedenle Att\&ck taktikleri veya şu tür şüpheli yetenekleri bulur:

- OutputDebugString hatası için kontrol etme
+- OutputDebugString hatasını kontrol etme
 - servis olarak çalıştırma
- süreç oluşturma
+- process oluşturma

 Edinin: [**Github repo**](https://github.com/mandiant/capa).

 ### IOCs

-IOC, Indicator Of Compromise anlamına gelir. Bir IOC, potansiyel olarak istenmeyen yazılımları veya teyit edilmiş **malware**'i tanımlayan bir dizi **koşuldur**. Blue Teams bu tür tanımları **bu tür kötü amaçlı dosyaları aramak** için kendi **sistemlerinde** ve **ağlarında** kullanır.\
+IOC, Indicator Of Compromise anlamına gelir. IOC, potansiyel olarak istenmeyen yazılımları veya doğrulanmış **malware**'i **tanımlayan koşulların** bir kümesidir. Blue Teams bu tür tanımları kendi **sistemlerinde** ve **ağlarında** bu tür kötü amaçlı dosyaları **aramak** için kullanır.\
 Bu tanımları paylaşmak çok faydalıdır; çünkü bir bilgisayarda malware tespit edildiğinde ve o malware için bir IOC oluşturulduğunda, diğer Blue Teams bunu kullanarak malware'i daha hızlı tespit edebilir.

-IOC oluşturmak veya değiştirmek için bir araç [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
-Tanımlı IOC'leri bir cihazda aramak için [**Redline**](https://www.fireeye.com/services/freeware/redline.html) gibi araçları kullanabilirsiniz.
+IOC oluşturmak veya değiştirmek için bir araç [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html).\
+[**Redline**](https://www.fireeye.com/services/freeware/redline.html) gibi araçları kullanarak **bir cihazda tanımlanmış IOC'leri arayabilirsiniz**.

 ### Loki

 [**Loki**](https://github.com/Neo23x0/Loki) Simple Indicators of Compromise için bir tarayıcıdır.\
-Tespit dört farklı yönteme dayanır:
+Tespit, dört algılama yöntemine dayanır:
 ```
 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/) GNU GPLv2 lisansı altında yayımlanan ve paylaşılan hosting ortamlarında karşılaşılan tehditlere göre tasarlanmış bir Linux malware tarayıcısıdır. Saldırılarda aktif olarak kullanılan malware'leri çıkarmak ve tespit için imzalar üretmek amacıyla ağ kenarı saldırı tespit sistemlerinden gelen tehdit verilerini kullanır. Ayrıca tehdit verileri, LMD checkout özelliğiyle yapılan kullanıcı gönderimleri ve malware topluluk kaynaklarından da elde edilir.
+[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) Linux için GNU GPLv2 lisansı altında yayımlanmış bir malware tarayıcısıdır; paylaşılan barındırma ortamlarında karşılaşılan tehditler göz önünde bulundurularak tasarlanmıştır. Ağ kenarında bulunan intrusion detection systems'ten gelen tehdit verilerini kullanarak saldırılarda aktif olarak kullanılan malware'leri tespit eder ve tespit için imzalar oluşturur. Ayrıca tehdit verileri, LMD'nin checkout özelliğiyle yapılan kullanıcı gönderimlerinden ve malware topluluk kaynaklarından da elde edilir.

 ### rkhunter

-Tools like [**rkhunter**](http://rkhunter.sourceforge.net) can be used to check the filesystem for possible **rootkits** and malware.
+[**rkhunter**](http://rkhunter.sourceforge.net) gibi araçlar, olası **rootkits** ve malware için dosya sistemini kontrol etmek amacıyla kullanılabilir.
 ```bash
 sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
 ```
 ### FLOSS

-[**FLOSS**](https://github.com/mandiant/flare-floss) farklı teknikler kullanarak executables içindeki obfuscated strings'i bulmaya çalışan bir araçtır.
+[**FLOSS**](https://github.com/mandiant/flare-floss) farklı teknikler kullanarak yürütülebilir dosyaların içinde obfuscated strings bulmaya çalışacak bir araçtır.

 ### PEpper

-[PEpper ](https://github.com/Th3Hurrican3/PEpper)executable içinde bazı temel şeyleri kontrol eder (binary data, entropy, URLs and IPs, some yara rules).
+[PEpper ](https://github.com/Th3Hurrican3/PEpper) yürütülebilir dosya içinde bazı temel şeyleri kontrol eder (binary data, entropy, URLs and IPs, some yara rules).

 ### PEstudio

-[PEstudio](https://www.winitor.com/download) Windows executables hakkında imports, exports, headers gibi bilgiler almayı sağlar; ayrıca virus total'u kontrol eder ve potansiyel Att\&ck tekniklerini bulur.
+[PEstudio](https://www.winitor.com/download) imports, exports, headers gibi Windows yürütülebilirleriyle ilgili bilgiler almayı sağlayan bir araçtır; ayrıca virus total'u kontrol eder ve potansiyel Att\&ck tekniklerini bulur.

 ### Detect It Easy(DiE)

-[**DiE**](https://github.com/horsicq/Detect-It-Easy/) bir dosyanın **encrypted** olup olmadığını tespit etmek ve **packers**'ı bulmak için bir araçtır.
+[**DiE**](https://github.com/horsicq/Detect-It-Easy/) bir dosyanın **encrypted** olup olmadığını tespit etmek ve ayrıca **packers** bulmak için bir araçtır.

 ### NeoPI

-[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is bir Python scriptidir ve text/script dosyalar içindeki **obfuscated** ve **encrypted** content'i tespit etmek için çeşitli **statistical methods** kullanır. NeoPI'nin amaçlarından biri **detection of hidden web shell code**'a yardımcı olmaktır.
+[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) metin/script dosyaları içinde **obfuscated** ve **encrypted** içeriği tespit etmek için çeşitli **statistical methods** kullanan bir Python scriptidir. NeoPI'nin amacı, **gizli web shell kodunun tespitine** yardımcı olmaktır.

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

-[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) **obfuscated**/**dodgy code**'ları ve sıklıkla **malwares**/webshells içinde kullanılan **PHP** fonksiyonlarını kullanan dosyaları tespit etmek için elinden geleni yapar.
+[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) **obfuscated**/**dodgy code** ve **malwares**/webshell'lerde sık kullanılan **PHP** fonksiyonlarını kullanan dosyaları tespit etmek için elinden geleni yapar.

 ### Apple Binary Signatures

-Bazı **malware sample**'larını incelerken, binary'nin **check the signature**'ını her zaman kontrol etmelisiniz çünkü imzalayan **developer** zaten **related** with **malware** olabilir.
+Bir **malware sample** incelerken, ikili dosyanın **check the signature**'ını her zaman yapmalısınız; imzalayan **developer** zaten **related** with **malware** olabilir.
 ```bash
 #Get signer
 codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -137,25 +137,25 @@ codesign --verify --verbose /Applications/Safari.app
 #Check if the signature is valid
 spctl --assess --verbose /Applications/Safari.app
 ```
-## Detection Techniques
+## Tespit Teknikleri

 ### File Stacking

-Eğer bir klasörün, bir web sunucusunun **files**ını içerdiğini ve **last updated on some date** olduğunu biliyorsanız. Web sunucusundaki tüm **files**ın oluşturulma ve değiştirilme **date**lerini **Check** edin; eğer herhangi bir tarih **suspicious** ise o dosyayı inceleyin.
+Eğer bir klasörün, web server'ın **dosyalarını** içerdiğini ve **son olarak belirli bir tarihte** güncellendiğini biliyorsanız, web server'daki tüm **dosyaların** oluşturulma ve değiştirilme **tarihlerini** **kontrol edin**; eğer herhangi bir tarih **şüpheli** ise o dosyayı inceleyin.

 ### Baselines

-Eğer bir klasörün **files**ı **shouldn't have been modified** ise, klasörün **original files**ının **hash**ini hesaplayıp bunları **current** olanlarla **compare** edebilirsiniz. Değişmiş olan herhangi bir şey **suspicious** olacaktır.
+Bir klasörün dosyaları **değiştirilmemiş olması gerekiyorsa**, klasörün **orijinal dosyalarının** **hash**'ini hesaplayıp bunları **şimdiki** dosyalarla **karşılaştırabilirsiniz**. Değiştirilmiş olan her şey **şüpheli** olacaktır.

 ### Statistical Analysis

-Bilgiler loglarda saklandığında, bir web shell en çok erişilenlerden biri olabileceği için her bir web sunucusu dosyasının kaç kez erişildiği gibi istatistikleri **check** edebilirsiniz.
+Bilgiler log'larda saklanıyorsa, örneğin her bir web server dosyasının kaç kez erişildiği gibi istatistikleri **kontrol edebilirsiniz**, çünkü bir web shell en çok erişilenlerden biri olabilir.

 ---

 ### Android in-app native telemetry (no root)

-Android'de, hedef uygulama sürecinin içindeki native kodu diğer JNI kütüphaneleri initialize olmadan önce küçük bir logger kütüphanesini preload ederek instrument edebilirsiniz. Bu, sistem çapında hook'lara veya root'a ihtiyaç duymadan native davranışa erken görünürlük sağlar. Popüler bir yaklaşım SoTap'tır: doğru ABI için libsotap.so'yu APK'ye koyun ve erken bir noktada System.loadLibrary("sotap") çağrısı enjekte edin (örn. static initializer veya Application.onCreate), ardından logları internal/external yollarından veya Logcat fallback'ten toplayın.
+Android üzerinde, hedef uygulama süreci içinde diğer JNI kütüphaneleri initialize olmadan önce küçük bir logger kütüphanesini önceden yükleyerek native kodu enstrümante edebilirsiniz. Bu, sistem çapı hook veya root gerektirmeden native davranış hakkında erken görünürlük sağlar. Yaygın bir yaklaşım SoTap: uygun ABI için libsotap.so'yu APK'ya bırakıp erken bir noktaya System.loadLibrary("sotap") çağrısı enjekte etmek (ör. static initializer veya Application.onCreate), ardından logları internal/external yollarından veya Logcat fallback ile toplamak.

 See the Android native reversing page for setup details and log paths:

@ -167,7 +167,7 @@ See the Android native reversing page for setup details and log paths:

 ## Deobfuscating Dynamic Control-Flow (JMP/CALL RAX Dispatchers)

-Modern malware families heavily abuse Control-Flow Graph (CFG) obfuscation: instead of a direct jump/call they compute the destination at run-time and execute a `jmp rax` or `call rax`.  A small *dispatcher* (typically nine instructions) sets the final target depending on the CPU `ZF`/`CF` flags, completely breaking static CFG recovery.
+Modern malware aileleri Control-Flow Graph (CFG) obfuscation'ı yoğun şekilde kötüye kullanıyor: doğrudan bir jump/call yerine hedefi çalışma zamanında hesaplayıp `jmp rax` veya `call rax` yürütüyorlar. Küçük bir *dispatcher* (genellikle dokuz talimat) CPU `ZF`/`CF` flag'lerine bağlı olarak nihai hedefi ayarlar ve bu, statik CFG kurtarmayı tamamen bozar.

 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.

@ -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. Unicorn ile bunu iki kez emüle et
+### 3. Unicorn ile iki kez emüle et
 ```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)
 ```
-`run(code,0,0)` ve `run(code,1,1)` komutlarını çalıştırarak *false* ve *true* branch hedeflerini elde edin.
+`run(code,0,0)` ve `run(code,1,1)` komutlarını çalıştırarak *false* ve *true* dallanma hedeflerini elde edin.

-### 4. Doğrudan jump / call'ı geri patch'layın
+### 4. Doğrudan jump / call'ı geri yama
 ```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))
 ```
-Patching yaptıktan sonra, IDA'yı fonksiyonu yeniden analiz etmeye zorlayın, böylece tam CFG ve Hex-Rays çıktısı geri yüklenir:
+After patching, IDA'nın fonksiyonu yeniden analiz etmesini zorlayın, böylece tam CFG ve Hex-Rays çıktıları geri yüklenir:
 ```python
 import ida_auto, idaapi
 idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
 ```
 ### 5. Dolaylı API çağrılarını etiketleyin

-Her `call rax`'in gerçek hedefi belirlendiğinde IDA'ya bunun ne olduğunu söyleyebilirsiniz, böylece parametre tipleri & değişken adları otomatik olarak geri kazanılır:
+Her `call rax` için gerçek hedef belirlendiğinde, IDA'ya bunun ne olduğunu söyleyebilirsiniz; böylece parametre türleri & değişken adları otomatik olarak belirlenir:
 ```python
 idc.set_callee_name(call_ea, resolved_addr, 0)  # IDA 8.3+
 ```
 ### Pratik faydalar

-* Gerçek CFG'yi geri yükler → dekompilasyon *10* satırdan binlerce satıra çıkar.
-* string-cross-reference & xrefs'i etkinleştirir, davranışın yeniden yapılandırılmasını kolaylaştırır.
-* Scripts yeniden kullanılabilir: aynı yöntemi kullanan herhangi bir loader'a yerleştirilebilir.
+* Gerçek CFG'yi geri yükler → decompilation *10* satırdan binlerce satıra çıkar.
+* string-cross-reference & xrefs'i etkinleştirir, bu da davranışın yeniden oluşturulmasını çok kolay hale getirir.
+* Scripts yeniden kullanılabilir: aynı yöntemle korunmuş herhangi bir loader'ın içine koyun.

 ---

+## AdaptixC2: Configuration Extraction and TTPs
+
+Ayrı sayfaya bakın:
+
+{{#ref}}
+adaptixc2-config-extraction-and-ttps.md
+{{#endref}}
+
 ## Kaynaklar

 - [Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques](https://unit42.paloaltonetworks.com/slow-tempest-malware-obfuscation/)
- SoTap: Hafif uygulama içi JNI (.so) davranış kaydedicisi – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
+- 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}}