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

6.8 KiB
Raw Permalink Blame History

Двоструко Ослобађање

Научите хаковање AWS-а од нуле до хероја са htARTE (HackTricks AWS Red Team Expert)!

Други начини да подржите HackTricks:

Основне Информације

Ако ослободите блок меморије више пута, то може да упропасти податке алокатора и отвори врати за нападе. Ево како се то дешава: када ослободите блок меморије, он се враћа у листу слободних чанкова (нпр. "fastbin"). Ако ослободите исти блок двапут за редом, алокатор то открива и баца грешку. Али ако ослободите други чанк између, двоструко-ослобађање провера се обилази, што може изазвати корупцију.

Сада, када захтевате нову меморију (користећи malloc), алокатор може да вам додели блок који је двапут ослобођен. Ово може довести до два различита показивача који показују на исту локацију меморије. Ако нападач контролише један од тих показивача, може променити садржај те меморије, што може изазвати безбедносне проблеме или им дозволити да изврше код.

Пример:

#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;
}

U ovom primeru, nakon što se tcache popuni sa nekoliko oslobođenih blokova, kod oslobađa blok h, zatim blok i, a zatim ponovo h, što uzrokuje grešku dvostrukog oslobađanja. Ovo otvara mogućnost dobijanja preklapajućih memorijskih adresa prilikom realokacije, što znači da dva ili više pokazivača mogu pokazivati na istu memorijsku lokaciju. Manipulisanje podacima putem jednog pokazivača može zatim uticati na drugi, stvarajući kritičan sigurnosni rizik i potencijal za eksploataciju.

Izvršavajući to, primetite kako su i1 i i2 dobili istu adresu:

Početne alokacije:
a: 0xaaab0f0c22a0
b: 0xaaab0f0c22c0
c: 0xaaab0f0c22e0
d: 0xaaab0f0c2300
e: 0xaaab0f0c2320
f: 0xaaab0f0c2340
g: 0xaaab0f0c2360
h: 0xaaab0f0c2380
i: 0xaaab0f0c23a0
Nakon realokacija:
a1: 0xaaab0f0c2360
b1: 0xaaab0f0c2340
c1: 0xaaab0f0c2320
d1: 0xaaab0f0c2300
e1: 0xaaab0f0c22e0
f1: 0xaaab0f0c22c0
g1: 0xaaab0f0c22a0
h1: 0xaaab0f0c2380
i1: 0xaaab0f0c23a0
i2: 0xaaab0f0c23a0

Reference

Naučite hakovanje AWS-a od nule do heroja sa htARTE (HackTricks AWS Red Team Expert)!

Drugi načini podrške HackTricks-u: