Translated ['binary-exploitation/heap/README.md', 'binary-exploitation/h

2024-11-25 14:10:41 +00:00 · 2024-05-10 17:40:15 +00:00 · 2024-05-10 17:40:15 +00:00 · 4259ddfc20
commit 4259ddfc20
parent c123ff05a0
8 changed files with 683 additions and 151 deletions
--- a/SUMMARY.md
+++ b/SUMMARY.md
@ -721,7 +721,11 @@
  * [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)
-  * [Use After Free](binary-exploitation/heap/use-after-free.md)
+  * [Bins & Memory Allocations](binary-exploitation/heap/bins-and-memory-allocations.md)
+  * [Heap Functions Security Checks](binary-exploitation/heap/heap-functions-security-checks.md)
+  * [Use After Free](binary-exploitation/heap/use-after-free/README.md)
+    * [First Fit](binary-exploitation/heap/use-after-free/first-fit.md)
+  * [Double Free](binary-exploitation/heap/double-free.md)
  * [Heap Overflow](binary-exploitation/heap/heap-overflow.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)
--- a/binary-exploitation/heap/README.md
+++ b/binary-exploitation/heap/README.md
@ -10,28 +10,28 @@ Görüldüğü gibi, bu bellek, binary belleğe yüklendikten hemen sonra bulunm

 ### 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ılmış olacaktır. Amaç, her parçanın nerede olduğunu bulmayı karmaşık hale getirmeden mümkün olduğunca az bellek rezerve etmektir. Bunun için, kullanılan her parçanın bilgilerini bilmek için parça bilgileri kullanılır.
+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ça için ayrılmış olacaktır. Amacı, her parçanın nerede olduğunu bulmayı karmaşık hale getirmeden mümkün olduğunca az bellek rezerve etmektir. Bunun için, kullanılan/boş parça bilgilerini bilmek için meta veri parça bilgileri kullanılır.

-Kullanılan bine bağlı olarak alanı rezerve etmenin farklı yolları vardır, ancak genel bir metodoloji şöyledir:
+Kullanılan bine bağlı olarak alanı ayırmak için farklı yollar vardır, ancak genel bir metodoloji şöyledir:

 * Program belirli miktarda bellek istemeye başlar.
 * İstek karşılayacak kadar büyük bir parça listesinde varsa, kullanılır.
-* Bu, isteğin bir kısmının kullanılabilir parçadan kullanılacağı ve geri kalanının parçalar listesine ekleneceği anlamına gelebilir.
-* Eğer listede 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 ayrılmak için yeterli heap alanı yoksa, heap yöneticisi kernelden heap'e ayrılan belleği genişletmesini ve ardından bu belleği kullanarak yeni parça oluşturmasını ister.
+* Bu, isteğin bir kısmı için kullanılacak olan mevcut parçanın bir kısmının kullanılacağı ve geri kalanının parça listesine ekleneceği anlamına gelebilir.
+* 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 kernel'den heap'e ayrılan belleği genişletmesini ister ve ardından bu belleği kullanarak yeni parça oluşturur.
 * Her şey başarısız olursa, `malloc` null döner.

-Unutulmamalıdır ki istenen **bellek bir eşiği geçerse**, istenen belleği eşlemek için **`mmap`** kullanılacaktır.
+İstenen belleğin bir **eşik değerini aşması durumunda**, istenen belleği eşlemek için **`mmap`** kullanılacaktır.

 ### Arenalar

-**Çoklu iş parçacıklı** uygulamalarda, heap yöneticisi, çökmelere yol açabilecek **yarış koşullarını** önlemelidir. 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** yapmıştır, ancak bu, kilitleme nedeniyle performans sorunlarına yol açmıştır.
+**Çoklu iş parçacıklı** uygulamalarda, heap yöneticisi, çökmelere yol açabilecek **yarış koşullarını** önlemelidir. Başlangıçta, bunu sadece bir iş parçacığının aynı anda heap'e erişebileceğinden emin olmak için bir **global kilitleme** kullanarak yapılıyordu, ancak bu, kilitleme nedeniyle performans sorunlarına yol açtı.

-Bunu ele almak için, ptmalloc2 heap tahsis edicisi, 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 engellemeden heap işlemleri yapmasına izin verir.
+Bunu ele almak için, ptmalloc2 heap tahsis edicisi, her birinin **kendi** veri **yapıları** ve **kilidi** olan **ayrı bir heap** olarak hareket eden "arenaları" tanıttı, bu da farklı arenaları kullansalar bile birden fazla iş parçacığının birbirini engellemeden 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ı** eklenirken, heap yöneticisi çekişmeyi azaltmak için onlara **ikincil arenalar** atar. İlk olarak, her yeni iş parçacığını kullanılmayan bir arenaya bağlamaya çalışır, gerekirse yeni arenalar oluşturur, 32 bit sistemler için CPU çekirdeklerinin 2 katı ve 64 bit sistemler için 8 katı kadar bir sınıra kadar. Sınır aşıldığında, **iş parçacıkları arenaları paylaşmak zorunda kalır**, bu da potansiyel çekişmelere yol açar.
+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 çekirdekleri için 2 kat, 64 bit sistemler için 8 kat sınırına ulaşana kadar. Sınır aşıldığında, **iş parçacıkları arenaları paylaşmak zorunda kalır**, potansiyel çekişmeye yol açar.

-Ana arenanın aksine, ikincil 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.
+Ana arenanın aksine, `brk` sistem çağrısını kullanarak genişleyen 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şturan ikincil arenalar oluşturur.

 ### Alt Heap'ler

@ -42,144 +42,108 @@ Alt heap'ler, çoklu iş parçacıklı uygulamalardaki ikincil arenalar için be
 * İ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, bir alt heap için ayrılan boyut, 32 bit işlemler için 1 MB ve 64 bit işlemler için 64 MB'dir.
+* 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 kernelin 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, bu da kernelin önceden rezerve edilen adreslere fiziksel bellek tahsis etmesini sağlar. Bu adım adım yaklaşım, alt heap'in ihtiyaç duyuldukça genişlemesine olanak tanır.
-* Tüm alt heap tüketildiğinde, heap yöneticisi devam etmek için yeni bir alt heap oluşturur.
+* Rezerve edilen bellek bölgesi başlangıçta `PROT_NONE` olarak işaretlenir, bu da kernelin bu alana henüz fiziksel bellek tahsis etmesine gerek olmadığını 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, bu da kernelin önceden rezerve edilen adreslere fiziksel bellek tahsis etmesini sağlar. 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 yeni bir alt heap oluşturarak tahsis işlemine devam eder.

-### Meta Veriler
+### malloc\_state

-Daha önce belirtildiği gibi, bu parçaların her birinin bazı meta verileri vardır, bu meta veriler bu resimde çok iyi temsil edilmiştir:
+Her heap'in (ana arena veya diğer iş parçacıklarının arenaları) bir **`malloc_state` yapısı** vardır.\
+Önemli bir nokta, **ana arenanın `malloc_state` yapısının** libc'de **global bir değişken** olduğudur (bu nedenle libc bellek alanında bulunur).\
+İş parçacıklarının arenalarının `malloc_state` yapıları ise **kendi iş parçacığı "heap"lerinin içinde** bulunur.
+
+Bu yapıdan bazı ilginç noktaları not etmek önemlidir (aşağıdaki C koduna bakınız):
+
+* `mchunkptr bins[NBINS * 2 - 2];`, küçük, büyük ve sıralanmamış **binlerin ilk ve son parçalarına işaretçiler** içerir (-2, çünkü indeks 0 kullanılmaz)
+* Dolayısıyla, bu binlerin **ilk parçaları** bu yapıya **ters işaretçiye sahip olacak** ve bu binlerin **son parçaları** bu yapıya **ileri işaretçiye sahip olacaktır**. Bu 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 arenaların bağlı listeleri olduğu
+* `top` parça, temelde **tüm heap hatırlama alanı olan** son "parçadır". Top parça "boş" olduğunda, heap tamamen kullanılmıştır ve daha fazla alan istenmesi gerekir.
+* `last reminder` parça, tam bir boyutta parça mevcut olmadığı durumlardan kaynaklanan, daha büyük bir parça bölündüğünde, geriye kalan kısmın yerleştirildiği bir noktadır.
+```c
+// From https://heap-exploitation.dhavalkapil.com/diving_into_glibc_heap/malloc_state
+struct malloc_state
+{
+/* Serialize access.  */
+__libc_lock_define (, mutex);
+/* Flags (formerly in max_fast).  */
+int flags;
+
+/* 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;
+};
+
+typedef struct malloc_state *mstate;
+```
+### 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
+// From https://heap-exploitation.dhavalkapil.com/diving_into_glibc_heap/malloc_chunk
+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 bazı meta verileri de bulunmaktadır, bu meta veriler bu 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'dir ve son 3 biti kullanarak aşağıdakileri belirtir:
+Meta veriler genellikle mevcut parça boyutunu belirten 0x08B'yi gösterir ve son 3 biti kullanarak aşağıdakileri belirtir:

-* `A`: 1 ise alt heap'ten gelir, 0 ise ana arenadadır
-* `M`: 1 ise bu parça, mmap ile ayrılan bir alana aittir ve heap'in bir parçası değildir
+* `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 mevcut olduğunda (veya ayrıldığında kullanıcı verilerini depolamak için) önceki parça boyutunu belirtmek için 0x08B bulunur.
+Ardından, kullanıcı verileri için alan ve son olarak parça kullanımda değilken (veya ayrıldığında kullanıcı verilerini saklamak için) önceki parça boyutunu belirtmek için 0x08B bulunur.

-Ayrıca, mevcut olduğunda, kullanıcı verileri aynı zamanda bazı verileri de içerecek şekilde kullanılır:
+Ayrıca, kullanılabilir olduğunda, kullanıcı verileri aynı zamanda bazı verileri içerecek şekilde kullanılır:

 * Bir sonraki parçaya işaretçi
 * Önceki parçaya işaretçi
-* Listenin bir sonraki parça boyutu
-* Listenin bir önceki parça boyutu
+* Listede bir sonraki parçanın boyutu
+* Listede önceki parçanın boyutu

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

-Listeyi bu şekilde bağlamak, her bir parçanın kaydedildiği bir diziye ihtiyaç duymadan yapılmasını sağlar.
-
-## Serbest Bırakma Korumaları
-
-Serbest işlevinin kazara veya kasıtlı kötüye kullanımından korunmak için, işlemlerini gerçekleştirmeden önce bazı kontroller yapar:
-
-* Adresin [8 bayt veya 64 bit sınırında](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l4182) hizalandığından emin olur (`(adres % 16) == 0`), çünkü _malloc_ tüm tahsislerin hizalandığından emin olur.
-* Parçanın boyut alanının imkansız olmadığını kontrol eder - ya çok küçük olduğu için, çok büyük olduğu için, hizalanmış bir boyutta olmadığı için veya [işlem adres alanının sonunu aşabileceği için](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l4175).
-* Parçanın arenanın sınırları içinde olduğunu kontrol eder.
-* Parçanın zaten serbest bırakılmış olmadığını kontrol eder, bunu yaparak, başlangıçtaki sonraki parçanın başındaki metadatada bulunan ilgili "P" bitini kontrol eder.
-## Bins
-
-Chunks'ın nasıl depolandığındaki verimliliği artırmak için her bir chunk sadece bir bağlı liste içinde değil, çeşitli tiplerde bulunur. 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ırasız bin, 10 hızlı bins ve her bir iş parçacığı için 64 tcache bins.
-
-Sırasız, küçük ve büyük bins'e ait başlangıç adresi aynı dizinin içindedir. İndeks 0 kullanılmaz, 1 sırasız bin, 2-64 arası küçük bins'ler ve 65-127 arası büyük bins'lerdir.
-
-### Küçük Bins
-
-Küçük bins'ler büyük bins'lerden daha hızlı ancak hızlı bins'lerden daha yavaştır.
-
-62'nin her bir bininde **aynı boyutta parçalar** bulunur: 16, 24, ... (32 bit'te maksimum 504 bayt, 64 bit'te 1024 bayt). Bu, bir alana yer tahsis edileceği binin bulunması, girişlerin bu listelerden çıkarılması ve eklenmesinde hız sağlar.
-
-### Büyük Bins
-
-Küçük bins'lerin aksine, her **büyük bin belirli bir parça boyutu aralığını yönetir**. Bu daha esnek bir yapıdır, çeşitli boyutları **ayrı bir bin olmadan** barındırabilir.
-
-Bir bellek tahsis edicisinde, büyük bins küçük bins'lerin bittiği yerden başlar. Büyük bins'ler için aralıklar giderek büyür, yani ilk bin 512 ila 576 bayt arasındaki parçaları kapsayabilirken, bir sonraki 576 ila 640 baytı kapsar. Bu desen devam eder, en büyük bin 1MB'nin üzerindeki tüm parçaları içerir.
-
-Büyük bins'ler, bir tahsis için en iyi uyumu bulmak için **farklı parça boyutlarının listesini sıralamak ve aramak zorunda olduklarından küçük bins'lere göre daha yavaş çalışır**. Bir parça büyük bir bine eklenirken sıralanmalı ve bellek tahsis edildiğinde sistem doğru parçayı bulmalıdır. Bu ek işlem onları **daha yavaş** yapar, ancak büyük tahsisler küçük olanlardan daha az olduğundan kabul edilebilir bir takas yapılır.
-
-Şunlar vardır:
-
-* 64B aralığından 32 bin
-* 512B aralığından 16 bin
-* 4096B aralığından 8 bin
-* 32768B aralığından 4 bin
-* 262144B aralığından 2 bin
-* Geri kalan boyutlar için 1 bin
-
-### Sırasız Bin
-
-Sırasız bin, bellek tahsisini hızlandırmak için kullanılan bir **hızlı önbellek**tir. İşleyişi şöyledir: Bir program belleği serbest bıraktığında, bellek yöneticisi hemen onu belirli bir bine koymaz. Bunun yerine, önce **bitişik serbest parçalarla birleştirmeye çalışır** ve daha büyük bir serbest bellek bloğu oluşturur. Daha sonra, bu yeni parçayı "sırasız bin" adı verilen genel bir bine yerleştirir.
-
-Bir program **bellek istediğinde**, bellek yöneticisi önce sırasız bin'i kontrol eder ve doğru boyutta bir parça bulunup bulunmadığına bakar. Bir tane bulursa hemen kullanır, bu diğer bins'lerde arama yapmaktan daha hızlıdır. Uygun bir parça bulamazsa, serbest bırakılan parçaları doğru bins'lerine, küçük veya büyük, boyutlarına göre taşır.
-
-Bu nedenle, sırasız bin, bellek tahsisini hızlandırmak için yakın zamanda serbest bırakılan belleği hızlı bir şekilde yeniden kullanarak ve zaman alıcı aramaları ve birleştirmeleri azaltarak bir yol sağlar.
-
-{% hint style="danger" %}
-Farklı kategorilerdeki parçalar bile olsalar, zaman zaman bir kullanılabilir parça başka bir kullanılabilir parça ile çakışıyorsa (farklı kategorilerde olsalar bile), birleştirileceklerdir.
+{% hint style="info" %}
+Listeyi bu şekilde beğenmek, her bir parçanın kaydedildiği bir diziye ihtiyaç duymadan yapılabilir.
 {% endhint %}

-### Hızlı Bins
+### Hızlı Heap Örneği

-Hızlı bins'ler, **küçük parçalar için bellek tahsisini hızlandırmak için tasarlanmıştır** ve yakın zamanda serbest bırakılan parçaları hızlı erişimli bir yapıda tutarak bunu sağlar. Bu bins'ler, Son Giren İlk Çıkar (LIFO) yaklaşımını kullanır, yani **en son serbest bırakılan parça**, yeni bir tahsis isteği olduğunda ilk olarak yeniden kullanılır. Bu davranış, bir yığının (LIFO) üstünden (FIFO'ya kıyasla) ekleme ve çıkarma yapmanın daha hızlı olması nedeniyle hız açısından avantajlıdır.
-
-Ayrıca, **hızlı bins'ler tek yönlü bağlı listeleri** kullanır, çift yönlü değil, bu da hızı daha da artırır. Hızlı bins'lerdeki parçalar komşularla birleştirilmediği için, ortadan kaldırma izni veren karmaşık bir yapıya ihtiyaç yoktur. Tek yönlü bağlı liste, bu işlemler için daha basit ve daha hızlıdır.
-
-Temelde burada olan şudur: Başlık (kontrol edilecek ilk parçanın işaretçisi) her zaman o boyuttaki en son serbest bırakılan parçaya işaret eder. Dolayısıyla:
-
-* O boyutta yeni bir parça tahsis edildiğinde, başlık kullanılacak bir serbest parçaya işaret eder. Bu serbest parça bir sonraki kullanılacak 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, serbest 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
-
-{% hint style="danger" %}
-Hızlı bins'lerdeki parçalar otomatik olarak kullanılabilir olarak ayarlanmaz, bu nedenle diğer parçalarla birleştirilebilme yeteneğine sahip olmaları yerine bir süre hızlı bins parçaları olarak kalırlar.
-{% endhint %}
-
-### Tcache (İş Parçacığı Başına Önbellek) Bins
-
-İş parçacıkları kendi belleğe sahip olmaya çalışsa da (bkz. [Arenalar](./#arenas) ve [Alt-bellekler](./#subheaps)), birçok iş parçacığına sahip bir sürecin (örneğin bir web sunucusu) **başka iş parçacıklarıyla belleği paylaşması mümkündür**. 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, her iş parçacığı için bir hızlı bin gibi **tek yönlü bağlı liste** olan bir yapıdır ve parçaları birleştirmez. Her iş parçacığı **64 tek yönlü tcache bins'ine** sahiptir. Her bir bin, [64 bit sistemlerde 24 ila 1032B ve 32 bit sistemlerde 12 ila 516B arasında](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315) maksimum [7 aynı boyutta parça](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) içerebilir.
-
-Bir iş parçacığı bir parçayı serbest bıraktığında, **eğer tcache'e 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 bins'lerde aramak veya yeni bir tane oluşturmak için bellek kilidinin açılmasını beklemesi gerekir.
-
-Bir **parça tahsis edildiğinde**, eğer **Tcache'te ihtiyaç duyulan boyutta bir serbest parça varsa**, onu kullanır, yoksa genel bins'lerde bir tane bulmak veya yeni bir tane oluşturmak için bellek kilidinin açılmasını beklemesi gerekir.\
-Bu durumda bir optimizasyon da vardır, bellek kilidi açıkken, iş parçacığı **istenen boyutta heap parçalarıyla (7) Tcache'ini dolduracaktır**, böylece daha fazla ihtiyaç duyarsa onları Tcache'te bulacaktır.
-### Bins sırası
-
-#### Tahsis için:
-
-1. Eğer istenilen boyutta Tcache'te uygun parça varsa, Tcache'i kullan
-2. Çok büyükse, mmap kullan
-3. Arena heap kilidini al ve:
-1. Yeterli küçük boyutta hızlı bin parçası istenilen boyutta mevcutsa, onu kullan ve tcache'i hızlı bindeki parçalarla doldur
-2. Mümkünse, yeterince büyük bir parça bulmak için sırasız listesindeki her girişi kontrol et ve tcache'i doldur
-3. Mümkünse küçük veya büyük kutuları (istenilen boyuta göre) kontrol et ve tcache'i doldur
-4. Mevcut bellekten yeni bir parça oluştur
-1. Eğer uygun bellek yoksa, `sbrk` kullanarak daha fazlasını al
-2. Ana heap belleği daha fazla genişleyemezse, mmap kullanarak yeni bir alan oluştur
-5. Hiçbiri işe yaramazsa, null değerini döndür
-
-**Serbest bırakma için:**
-
-1. İşaretçi Null ise, işlemi bitir
-2. Parçada `free` sağlamlık kontrolleri yaparak geçerli bir parça olup olmadığını doğrulamaya çalış
-1. Yeterince küçükse ve tcache dolu değilse, oraya koy
-2. M biti ayarlıysa (heap değilse), `munmap` kullan
-3. Arena heap kilidini al:
-1. Hızlı bin'e sığarsa, oraya koy
-2. Parça 64KB'den büyükse, hızlı kutuları hemen birleştir ve ortaya çıkan birleştirilmiş parçaları sırasız kutuya koy
-3. Parçayı yanındaki serbest bırakılmış parçalarla küçük, büyük ve sırasız kutularda geriye ve ileriye doğru birleştir
-4. Başın üstünde ise, kullanılmayan belleğe birleştir
-5. Öncekiler değilse, sırasız listesinde sakla
-
-
-
-\
-
-Hızlı heap örneği [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) ancak arm64'te:
+Arm64'te [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) adresindeki hızlı heap örneği:
 ```c
 #include <stdio.h>
 #include <stdlib.h>
@ -192,19 +156,33 @@ ptr = malloc(0x10);
 strcpy(ptr, "panda");
 }
 ```
-Ana fonksiyonun sonunda bir kesme noktası belirleyin ve bilginin nerede saklandığını bulalım:
+Ana fonksiyonun sonunda bir kesme noktası belirleyin ve bilgilerin 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çindeki malloc tarafından yanıt olarak verilen adresdi). Onun 0x10 byte öncesini kontrol etmek mümkün, bu durumda `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ün.
+Görülebileceği gibi, dize panda `0xaaaaaaac12a0` adresinde saklandı (bu adres, `x0` içindeki 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 anlamlara sahip olduğu anlamına gelir. Uzunluk her zaman 16 bayt hizalı olduğundan (64 bit makinelerde), bu bitler aslında uzunluk numarası tarafından asla kullanılmayacak.
+Ekstra boşluklar ayrılmıştır (0x21-0x10=0x11) **eklenen başlıklardan** (0x10) gelir ve 0x1, 0x21B ayrılmış olduğu anlamına gelmez ancak mevcut başlığın uzunluğunun son 3 bitinin bazı özel anlamlara sahip olduğu anlamına gelir. 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
 ```
-##
+## Bins ve Bellek Tahsisleri/Serbest Bırakmalar
+
+Kontrol edin nelerin bins olduğunu ve nasıl düzenlendiğini ve belleğin nasıl tahsis edildiğini ve serbest bırakıldığını:
+
+{% 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ışacak:
+
+{% content-ref url="heap-functions-security-checks.md" %}
+[heap-functions-security-checks.md](heap-functions-security-checks.md)
+{% endcontent-ref %}

 ## Referanslar

--- a/binary-exploitation/heap/bins-and-memory-allocations.md
+++ b/binary-exploitation/heap/bins-and-memory-allocations.md
@ -0,0 +1,196 @@
+# Bins & Bellek Tahsisi
+
+<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)** 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ı liste içinde değil, farklı türlerde bulunur. Bunlar "bins" olarak adlandırılır 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.
+
+Sıralanmamış, küçük ve büyük bins için her birinin başlangıç adresi aynı dizinin içindedir. İndeks 0 kullanılmaz, 1 sıralanmamış bin, 2-64 arası küçük bins ve 65-127 arası büyük bins olarak belirlenmiştir.
+
+### Küçük Bins
+
+Küçük bins, büyük binsden daha hızlı ancak hızlı binsden daha yavaştır.
+
+62'nin her bir bininde **aynı boyutta parçalar** bulunur: 16, 24, ... (32 bitlerde maksimum 504 bayt, 64 bitlerde 1024 bayta kadar). Bu, bir alana yer tahsis edilecek binin bulunması, girişlerin eklenmesi ve çıkarılması hızını artırır.
+
+### Büyük Bins
+
+Küçük binslerin aksine, her **büyük bin bir parça boyutu aralığını yönetir**. Bu, sistemin **farklı boyutları** ayrı birer bin olmadan barındırabilmesini sağlar.
+
+Bir bellek tahsisçısında, büyük binsler küçük binslerin bittiği yerden başlar. Büyük binsler için aralıklar giderek daha büyük hale gelir, yani ilk bin 512 ila 576 bayt arasındaki parçaları kapsarken, bir sonraki 576 ila 640 baytı kapsar. Bu desen devam eder ve en büyük bin tüm 1MB üzerindeki parçaları içerir.
+
+Büyük binsler, bir tahsis için en iyi uyumu bulmak için **farklı parça boyutlarının listesini sıralamak ve aramak zorunda olduklarından küçük binslere göre daha yavaş çalışır**. Bir parça büyük bine eklenirken sıralanmalı ve bellek tahsis edilirken sistem doğru parçayı bulmalıdır. Bu ek iş, onları **daha yavaş** yapar, ancak büyük tahsisler küçük olanlardan daha az yaygın olduğundan, kabul edilebilir bir takas yapılır.
+
+Şunlar vardır:
+
+* 64B aralığındaki 32 bin
+* 512B aralığındaki 16 bin
+* 4096B aralığındaki 8 bin
+* 32768B aralığındaki 4 bin
+* 262144B aralığındaki 2 bin
+* Geri kalan boyutlar için 1 bin
+
+### Sıralanmamış Bin
+
+Sıralanmamış bin, bellek tahsisini hızlandırmak için kullanılan bir **hızlı önbellektir**. İşte nasıl çalışır: Bir program belleği serbest bıraktığında, bellek yöneticisi hemen onu belirli bir bine koymaz. Bunun yerine, öncelikle yan yana gelen serbest parçaları birleştirerek daha büyük bir serbest bellek bloğu oluşturmaya çalışır. Daha sonra, bu yeni parçayı "sıralanmamış bin" adı verilen genel bir bine yerleştirir.
+
+Bir program **bellek istediğinde**, bellek yöneticisi **sıralanmamış bin'i kontrol eder** ve yeterli boyutta bir parça bulunup bulunmadığını kontrol eder. Bir uygun parça bulursa, hemen kullanır. Uygun bir parça bulamazsa, serbest bırakılan parçaları boyutlarına bağlı olarak küçük veya büyük bine taşır.
+
+Bu nedenle, sıralanmamış bin, bellek tahsisini hızlandırmak için son zamanlarda serbest bırakılan belleği hızlı bir şekilde yeniden kullanarak ve zaman alıcı aramaları ve birleştirmeleri azaltarak hafızayı hızlandırır.
+
+{% hint style="danger" %}
+Farklı kategorilerdeki parçalar bile olsa, mevcut bir parça başka bir mevcut parçayla çakışıyorsa (farklı kategorilerde olsalar bile), birleştirileceklerdir.
+{% endhint %}
+
+### Hızlı Bins
+
+Hızlı binsler, 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 çalışır. Bu binsler, Son Giren İlk Çıkar (LIFO) yaklaşımını kullanır, yani **en son serbest bırakılan parça**, yeni bir tahsis isteği olduğunda ilk olarak yeniden kullanılır. Bu davranış, hız için avantajlıdır, çünkü bir yığının üstünden (LIFO) ekleme ve çıkarma işlemleri bir kuyruktan (FIFO) daha hızlıdır.
+
+Ayrıca, **hızlı binsler tek yönlü bağlı listeleri** kullanır, çift yönlü bağlı listelerden değil, bu da hızı artırır. Hızlı binslerdeki parçalar komşularla birleştirilmediğinden, ortadan kaldırma işlemleri için karmaşık bir yapıya gerek yoktur. Tek yönlü 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ça için 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 bir sonraki kullanılacak parçaya işaret ettiğinden, 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
+
+{% hint style="danger" %}
+Hızlı binslerdeki parçalar otomatik olarak kullanılabilir olarak ayarlanmaz, bu nedenle diğer parçalarla birleşebilme yeteneğine sahip olmazlar ve bir süre hızlı bin parçaları olarak kalırlar.
+{% endhint %}
+
+### Tcache (İş Parçacığına Özel Önbellek) Bins
+
+İş parçacıkları kendi belleklerine 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 sürecin (örneğin bir web sunucusu) **başka iş parçacıklarıyla belleği paylaşması olasılığı** vardır. 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, her iş parçacığı için bir hızlı bin gibi **tek yönlü bağlı liste** olan bir yapıdır ve parçaları birleştirmez. Her iş parçacığı **64 tek yönlü tcache bin'ine** sahiptir. Her bir bin, [64 bit sistemlerde 24 ila 1032B ve 32 bit sistemlerde 12 ila 516B arasında](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315) olan [7 aynı boyutta parça](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) içerebilir.
+
+Bir iş parçacığı bir parçayı serbest bıraktığında, **eğer çok büyük değilse** ve ilgili tcache bin **dolu değilse** (zaten 7 parça), **oraya tahsis edilir**. Tcache'e gidemiyorsa, genel bine serbest bırakma işlemini yapabilmek için bellek kilidini beklemek zorunda kalır.
+
+Bir **parça tahsis edildiğinde**, eğer **Tcache'te ihtiyaç duyulan boyutta bir boş parça varsa kullanılır**, yoksa genel bine bir tane bulmak veya yeni bir tane oluşturmak için bellek kilidini beklemek zorunda kalır.\
+Bu durumda bir optimizasyon da vardır, bellek kilidini alırken, iş parçacığı **istenen boyutta Tcache'ine heap parçaları (7) doldurur**, böylece daha fazla ihtiyaç duyarsa Tcache'te bulabilir.
+## Tahsis Akışı
+
+{% hint style="success" %}
+(Bu mevcut açıklama [https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions](https://heap-exploitation.dhavalkapil.com/diving_into_glibc_heap/core_functions) adresinden alınmıştır. TODO: Son sürümü kontrol edin ve güncelleyin)
+{% endhint %}
+
+Tahsisler sonunda şu işlevle gerçekleştirilir: `void * _int_malloc (mstate av, size_t bytes)` ve şu sıraya sahiptir:
+
+1. **Hizalamaları** vb. dikkate almak için `bytes` güncellenir.
+2. `av`'nin **NULL** olup olmadığı kontrol edilir.
+3. **Kullanılabilir alan** eksikliği durumunda (av NULL olduğunda), mmap kullanarak parça almak için `sysmalloc` çağrılır. Başarılı olursa, `alloc_perturb` çağrılır. İşaretçi döndürülür.
+4. Boyuta bağlı olarak:
+* \[Orijinal ek] Bir sonraki fastbin'i kontrol etmeden önce tcache kullanılır.
+* \[Orijinal ek] Tcache yoksa ancak farklı bir bin kullanılıyorsa (daha sonraki adımlarda görülecek), tcache'i o bini doldurmaya çalışır.
+* Boyut **fastbin** aralığına düşerse:&#x20;
+1. Uygun bir bin erişmek için fastbin dizisine endeks alınır.
+2. Bu bindeki ilk parçayı çıkarır ve `victim`'ı ona işaret eder.
+3. Eğer `victim` NULL ise, bir sonraki duruma geçilir (smallbin).
+4. Eğer `victim` NULL değilse, parçanın boyutunu kontrol etmek için onun o belirli bine ait olduğundan emin olmak için kontrol edilir. Aksi takdirde bir hata ("malloc(): bellek bozulması (hızlı)") fırlatılır.
+5. `alloc_perturb` çağrılır ve ardından işaretçi döndürülür.
+* Boyut **smallbin** aralığına düşerse:
+1. Uygun bir bin erişmek için smallbin dizisine endeks alınır.
+2. Bu binde parça yoksa, bir sonraki duruma geçilir. Bu, `bin` ve `bin->bk` işaretçilerini karşılaştırarak kontrol edilir.
+3. `victim`, `bin->bk`'ye (bindeki son parça) eşitlenir. Eğer NULL ise (başlangıçta gerçekleşir), `malloc_consolidate` çağrılır ve farklı binalara bakma adımı tamamen atlanır.
+4. Aksi takdirde, `victim` NULL değilse, `victim->bk->fd` ve `victim`'ın eşit olup olmadığı kontrol edilir. Eğer eşit değillerse, bir hata (`malloc(): smallbin çift bağlı liste bozulmuş`) fırlatılır.
+5. `victim` için bir sonraki parça için (bellekte, çift bağlı listede değil) PREV_INSUSE biti ayarlanır.
+6. Bu parça bin listesinden çıkarılır.
+7. Bu parçaya uygun arena biti `av`'ye bağlı olarak ayarlanır.
+8. `alloc_perturb` çağrılır ve ardından işaretçi döndürülür.
+* Boyut **smallbin** aralığına düşmezse:
+1. Uygun bir bin erişmek için largebin dizisine endeks alınır.
+2. `av`'nin fastchunks'a sahip olup olmadığı kontrol edilir. Bu, `av->flags` içindeki `FASTCHUNKS_BIT`'i kontrol ederek yapılır. Öyleyse, `av` üzerinde `malloc_consolidate` çağrılır.
+5. Henüz bir işaretçi döndürülmemişse, bu bir veya daha fazla aşağıdaki durumdan birini gösterir:
+1. Boyut 'fastbin' aralığına düşer ancak hızlı parça mevcut değildir.
+2. Boyut 'smallbin' aralığına düşer ancak küçük parça mevcut değildir (başlangıçta `malloc_consolidate` çağrılır).
+3. Boyut 'largebin' aralığına düşer.
+6. Sonra, **sırasız parçalar** kontrol edilir ve gezilen parçalar binalara yerleştirilir. Parçaların binalara yerleştirildiği tek yer burasıdır. Sırasız bin 'TAIL'den iterasyon yapılır.
+1. `victim`, üzerinde durulan mevcut parçayı işaret eder.
+2. `victim`'ın parça boyutunun minimum (`2*SIZE_SZ`) ve maksimum (`av->system_mem`) aralığında olup olmadığı kontrol edilir. Aksi takdirde bir hata (`malloc(): bellek bozulması`) fırlatılır.
+3. Eğer (istenen parça boyutu smallbin aralığına düşerse) ve (`victim` son kalan parça ise) ve (sırasız binde tek parça varsa) ve (parçanın boyutu istenen boyuttan büyükse): **Parçayı 2 parçaya ayır**:
+* İlk parça istenen boyuta uyar ve döndürülür.
+* Geriye kalan parça yeni son kalan parça olur. Bu sırasız bine geri eklenir.
+1. Her iki parça için de `chunk_size` ve `chunk_prev_size` alanları uygun şekilde ayarlanır.
+2. İlk parça, `alloc_perturb` çağrıldıktan sonra döndürülür.
+3. Yukarıdaki koşul yanlışsa, kontrol buraya ulaşır. `victim` sırasız binde çıkarılır. `victim`'ın boyutu tam olarak istenen boyuta uyuşuyorsa, bu parça `alloc_perturb` çağrıldıktan sonra döndürülür.
+4. Eğer `victim`'ın boyutu smallbin aralığına düşerse, parça uygun smallbin'e `HEAD`'e eklenir.
+5. Aksi takdirde, uygun sıralı düzende büyük bin içine eklenir:
+6. En küçük son parçayı (en küçük) kontrol eder. Eğer `victim` en küçük parçadan küçükse, en sona eklenir.
+7. Aksi takdirde, `victim`'ın boyutundan büyük veya eşit bir parça bulmak için döngü yapılır. Boyut tam olarak aynıysa, her zaman ikinci pozisyona eklenir.
+8. Bu adım maksimum `MAX_ITERS` (10000) kez veya sırasız bindeki tüm parçalar tükenene kadar tekrarlanır.
+7. Sırasız parçalar kontrol edildikten sonra, istenen boyutun smallbin aralığına düşmediği kontrol edilir, öyleyse **largebin'leri** kontrol edilir.
+1. Uygun bir bin erişmek için largebin dizisine endeks alınır.
+2. En büyük parçanın boyutu (bindeki ilk parça) istenen boyuttan büyükse:
+1. Bir parça (`victim`) bulmak için 'TAIL'den iterasyon yapılır, istenen boyuttan büyük veya eşit en küçük boyuta sahip.
+2. `victim` parçasını bindeki çıkarmak için `unlink` çağrılır.
+3. `victim`'ın parçası için `remainder_size` hesaplanır (bu, `victim`'ın parça boyutu - istenen boyut olacaktır).
+4. Eğer bu `remainder_size` >= `MINSIZE` (başlık dahil minimum parça boyutu), parçayı iki parçaya böler. Aksi takdirde, tüm `victim` parçası döndürülür. Geriye kalan parça sırasız bine eklenir ('TAIL' sonunda). Sırasız binde `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)` kontrol edilir. Aksi takırdi hata fırlatılır ("malloc(): bozuk sırasız parçalar").
+5. `victim` parça, `alloc_perturb` çağrıldıktan sonra döndürülür.
+8. Şimdiye kadar, sırasız bin ve ilgili fast, small veya large bin kontrol edildi. Unutmayın ki tek bir bin (hızlı veya küçük) istenen parça boyutunun **tam olarak** kontrol edildiği yerdir. Tüm binalar tükenene kadar aşağıdaki adımları tekrarlayın:
+1. Bin dizisine erişim endeksi artırılır.
+2. Boş olan binaları atlamak için `av->binmap` haritası kullanılır.
+3. `victim` mevcut binin 'TAIL'ine işaret eder.
+4. Bin haritası, bir binin atlandığını (yukarıdaki 2. adımda) kesinlikle boş olduğunu sağlar. Ancak, tüm boş binaların atlanacağını garanti etmez. `victim`'ın boş olup olmadığı kontrol edilir. Eğer boşsa, tekrar bin atlanır ve yukarıdaki işlem tekrarlanır (veya bu döngü 'devam' eder) boş olmayan bir bine ulaşılana kadar.
+5. Parça ikiye bölünür (`victim`, dolu olmayan bir binin son parçasını işaret eder). Geriye kalan parça sırasız bine eklenir ('TAIL' sonunda). Sırasız binde `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)` kontrol edilir. Aksi takdirde hata fırlatılır ("malloc(): bozuk sırasız parçalar 2").
+6. `victim` parça, `alloc_perturb` çağrıldıktan sonra döndürülür.
+9. Hala boş bir bin bulunamazsa, 'top' parçası isteği karşılamak için kullanılacaktır:
+1. `victim`, `av->top`'a işaret eder.
+2. 'top' parçasının boyutu >= 'istenilen boyut' + `MINSIZE` ise, ikiye bölünür. Bu durumda, geriye kalan parça yeni 'top' parça olur ve diğer parça `alloc_perturb` çağrıldıktan sonra kullanıcıya döndürülür.
+3. `av`'nin fastchunks'a sahip olup olmadığı kontrol edilir. Bu, `av->flags` içindeki `FASTCHUNKS_BIT`'i kontrol ederek yapılır. Öyleyse, `av` üzerinde `malloc_consolidate` çağrılır. 6. adıma geri dönülür (sırasız bin kontrol edildiği yer).
+4. Eğer `av`'nin fastchunks'u yoksa, `sysmalloc` çağrılır ve `alloc_perturb` çağrıldıktan sonra elde edilen işaretçi döndürülür.
+## Serbest Akış
+
+{% hint style="success" %}
+(Bu mevcut açıklama [https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions](https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions) adresinden alınmıştır. TODO: Son sürümü kontrol edin ve güncelleyin)
+{% endhint %}
+
+Hafıza parçalarını serbest bırakan son işlev `_int_free (mstate av, mchunkptr p, int have_lock)` şöyledir:
+
+1. `p`, bellekte `p + chunksize(p)`'den önce mi diye kontrol edilir (sarılma olmaması için). Aksi takdirde bir hata (`free(): invalid pointer`) oluşturulur.
+2. Parçanın en az `MINSIZE` boyutunda veya `MALLOC_ALIGNMENT`'ın katı olup olmadığı kontrol edilir. Aksi takdirde bir hata (`free(): invalid size`) oluşturulur.
+3. Eğer parçanın boyutu fastbin listesine düşerse:
+1. Sonraki parçanın boyutunun minimum ve maksimum boyut (`av->system_mem`) arasında olup olmadığı kontrol edilir, aksi takdirde bir hata (`free(): invalid next size (fast)`) oluşturulur.
+2. Parçada `free_perturb` çağrılır.
+3. `av` için `FASTCHUNKS_BIT` ayarlanır.
+4. Parçanın boyutuna göre fastbin dizisine endeks alınır.
+5. Kovanın en üstünde ekleyeceğimiz parçanın parça olmadığı kontrol edilir. Aksi takdirde bir hata (`double free or corruption (fasttop)`) oluşturulur.
+6. Kovanın en üstündeki fastbin parçanın boyutunun ekleyeceğimiz parça ile aynı olup olmadığı kontrol edilir. Aksi takdirde bir hata (`invalid fastbin entry (free)`) oluşturulur.
+7. Parçayı fastbin listesinin en üstüne ekleyin ve dönün.
+4. Eğer parça mmapped değilse:
+1. Parçanın en üst parça olup olmadığı kontrol edilir. Eğer öyleyse, bir hata (`double free or corruption (top)`) oluşturulur.
+2. Sonraki parçanın (bellek tarafından) arenanın sınırları içinde olup olmadığı kontrol edilir. Değilse, bir hata (`double free or corruption (out)`) oluşturulur.
+3. Sonraki parçanın (bellek tarafından) önceki kullanımda işaretlenmiş olup olmadığı kontrol edilir. Değilse, bir hata (`double free or corruption (!prev)`) oluşturulur.
+4. Sonraki parçanın boyutunun minimum ve maksimum boyut (`av->system_mem`) arasında olup olmadığı kontrol edilir. Değilse, bir hata (`free(): invalid next size (normal)`) oluşturulur.
+5. Parçada `free_perturb` çağrılır.
+6. Önceki parça (bellek tarafından) kullanımda değilse, önceki parçada `unlink` çağrılır.
+7. Sonraki parça (bellek tarafından) en üst parça değilse:
+1. Sonraki parça kullanımda değilse, sonraki parçada `unlink` çağrılır.
+2. Parçayı önceki, sonraki (bellek tarafından) parçalarla birleştirin, herhangi biri boşsa ve bunu sırasız kovaya ekleyin. Eklerken, `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)` olup olmadığı kontrol edilir. Değilse, bir hata ("free(): corrupted unsorted chunks") oluşturulur.
+8. Sonraki parça (bellek tarafından) en üst parça ise, parçaları uygun şekilde tek bir en üst parçaya birleştirin.
+5. Eğer parça mmapped ise, `munmap_chunk` çağrılır.
+
+## Hafıza İşlevleri Güvenlik Kontrolleri
+
+Hafızada sıkça kullanılan işlevlerde gerçekleştirilen güvenlik kontrollerini kontrol edin:
+
+{% content-ref url="heap-functions-security-checks.md" %}
+[heap-functions-security-checks.md](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)
--- a/binary-exploitation/heap/double-free.md
+++ b/binary-exploitation/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(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 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, aynı bellek konumuna işaret eden iki farklı işaretçiye 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 yapılırken ö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 edilirse diğeri etkilenebilir, bu da kritik bir güvenlik riski ve sömürü potansiyeli yaratır.
+
+Ç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ı 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 **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>
--- a/binary-exploitation/heap/heap-functions-security-checks.md
+++ b/binary-exploitation/heap/heap-functions-security-checks.md
@ -0,0 +1,92 @@
+# Heap Fonksiyonları Güvenlik Kontrolleri
+
+<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 PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini alın**](https://peass.creator-spring.com)
+* [**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 püf noktalarınızı paylaşarak PR göndererek HackTricks ve HackTricks Cloud github depolarına katkıda bulunun.**
+
+</details>
+
+## unlink
+
+Bu fonksiyon, bir parçayı çift yönlü bağlı listeden kaldırır. Parçaları ayırırken bağlı liste yapısının tutarlı kalmasını sağlayan yaygın kontroller bulunmaktadır.
+
+* **Tutarlılık Kontrolleri**:
+* `P->fd->bk == P` ve `P->bk->fd == P` koşullarını kontrol edin.
+* Hata mesajı: `corrupted double-linked list`
+
+## \_int\_malloc
+
+Bu fonksiyon, heap'ten bellek tahsisinden sorumludur. Buradaki kontroller, belleğin tahsis sırasında bozulmadığından emin olur.
+
+* **Fastbin Boyut Kontrolü**:
+* Bir parçayı fastbin'den kaldırırken, parçanın boyutunun fastbin aralığında olduğundan emin olun.
+* Hata mesajı: `malloc(): memory corruption (fast)`
+* **Smallbin Tutarlılık Kontrolü**:
+* Bir parçayı smallbin'den kaldırırken, çift yönlü bağlı listedeki önceki ve sonraki bağlantıların tutarlı olduğundan emin olun.
+* Hata mesajı: `malloc(): smallbin double linked list corrupted`
+* **Unsorted Bin Bellek Aralığı Kontrolü**:
+* Karışık kutulardaki parçaların boyutunun minimum ve maksimum sınırlar arasında olduğundan emin olun.
+* Hata mesajı: `malloc(): memory corruption`
+* **Unsorted Bin Tutarlılık Kontrolü (İlk Senaryo)**:
+* Kalan bir parçayı karışık kutuya eklerken, `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)` koşulunu kontrol edin.
+* Hata mesajı: `malloc(): corrupted unsorted chunks`
+* **Unsorted Bin Tutarlılık Kontrolü (İkinci Senaryo)**:
+* Önceki kontrolle aynıdır, ancak hızlı veya küçük bir parçayı böldükten sonra eklerken tetiklenir.
+* Hata mesajı: `malloc(): corrupted unsorted chunks 2`
+
+## \_int\_free
+
+Bu fonksiyon önceden tahsis edilmiş belleği serbest bırakır. Buradaki kontroller, uygun bellek serbest bırakma ve bellek bozulmasını önlemeye yardımcı olur.
+
+* **İşaretçi Sınır Kontrolü**:
+* Serbest bırakılan işaretçinin belleği sarmadığından emin olun.
+* Hata mesajı: `free(): invalid pointer`
+* **Boyut Kontrolü**:
+* Serbest bırakılan parçanın boyutunun en az `MINSIZE` veya `MALLOC_ALIGNMENT`'ın katları olduğundan emin olun.
+* Hata mesajı: `free(): invalid size`
+* **Fastbin Boyut Kontrolü**:
+* Fastbin parçaları için, bir sonraki parçanın boyutunun minimum ve maksimum sınırlar arasında olduğundan emin olun.
+* Hata mesajı: `free(): invalid next size (fast)`
+* **Fastbin Çift Serbest Bırakma Kontrolü**:
+* Bir parçayı fastbin'e eklerken, baştaki parçanın eklenen parça ile aynı olmadığından emin olun.
+* Hata mesajı: `double free or corruption (fasttop)`
+* **Fastbin Tutarlılık Kontrolü**:
+* Bir fastbin'e ekleme yaparken, baştaki parçanın boyutunun ve eklenen parçanın boyutunun aynı olduğundan emin olun.
+* Hata mesajı: `invalid fastbin entry (free)`
+* **Üst Parça Tutarlılık Kontrolü**:
+* Hızlı olmayan fastbin parçaları için, parçanın üst parça ile aynı olmadığından emin olun.
+* Hata mesajı: `double free or corruption (top)`
+* **Bellek Sınırları Kontrolü**:
+* Belleği saran bir sonraki parçanın arenanın sınırları içinde olduğundan emin olun.
+* Hata mesajı: `double free or corruption (out)`
+* **Prev\_inuse Bit Kontrolü**:
+* Bir sonraki parçadaki önceki kullanımda bitin işaretlendiğinden emin olun.
+* Hata mesajı: `double free or corruption (!prev)`
+* **Normal Boyut Kontrolü**:
+* Bir sonraki parçanın boyutunun geçerli aralıklarda olduğundan emin olun.
+* Hata mesajı: `free(): invalid next size (normal)`
+* **Unsorted Bin Tutarlılık Kontrolü**:
+* Bir birleştirilmiş parçayı karışık kutuya eklerken, `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)` koşulunu kontrol edin.
+* Hata mesajı: `free(): corrupted unsorted chunks`
+
+<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 PLANLARI**](https://github.com/sponsors/carlospolop)'na göz atın!
+* [**Resmi PEASS & HackTricks ürünlerini alın**](https://peass.creator-spring.com)
+* [**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 püf noktalarınızı paylaşarak PR göndererek HackTricks ve HackTricks Cloud github depolarına katkıda bulunun.**
+
+</details>
--- a/binary-exploitation/heap/heap-overflow.md
+++ b/binary-exploitation/heap/heap-overflow.md
@ -2,44 +2,58 @@

 <details>

-<summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> ile sıfırdan kahramana kadar AWS hacklemeyi öğrenin!</summary>
+<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'i desteklemenin diğer yolları:
+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'lerimizi](https://opensea.io/collection/the-peass-family) içerir
- 💬 [Discord grubuna](https://discord.gg/hRep4RUj7f) veya [telegram grubuna](https://t.me/peass) **katılın** veya **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.
+* **Ş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ünleri**]'ni (https://peass.creator-spring.com) edinin
+* [**PEASS Ailesi**]'ni (https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'ler**]'imiz (https://opensea.io/collection/the-peass-family) koleksiyonumuz
+* **Katılın** 💬 [**Discord grubuna**] (https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**] katılın (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

-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ıldı ve **depolanan veri ayrılan alandan daha büyüktü.**
+Bir heap taşması, heap'te bir [**yığın taşması**] (../stack-overflow/) gibi. Temelde, heap'te bazı verileri depolamak için bir alan ayrılmış ve **depolanan veriler ayrılan alandan daha büyük**.

-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, taşınan heap parçasında varsayılan olarak **duyarlı bilgi depolanmaz.** Bununla birlikte, hassas bilgi veya işaretçiler olabilir, bu nedenle bu zafiyetin **kritikliği**, **hangi verilerin üzerine yazılabileceğine** ve bir saldırganın bunu nasıl istismar edebileceğine bağlıdır.
+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, taşınabilecek bir heap parçasında **varsayılan olarak depolanan hassas bilgi yoktur**. Bununla birlikte, hassas bilgi veya işaretçiler olabilir, bu nedenle bu zafiyetin **kritikliği**, bu zafiyetle **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.
+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 çakışarak arttığı, 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ığı, ancak **ayrılmış bellek pozisyonlarında genellikle ayrılmış parçaların** (yan yana olmayan) olduğu, boyuta göre ayrımlar yapan **kutular ve bölgeler** nedeniyle ve **önceki serbest bırakılan belleğin** yeni parçalar ayrılmadan önce kullanıldığı için **taşan nesnenin çarpışacağı nesneyi bilmek karmaşıktır**. Bu nedenle, bir heap taşması bulunduğunda, istenen nesnenin taşan nesneye bitişik olmasını sağlayacak **güvenilir bir yol bulunması gerekir**.
+
+Bunun için kullanılan tekniklerden biri **Heap Grooming**'dir ve örneğin [**bu gönderide**] (https://azeria-labs.com/grooming-the-ios-kernel-heap/) kullanılmaktadır. Gönderide, iOS çekirdeğinde bir bölgenin bellekte bellek parçalarını depolamak için hafızasının tükendiğinde, bir çekirdek sayfası ile 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 bir kurban sırayla çarpışmasını zorlamak için birkaç **`kalloc`'lar** zorlanır ve tüm boş parçaların doldurulduğundan ve yeni bir sayfa oluşturulduğundan emin olunmaya çalışılı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, bazı bu yer tutucular **serbest bırakılabilir**. **`kalloc.4096` serbest listesi, öğeleri son giren ilk çıkan düzeninde serbest bırakır**, bu da temelde bazı yer tutucuların serbest bırakıldığı ve saldırının taşma nesnesini almaya çalışırken birkaç kurban nesne tahsis etmeye çalışırken, bu nesnenin muhtemelen bir kurban nesne tarafından takip edileceği anlamına gelir.
+
 ## Ö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, taşan parçadan bir sonraki parçada depolanacak bir komutun bulunduğu bir heap taşması örneği bulabilirsiniz. Bu nedenle, basit bir istismarla yürütülecek komutu değiştirmek mümkündür, örneğin:
+[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, taşan nesneden sonraki bir sonraki parçada yürütülecek bir komutun depolandığı bir heap taşması örneği bulabilirsiniz. Bu nedenle, basit bir saldırı ile üzerine yazarak yürütülen komutu değiştirmek mümkündür.
 ```bash
 python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
 ```
 <details>

-<summary><strong>Sıfırdan kahramana 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>
+<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 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.**
-* **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.
+* **Ş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)
+* [**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)**'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>
--- a/binary-exploitation/heap/use-after-free/README.md
+++ b/binary-exploitation/heap/use-after-free/README.md
@ -0,0 +1,46 @@
+# Kullanımdan Sonra Ücretsiz
+
+<details>
+
+<summary><strong>AWS hackleme konusunda sıfırdan kahraman olmaya 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 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 püf noktalarınızı göndererek HackTricks ve HackTricks Cloud** github depolarına PR göndererek paylaşın.
+
+</details>
+
+## Temel Bilgiler
+
+Adından da anlaşılacağı gibi, bu zafiyet, bir programın bir nesne için heap'te **bazı alanlar 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şturabilir** (eğer çağrılacak bir işlevin işaretçisiyse, 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ğine hedeflenir. 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, **yeniden kullanılan bellek blokları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 şuraya bakın:
+
+{% content-ref url="first-fit.md" %}
+[first-fit.md](first-fit.md)
+{% endcontent-ref %}
+
+##
+
+<details>
+
+<summary><strong>AWS hackleme konusunda sıfırdan kahraman olmaya 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 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 püf noktalarınızı göndererek HackTricks ve HackTricks Cloud** github depolarına PR göndererek paylaşın.
+
+</details>
--- a/binary-exploitation/heap/use-after-free/first-fit.md
+++ b/binary-exploitation/heap/use-after-free/first-fit.md
@ -0,0 +1,64 @@
+# İlk Uygun Alan
+
+<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 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 Alan**
+
+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) eklenen bir liste gibi davranır. Yeni bir bellek parçası istediğinizde, tahsisatçı, istediğinizden yeterince büyük bir parça bulmak için sıralanmamış kutuya arkadan (kuyruk) bakar. Eğer sıralanmamış kutudan bir parça isteğinizden 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 250 bayt daha 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ışı 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 üzerine yazarak kullanıcı->şifre konumunu** değiştir. Kullanıcıyı **şifre kontrolünü atlatmak** için yeniden kullan.