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

6.2 KiB
Raw Blame History

Çift Serbest Bırakma

Sıfırdan kahraman olmaya kadar AWS hacklemeyi öğrenin htARTE (HackTricks AWS Kırmızı Takım Uzmanı) ile!

HackTricks'ı desteklemenin diğer yolları:

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:

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

İ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
i1: 0xaaab0f0c23a0
i2: 0xaaab0f0c23a0

Referanslar

Sıfırdan kahraman olmak için AWS hackleme öğrenin htARTE (HackTricks AWS Red Team Expert)!

HackTricks'ı desteklemenin diğer yolları: