# Large Bin Attack

{{#include ../../banners/hacktricks-training.md}}

## Basic Information

Za više informacija o tome šta je veliki bin, proverite ovu stranicu:

{{#ref}}
bins-and-memory-allocations.md
{{#endref}}

Moguće je pronaći odličan primer u [**how2heap - large bin attack**](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/large_bin_attack.c).

U suštini, ovde možete videti kako, u najnovijoj "trenutnoj" verziji glibc (2.35), nije provereno: **`P->bk_nextsize`** što omogućava modifikaciju proizvoljne adrese sa vrednošću velikog bin chunk-a ako su ispunjeni određeni uslovi.

U tom primeru možete pronaći sledeće uslove:

- Veliki chunk je alociran
- Veliki chunk manji od prvog, ali u istom indeksu, je alociran
- Mora biti manji tako da mora ići prvi u bin
- (Chunk za sprečavanje spajanja sa vrhunskim chunk-om je kreiran)
- Zatim, prvi veliki chunk se oslobađa i novi chunk veći od njega se alocira -> Chunk1 ide u veliki bin
- Zatim, drugi veliki chunk se oslobađa
- Sada, ranjivost: Napadač može modifikovati `chunk1->bk_nextsize` na `[target-0x20]`
- Zatim, alocira se veći chunk od chunk 2, tako da se chunk2 ubacuje u veliki bin prepisujući adresu `chunk1->bk_nextsize->fd_nextsize` sa adresom chunk2

> [!TIP]
> Postoje i drugi potencijalni scenariji, stvar je dodati u veliki bin chunk koji je **manji** od trenutnog X chunk-a u bin-u, tako da treba biti umetnut neposredno pre njega u bin, i moramo biti u mogućnosti da modifikujemo X-ov **`bk_nextsize`** jer će se tu zapisati adresa manjeg chunk-a.

Ovo je relevantan kod iz malloc. Komentari su dodati da bi se bolje razumelo kako je adresa prepisana:
```c
/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
{
fwd = bck; // fwd = p1
bck = bck->bk; // bck = p1->bk

victim->fd_nextsize = fwd->fd; // p2->fd_nextsize = p1->fd (Note that p1->fd is p1 as it's the only chunk)
victim->bk_nextsize = fwd->fd->bk_nextsize; // p2->bk_nextsize = p1->fd->bk_nextsize
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // p1->fd->bk_nextsize->fd_nextsize = p2
}
```
Ovo se može koristiti za **prepisivanje `global_max_fast` globalne promenljive** libc kako bi se iskoristio fast bin napad sa većim delovima.

Možete pronaći još jedno odlično objašnjenje ovog napada u [**guyinatuxedo**](https://guyinatuxedo.github.io/32-largebin_attack/largebin_explanation0/index.html).

### Ostali primeri

- [**La casa de papel. HackOn CTF 2024**](https://7rocky.github.io/en/ctf/other/hackon-ctf/la-casa-de-papel/)
- Large bin napad u istoj situaciji kao što se pojavljuje u [**how2heap**](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/large_bin_attack.c).
- Write primitiv je složeniji, jer je `global_max_fast` ovde beskoristan.
- FSOP je potreban da se završi eksploatacija.

{{#include ../../banners/hacktricks-training.md}}