Translated ['src/binary-exploitation/libc-heap/unsorted-bin-attack.md']

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

@@ -4,52 +4,109 @@
 
 ## Temel Bilgiler
 
-Unsorted bin nedir hakkında daha fazla bilgi için bu sayfayı kontrol edin:
+Ne olduğunu daha fazla öğrenmek için unsorted bin hakkında şu sayfaya bakın:
+
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-Unsorted listeler, `bk` adresine `unsorted_chunks (av)` adresini yazma yeteneğine sahiptir. Bu nedenle, bir saldırgan bir unsorted bin içindeki bir chunk'taki **`bk` pointer'ının adresini değiştirebilirse**, bu adresi **rastgele bir adrese yazabilir** ki bu da Glibc adreslerini sızdırmak veya bazı savunmaları aşmak için faydalı olabilir.
+Unsorted listleri, chunk'ın `bk` adresine `unsorted_chunks (av)` adresini yazabilirler. Bu nedenle, eğer bir saldırgan unsorted bin içindeki bir chunk'taki `bk` pointerının adresini **değiştirebiliyorsa**, o adresi **rastgele bir adrese yazabilme** imkanına sahip olabilir; bu, Glibc adreslerini leak etmek veya bazı korumaları atlatmak için faydalı olabilir.
 
-Yani, temelde bu saldırı, **rastgele bir adreste büyük bir sayı ayarlamaya** olanak tanır. Bu büyük sayı, bir heap adresi veya bir Glibc adresi olabilir. Tipik bir hedef, daha büyük boyutlarda hızlı binler oluşturmak için **`global_max_fast`**'tır (ve bir unsorted bin saldırısından hızlı bin saldırısına geçiş yapar).
+Yani temelde bu atak, **rastgele bir adrese büyük bir sayı yazmayı** sağlar. Bu büyük sayı bir adrestir; heap adresi veya Glibc adresi olabilir. Geleneksel hedefler arasında fast bin boyutlarını artırmaya izin veren **`global_max_fast`** vardı (ve unsorted bin attack'tan fast bin attack'a geçişi sağlar).
+
+- Modern not (glibc ≥ 2.39): `global_max_fast` 8‑bit bir global oldu. Oraya unsorted‑bin write ile körü körüne bir pointer yazmak, bitişik libc verilerini bozacak ve artık fastbin limitini güvenilir şekilde yükseltmeyecektir. glibc 2.39+ karşısında çalışırken diğer hedefleri veya primitifleri tercih edin. Aşağıdaki "Modern constraints" bölümüne bakın ve kararlı bir primitif elde ettiğinizde bunu bir [large bin attack](large-bin-attack.md) veya bir [fast bin attack](fast-bin-attack.md) gibi diğer tekniklerle birleştirmeyi düşünün.
 
 > [!TIP]
-> [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 verilen örneğe bakarak ve chunk boyutları için 0x400 ve 0x500 yerine 0x4000 ve 0x5000 kullanarak (Tcache'den kaçınmak için) **günümüzde** **`malloc(): unsorted double linked list corrupted`** hatasının tetiklendiğini görebilirsiniz.
+> T>  [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) adresindeki örneğe bakıldığında ve chunk boyutları olarak 0x400 ve 0x500 yerine 0x4000 ve 0x5000 kullanıldığında (Tcache'i önlemek için) **günümüzde** artık **`malloc(): unsorted double linked list corrupted`** hatasının tetiklendiği görülebilir.
 >
-> Bu nedenle, bu unsorted bin saldırısı artık (diğer kontrollerin yanı sıra) çift bağlı listeyi düzeltme yeteneğine sahip olmayı da gerektiriyor, böylece `victim->bk->fd == victim` veya `victim->fd == av (arena)` kontrolü geçiliyor, bu da yazmak istediğimiz adresin `fd` konumunda sahte chunk'ın adresini bulundurması ve sahte chunk'ın `fd`'sinin arenaya işaret etmesi gerektiği anlamına geliyor.
+> Bu nedenle, bu unsorted bin atakı artık (diğer kontrollerin yanında) çift bağlı listeyi düzeltme yeteneğini de gerektiriyor; aksi halde `victim->bk->fd == victim` veya `victim->fd == av (arena)` kontrolleri atlanamıyor. Bu da, yazmak istediğimiz adresin, fake chunk'ın adresini kendi `fd` pozisyonunda barındırması ve fake chunk `fd`'sinin arena'ya işaret etmesi gerektiği anlamına gelir.
 
 > [!CAUTION]
-> Bu saldırının unsorted bin'i bozduğunu unutmayın (bu nedenle küçük ve büyük de). Bu nedenle, artık yalnızca **hızlı binlerden tahsisat kullanabiliriz** (daha karmaşık bir program başka tahsisatlar yapabilir ve çökebilir) ve bunu tetiklemek için **aynı boyutta tahsisat yapmalıyız yoksa program çöker.**
+> Bu atak unsorted bin'i (dolayısıyla small ve large'ı da) bozar. Bu yüzden artık yalnızca **fast bin**'den yapılan allocation'ları kullanabiliriz (daha karmaşık bir program başka allocation'lar yaparsa crash olabilir), ve bunu tetiklemek için **aynı boyutta allocation yapmalıyız yoksa program çöker.**
 >
-> **`global_max_fast`**'ı yazmak bu durumda yardımcı olabilir, çünkü hızlı binin tüm diğer tahsisatları exploit tamamlanana kadar yönetebileceğine güveniyoruz.
+> Bu durumda **`global_max_fast`**'ı overwrite etmek, exploit tamamlanana kadar fast bin'in diğer allocation'ları karşılayabileceğine güvenerek yardımcı olabilir.
 
-[**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) tarafından verilen kod bunu çok iyi açıklıyor, ancak malloc'ları yeterince büyük bir bellek tahsis etmek için değiştirirseniz, böylece Tcache'de sona ermezseniz, daha önce bahsedilen hatanın bu tekniği engellediğini görebilirsiniz: **`malloc(): unsorted double linked list corrupted`**
+[**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) tarafından yazılan kod bunu çok iyi açıklıyor; fakat malloc'ları Tcache'e düşmeyecek kadar büyük allocate edecek şekilde değiştirirseniz, daha önce bahsedilen hata ortaya çıkar: **`malloc(): unsorted double linked list corrupted`**
+
+### Yazmanın gerçekte nasıl gerçekleştiği
+
+- Unsorted‑bin yazma, freed chunk unsorted list'in başına eklenirken `free` sırasında tetiklenir.
+- Ekleme sırasında allocator şunu yapar: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
+- Eğer `free(victim)` çağrısından önce `victim->bk`'yi `(mchunkptr)(TARGET - 0x10)` olarak ayarlayabilirseniz, son ifade şu yazmayı yapar: `*(TARGET) = victim`.
+- Daha sonra allocator unsorted bin'i işlerken, unlink etmeden önce bütünlük kontrolleri (başka kontrollerin yanında) `bck->fd == victim` ve `victim->fd == unsorted_chunks(av)` doğrulamasını yapar. Çünkü ekleme zaten `bck->fd`'ye (bizim `TARGET`) `victim`'i yazmıştır, eğer yazma başarılı olduysa bu kontroller sağlanabilir.
+
+## Modern kısıtlamalar (glibc ≥ 2.33)
+
+Güncel glibc üzerinde unsorted‑bin write'ları güvenilir şekilde kullanmak için:
+
+- Tcache müdahalesi: tcache'e düşen boyutlar için free'lar oraya yönlendirilir ve unsorted bin ile işlem yapmaz. Ya
+  - istekleri MAX_TCACHE_SIZE'tan (> 64‑bit için genelde ≥ 0x410) büyük boyutlarla yapın, veya
+  - ilgili tcache bin'ini (7 giriş) doldurun ki ek free'lar global bin'lere ulaşsın, veya
+  - ortamı kontrol edebiliyorsanız tcache'i devre dışı bırakın (ör. GLIBC_TUNABLES glibc.malloc.tcache_count=0).
+- Unsorted liste üzerindeki bütünlük kontrolleri: unsorted bin'i inceleyen sonraki allocation yolunda, glibc (basitleştirilmiş olarak) şunları kontrol eder:
+  - `bck->fd == victim` ve `victim->fd == unsorted_chunks(av)`; aksi halde `malloc(): unsorted double linked list corrupted` ile abort eder.
+- Bu, hedeflediğiniz adresin iki yazmayı tolere etmesi gerektiği anlamına gelir: önce free‑zamanında `*(TARGET) = victim`; daha sonra chunk kaldırılırken `*(TARGET) = unsorted_chunks(av)` (allocator `bck->fd`'yi tekrar bin başına yazar). Sadece büyük, sıfır olmayan bir değer zorlamak işe yarayacak hedefler seçin.
+- Modern exploitlerde tipik olarak güvenli hedefler
+  - Uygulama veya global durumda "büyük" değerleri bayrak/limit olarak işleyen alanlar.
+  - Dolaylı primitifler (ör. sonrasında bir [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) için hazırlık yapmak veya daha sonra bir write‑what‑where pivotu).
+  - Yeni glibc'de `__malloc_hook`/`__free_hook`'tan kaçının: bunlar 2.34'te kaldırıldı. `global_max_fast`'ı ≥ 2.39 üzerinde kullanmaktan kaçının (bir sonraki notu görün).
+- `global_max_fast` hakkında (yeni glibc)
+  - glibc 2.39+ üzerinde, `global_max_fast` 8‑bit bir global'dir. Klasik hile olan heap pointer'ını oraya yazmak (fastbinleri büyütmek için) artık düzgün çalışmıyor ve muhtemelen bitişik allocator durumunu bozuyor. Diğer stratejileri tercih edin.
+
+## Minimal exploit tarifi (modern glibc)
+
+Amaç: unsorted‑bin insertion primitifi kullanarak çökertmeden heap pointer'ını tek seferlik bir rastgele adrese yazdırmak.
+
+- Düzen/grooming
+  - Tcache'i atlatacak kadar büyük boyutlarda A, B, C allocate edin (ör. 0x5000). C, top chunk ile konsolidasyonu önler.
+- Bozma
+  - A'dan B'nin chunk header'ına overflow yaparak `B->bk = (mchunkptr)(TARGET - 0x10)` ayarlayın.
+- Tetikleme
+  - `free(B)`. Ekleme sırasında allocator `bck->fd = B` ifadesini çalıştırır, dolayısıyla `*(TARGET) = B`.
+- Devam
+  - Eğer allocation yapmaya devam edecekseniz ve program unsorted bin'i kullanıyorsa, allocator'ın daha sonra `*(TARGET) = unsorted_chunks(av)` yazacağını bekleyin. Her iki değer de tipik olarak büyük olup, sadece "büyük" olup olmadığına bakan hedeflerde boyut/limit semantiğini değiştirmek için yeterli olabilir.
+
+Pseudocode skeleton:
+```c
+// 64-bit glibc 2.35–2.38 style layout (tcache bypass via large sizes)
+void *A = malloc(0x5000);
+void *B = malloc(0x5000);
+void *C = malloc(0x5000); // guard
+
+// overflow from A into B’s metadata (prev_size/size/.../bk). You must control B->bk.
+*(size_t *)((char*)B - 0x8) = (size_t)(TARGET - 0x10); // write fake bk
+
+free(B); // triggers *(TARGET) = B (unsorted-bin insertion write)
+```
+> [!NOTE]
+> • Eğer size ile tcache'i atlatamıyorsanız, bozulan chunk'ı free etmeden önce seçilen boyut için tcache bin'ini doldurun (7 frees) ki free unsorted'a gitsin.
+> • Eğer program bir sonraki allocation'da unsorted-bin kontrolleri nedeniyle hemen abort ediyorsa, `victim->fd`'nin hâlâ bin head'e eşit olduğunu ve ilk yazmadan sonra `TARGET`'in tam olarak `victim` pointer'ını tuttuğunu yeniden kontrol edin.
 
 ## Unsorted Bin Infoleak Attack
 
-Bu aslında çok temel bir kavramdır. Unsorted bin'deki chunk'lar pointer'lara sahip olacaktır. Unsorted bin'deki ilk chunk aslında **`fd`** ve **`bk`** bağlantılarına **ana arenanın (Glibc)** bir kısmına işaret edecektir.\
-Bu nedenle, bir chunk'ı unsorted bin içine **yerleştirip okuyabilirseniz** (free'den sonra kullanma) veya **en az 1 pointer'ı yazmadan tekrar tahsis ederseniz** ve ardından **okuyabilirseniz**, bir **Glibc bilgi sızıntısı** elde edebilirsiniz.
+Bu aslında çok temel bir konsept. unsorted bin'deki chunk'ların pointer'ları olur. Unsorted bin'deki ilk chunk gerçekte **`fd`** ve **`bk`** link'lerini **main arena (Glibc)**'nin bir kısmına işaret edecek şekilde tutar.\
+Dolayısıyla, eğer bir chunk'ı unsorted bin içine koyup okuyabiliyorsanız (use after free) veya en az bir pointer'ı ezmeden tekrar allocate edip sonra okuyabiliyorsanız, bir **Glibc info leak** elde edebilirsiniz.
 
-Bu yazımda kullanılan benzer bir [**saldırı**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), 4 chunk yapısını (A, B, C ve D - D yalnızca üst chunk ile konsolidasyonu önlemek için) kötüye kullanmak için B'de bir null byte overflow kullanarak C'nin B'nin kullanılmadığını belirtmesini sağladı. Ayrıca, B'de `prev_size` verisi değiştirilerek boyutun B'nin boyutu yerine A+B olması sağlandı.\
-Sonra C serbest bırakıldı ve A+B ile konsolide edildi (ancak B hala kullanılıyordu). A boyutunda yeni bir chunk tahsis edildi ve ardından libc sızdırılan adresler B'ye yazıldı ve buradan sızdırıldı.
+Benzer bir [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), 4 chunk'lık bir yapı (A, B, C ve D - D sadece top chunk ile consolidation'ı önlemek için) suiistimal edilerek yapılmış; B'deki 1 byte null overflow, C'nin B'nin unused olduğunu göstermesi için kullanılmış. Ayrıca B içinde `prev_size` verisi değiştirilmiş, böylece boyut B'nin boyutu yerine A+B olmuş.\
+Sonra C free edilmiş ve A+B ile consolidate olmuş (B hâlâ in use). Boyutu A olan yeni bir chunk allocate edilmiş ve ardından libc leaked adresleri B'ye yazılmış, buradan leak edilmişler.
 
-## Referanslar ve Diğer Örnekler
+## Referanslar ve Diğer örnekler
 
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
-- Amaç, 4869'dan büyük bir değerle bir global değişkeni yazmaktır, böylece bayrağı almak mümkün olur ve PIE etkin değildir.
-- Rastgele boyutlarda chunk'lar oluşturmak mümkündür ve istenen boyutta bir heap overflow vardır.
-- Saldırı, 3 chunk oluşturarak başlar: overflow'u kötüye kullanmak için chunk0, taşan chunk için chunk1 ve üst chunk'un önceki chunk'larla konsolide olmaması için chunk2.
-- Sonra, chunk1 serbest bırakılır ve chunk0, chunk1'in `bk` pointer'ına taşar: `bk = magic - 0x10`
-- Ardından, chunk1 ile aynı boyutta chunk3 tahsis edilir, bu da unsorted bin saldırısını tetikleyecek ve global değişkenin değerini değiştirecektir, böylece bayrağı almak mümkün olacaktır.
+- Amaç, PIE etkin değilken global bir değişkeni 4869'dan büyük bir değerle overwrite etmek (flag alınabilir hale getirmek).
+- İstenilen boyutta bir heap overflow ile arbitrary boyutlarda chunk üretmek mümkün.
+- Saldırı chunk'lar oluşturmakla başlar: overflow için chunk0, overflow edilecek chunk1 ve top chunk'un önceki chunk'larla consolidate olmasını önlemek için chunk2.
+- Ardından chunk1 free edilir ve chunk0, chunk1'in `bk` pointer'ına overflow edilir: `bk = magic - 0x10`
+- Sonra chunk3, chunk1 ile aynı boyutta allocate edilir; bu unsorted bin attack'ı tetikleyecek ve global değişkenin değerini değiştirecek, böylece flag alınabilecek hale gelecek.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
-- Birleştirme fonksiyonu, eğer geçen her iki indeks aynıysa, onu yeniden tahsis eder ve ardından serbest bırakır, ancak serbest bırakılan bölgeye bir pointer döndürür.
-- Bu nedenle, **2 chunk oluşturulur**: **chunk0** kendisiyle birleştirilecek ve üst chunk ile konsolide olmayı önlemek için chunk1. Ardından, **birleştirme fonksiyonu chunk0 ile** iki kez çağrılır, bu da free'den sonra kullanma durumuna neden olur.
-- Sonra, **`view`** fonksiyonu, free'den sonra kullanılan chunk'ın indeksi olan 2 ile çağrılır, bu da **bir libc adresini sızdırır**.
-- Binary, yalnızca **`global_max_fast`**'tan daha büyük boyutları malloc etmeye izin verdiğinden, hızlı bin kullanılmadığı için bir unsorted bin saldırısı kullanılacak ve global değişken `global_max_fast`'ı yazmak için kullanılacaktır.
-- Ardından, 2 indeksi (free'den sonra kullanılan pointer) ile edit fonksiyonu çağrılabilir ve `bk` pointer'ı `p64(global_max_fast-0x10)`'a işaret edecek şekilde yazılabilir. Ardından, daha önce tehlikeye atılmış serbest adresi (0x20) kullanarak yeni bir chunk oluşturmak, **unsorted bin saldırısını tetikleyecek** ve `global_max_fast`'ı çok büyük bir değerle yazacaktır, bu da artık hızlı binlerde chunk'lar oluşturmayı mümkün kılacaktır.
-- Şimdi bir **hızlı bin saldırısı** gerçekleştirilir:
-- Öncelikle, **`__free_hook`** konumunda hızlı **200 boyutunda chunk'larla çalışmanın mümkün olduğu keşfedilir**:
+- merge fonksiyonu, eğer aynı index iki kez geçirilirse realloc yapıp sonra free ettiği ve freed bölgeye işaret eden bir pointer döndürdüğü için vuln.
+- Bu sebeple, **2 chunk oluşturulur**: kendisiyle merge edilecek olan **chunk0** ve top chunk ile consolidate olmaması için chunk1. Sonra **merge** fonksiyonu chunk0 ile iki kez çağrılır ve bu use after free'e yol açar.
+- Ardından **`view`** fonksiyonu index 2 ile çağrılır (use after free chunk'un index'i), bu da **libc adresi leak** eder.
+- Binary, sadece `global_max_fast`'tan büyük boyutlarda malloc yapmaya izin veren korumalara sahip olduğundan fastbin kullanılmaz; bu yüzden `global_max_fast`'ı overwrite etmek için bir unsorted bin attack kullanılacak.
+- Sonra, edit fonksiyonu index 2 (use after free pointer) ile çağrılıp `bk` pointer'ı `p64(global_max_fast-0x10)`'a overwrite edilir. Ardından yeni bir chunk oluşturmak, daha önce değiştirilmiş free adresini kullanacak (0x20) ve **unsorted bin attack'ı** tetikleyerek `global_max_fast`'ı çok büyük bir değere overwrite eder; böylece artık fast bin'lerde chunk oluşturmak mümkün olur.
+- Şimdi bir **fast bin attack** gerçekleştirilir:
+- Öncelikle `__free_hook` konumunda fast boyutlu chunk'larla çalışılabildiği keşfedilir:
 - <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -58,16 +115,20 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- Bu konumda 0x200 boyutunda hızlı bir chunk elde edebilirsek, çalıştırılacak bir fonksiyon pointer'ını yazmak mümkün olacaktır.
-- Bunun için, `0xfc` boyutunda yeni bir chunk oluşturulur ve birleştirilmiş fonksiyon bu pointer ile iki kez çağrılır, bu şekilde hızlı bin içinde `0xfc*2 = 0x1f8` boyutunda serbest bir chunk'a işaret eden bir pointer elde ederiz.
-- Ardından, bu chunk'ta edit fonksiyonu çağrılarak bu hızlı binin **`fd`** adresi önceki **`__free_hook`** fonksiyonuna işaret edecek şekilde değiştirilir.
-- Ardından, hızlı bin'den önceki işe yaramaz chunk'ı almak için `0x1f8` boyutunda bir chunk oluşturulur, böylece **`__free_hook`** içinde hızlı bir chunk elde etmek için `0x1f8` boyutunda başka bir chunk oluşturulur ve bu, **`system`** fonksiyonunun adresi ile yazılır.
-- Ve nihayet, `/bin/sh\x00` dizesini içeren bir chunk serbest bırakılır ve delete fonksiyonu çağrılır, bu da **`__free_hook`** fonksiyonunu tetikler ve `/bin/sh\x00` parametresi ile system'a işaret eder.
+- Eğer bu konumda 0x200 boyutunda bir fast chunk elde edebilirsek, yürütülecek bir function pointer'ı overwrite etmek mümkün olacak.
+- Bunun için `0xfc` boyutunda yeni bir chunk oluşturulur ve merged fonksiyonu bu pointer ile iki kez çağrılır; böylece fast bin'de `0xfc*2 = 0x1f8` boyutunda freed bir chunk pointer'ı elde edilir.
+- Sonra edit fonksiyonu bu chunk'ta çağrılarak bu fast bin'in **`fd`** adresi önceki **`__free_hook`** fonksiyonuna işaret edecek şekilde değiştirilir.
+- Ardından `0x1f8` boyutunda bir chunk oluşturulur, fast bin'den o işe yaramaz chunk alınır ve başka bir `0x1f8` chunk daha oluşturularak `__free_hook`'ta bir fast bin chunk elde edilir; burası `system` fonksiyonunun adresiyle overwrite edilir.
+- Son olarak `/bin/sh\x00` içeren bir chunk delete fonksiyonu ile free edilerek `__free_hook` tetiklenir; `__free_hook` artık system'e işaret eder ve `/bin/sh\x00` parametresiyle çağrılır.
 - **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 bin'de chunk'ları konsolide etmek ve bir libc bilgi sızıntısı elde etmek için 1B overflow'un kötüye kullanılması ve ardından malloc hook'u bir gadget adresi ile yazmak için hızlı bin saldırısı gerçekleştirilmesi.
+- 1 byte overflow kullanılarak unsorted bin'de chunk'ların consolidate edilmesiyle libc infoleak elde edilip ardından fast bin attack ile malloc hook'un one gadget adresiyle overwrite edilmesine dair başka bir örnek
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
-- Sadece `0x100`'den büyük boyutlarda chunk'lar tahsis edebiliriz.
-- Unsorted Bin saldırısı kullanarak `global_max_fast`'ı yazmak (ASLR nedeniyle 1/16 kez çalışır, çünkü 12 bit değiştirmemiz gerekir, ancak 16 bit değiştirmeliyiz).
-- Global bir chunk dizisini değiştirmek için hızlı bin saldırısı. Bu, GOT'u değiştirme ve bazı fonksiyonları `system`'a işaret etme yeteneği veren rastgele okuma/yazma ilkesini sağlar.
+- Sadece `0x100`'den büyük boyutlarda chunk allocate edilebiliyor.
+- Unsorted Bin attack ile `global_max_fast` overwrite ediliyor (ASLR nedeniyle 1/16 oranında işe yarıyor; çünkü 12 bit'i değil 16 bit'i değiştirmek gerekiyor).
+- Fast Bin attack ile global bir chunk dizisi modify ediliyor. Bu, arbitrary read/write primitive sağlar ve GOT'u değiştirip bazı fonksiyonları `system`'e yönlendirmeye izin verir.
 
+## References
+
+- Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c
+- `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c
 {{#include ../../banners/hacktricks-training.md}}