Double Free
Tip
AWS ํดํน ๋ฐฐ์ฐ๊ธฐ ๋ฐ ์ฐ์ตํ๊ธฐ:
HackTricks Training AWS Red Team Expert (ARTE)
GCP ํดํน ๋ฐฐ์ฐ๊ธฐ ๋ฐ ์ฐ์ตํ๊ธฐ:HackTricks Training GCP Red Team Expert (GRTE)
Azure ํดํน ๋ฐฐ์ฐ๊ธฐ ๋ฐ ์ฐ์ตํ๊ธฐ:
HackTricks Training Azure Red Team Expert (AzRTE)
HackTricks ์ง์ํ๊ธฐ
- ๊ตฌ๋ ๊ณํ ํ์ธํ๊ธฐ!
- **๐ฌ ๋์ค์ฝ๋ ๊ทธ๋ฃน ๋๋ ํ ๋ ๊ทธ๋จ ๊ทธ๋ฃน์ ์ฐธ์ฌํ๊ฑฐ๋ ํธ์ํฐ ๐ฆ @hacktricks_live๋ฅผ ํ๋ก์ฐํ์ธ์.
- HackTricks ๋ฐ HackTricks Cloud ๊นํ๋ธ ๋ฆฌํฌ์งํ ๋ฆฌ์ PR์ ์ ์ถํ์ฌ ํดํน ํธ๋ฆญ์ ๊ณต์ ํ์ธ์.
Basic Information
๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ๋ ๋ฒ ์ด์ ํด์ ํ๋ฉด ํ ๋น์์ ๋ฐ์ดํฐ๊ฐ ์๋ง์ด ๋์ด ๊ณต๊ฒฉ์ ๊ธธ์ ์ด ์ ์์ต๋๋ค. ์ด๋ ๋ค์๊ณผ ๊ฐ์ด ๋ฐ์ํฉ๋๋ค: ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ํด์ ํ๋ฉด, ๊ทธ๊ฒ์ ๋ฌด๋ฃ ์ฒญํฌ ๋ชฉ๋ก(์: โfast binโ)์ผ๋ก ๋์๊ฐ๋๋ค. ๋์ผํ ๋ธ๋ก์ ์ฐ์์ผ๋ก ๋ ๋ฒ ํด์ ํ๋ฉด, ํ ๋น์๋ ์ด๋ฅผ ๊ฐ์งํ๊ณ ์ค๋ฅ๋ฅผ ๋ฐ์์ํต๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ ์ฌ์ด์ ๋ค๋ฅธ ์ฒญํฌ๋ฅผ ํด์ ํ๋ฉด, ์ด์ค ํด์ ๊ฒ์ฌ๊ฐ ์ฐํ๋์ด ์์์ด ๋ฐ์ํฉ๋๋ค.
์ด์ ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฒญํ ๋(malloc ์ฌ์ฉ), ํ ๋น์๋ ๋ ๋ฒ ํด์ ๋ ๋ธ๋ก์ ์ ๊ณตํ ์ ์์ต๋๋ค. ์ด๋ก ์ธํด ๋ ๊ฐ์ ์๋ก ๋ค๋ฅธ ํฌ์ธํฐ๊ฐ ๋์ผํ ๋ฉ๋ชจ๋ฆฌ ์์น๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋ฉ๋๋ค. ๊ณต๊ฒฉ์๊ฐ ๊ทธ ํฌ์ธํฐ ์ค ํ๋๋ฅผ ์ ์ดํ๋ฉด, ๊ทธ ๋ฉ๋ชจ๋ฆฌ์ ๋ด์ฉ์ ๋ณ๊ฒฝํ ์ ์์ผ๋ฉฐ, ์ด๋ ๋ณด์ ๋ฌธ์ ๋ฅผ ์ผ์ผํค๊ฑฐ๋ ์ฌ์ง์ด ์ฝ๋๋ฅผ ์คํํ ์ ์๊ฒ ํ ์ ์์ต๋๋ค.
Example:
#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 *)i2);
return 0;
}
์ด ์์ ์์, ์ฌ๋ฌ ๊ฐ์ ํด์ ๋ ์ฒญํฌ(7)๋ก tcache๋ฅผ ์ฑ์ด ํ, ์ฝ๋๋ ์ฒญํฌ h๋ฅผ ํด์ ํ ๋ค์ ์ฒญํฌ i๋ฅผ ํด์ ํ๊ณ ๋ค์ h๋ฅผ ํด์ ํ์ฌ ์ด์ค ํด์ ๋ฅผ ๋ฐ์์ํต๋๋ค(Fast Bin dup์ด๋ผ๊ณ ๋ ํจ). ์ด๋ ์ฌํ ๋น ์ ๊ฒน์น๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋ฐ์ ๊ฐ๋ฅ์ฑ์ ์ด์ด์ฃผ๋ฉฐ, ๋ ๊ฐ ์ด์์ ํฌ์ธํฐ๊ฐ ๋์ผํ ๋ฉ๋ชจ๋ฆฌ ์์น๋ฅผ ๊ฐ๋ฆฌํฌ ์ ์์ต๋๋ค. ํ๋์ ํฌ์ธํฐ๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๋ฉด ๋ค๋ฅธ ํฌ์ธํฐ์ ์ํฅ์ ๋ฏธ์น ์ ์์ด, ์ด๋ ์ฌ๊ฐํ ๋ณด์ ์ํ๊ณผ ์
์ฉ ๊ฐ๋ฅ์ฑ์ ์ด๋ํฉ๋๋ค.
์คํํ ๋, i1๊ณผ i2๊ฐ ๋์ผํ ์ฃผ์๋ฅผ ๊ฐ์ก์์ ์ฃผ๋ชฉํ์ธ์:
์ด๊ธฐ ํ ๋น:
a: 0xaaab0f0c22a0
b: 0xaaab0f0c22c0
c: 0xaaab0f0c22e0
d: 0xaaab0f0c2300
e: 0xaaab0f0c2320
f: 0xaaab0f0c2340
g: 0xaaab0f0c2360
h: 0xaaab0f0c2380
i: 0xaaab0f0c23a0
์ฌํ ๋น ํ:
a1: 0xaaab0f0c2360
b1: 0xaaab0f0c2340
c1: 0xaaab0f0c2320
d1: 0xaaab0f0c2300
e1: 0xaaab0f0c22e0
f1: 0xaaab0f0c22c0
g1: 0xaaab0f0c22a0
h1: 0xaaab0f0c2380
i1: 0xaaab0f0c23a0
i2: 0xaaab0f0c23a0
์์
- Dragon Army. Hack The Box
- ์ฐ๋ฆฌ๋ ์ผ๋ฐ์ ์ธ
__malloc_hook๋ฎ์ด์ฐ๊ธฐ๋ฅผ ๋ฐฉ์งํ๋ ํฌ๊ธฐ0x70๋ฅผ ์ ์ธํ๊ณ ๋ Fast-Bin ํฌ๊ธฐ์ ์ฒญํฌ๋ง ํ ๋นํ ์ ์์ต๋๋ค. - ๋์ , Fast Bin dup์ ๋์์ผ๋ก
0x56๋ก ์์ํ๋ PIE ์ฃผ์๋ฅผ ์ฌ์ฉํฉ๋๋ค(1/2 ํ๋ฅ ). - PIE ์ฃผ์๊ฐ ์ ์ฅ๋๋ ํ ๊ณณ์ Glibc ๋ด๋ถ์
main_arena์ด๋ฉฐ,__malloc_hook๊ทผ์ฒ์ ์์ต๋๋ค. - ์ฐ๋ฆฌ๋
main_arena์ ํน์ ์คํ์ ์ ๋ชฉํ๋ก ํ์ฌ ๊ทธ๊ณณ์ ์ฒญํฌ๋ฅผ ํ ๋นํ๊ณ ,__malloc_hook์ ๋๋ฌํ ๋๊น์ง ์ฒญํฌ๋ฅผ ๊ณ์ ํ ๋นํ์ฌ ์ฝ๋ ์คํ์ ์ป์ต๋๋ค. - zero_to_hero. PicoCTF
- Tcache ๋น๊ณผ ๋ ๋ฐ์ดํธ ์ค๋ฒํ๋ก์ฐ๋ฅผ ์ฌ์ฉํ์ฌ ์ด์ค ํด์ ์ํฉ์ ๋ฌ์ฑํ ์ ์์ต๋๋ค:
- ์ฐ๋ฆฌ๋ ํฌ๊ธฐ
0x110์ ์ฒญํฌ ์ธ ๊ฐ(A,B,C)๋ฅผ ํ ๋นํฉ๋๋ค. B๋ฅผ ํด์ ํฉ๋๋ค.A๋ฅผ ํด์ ํ๊ณ ๋ ๋ฐ์ดํธ ์ค๋ฒํ๋ก์ฐ๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด ๋ค์ ํ ๋นํฉ๋๋ค.- ์ด์
B์ ํฌ๊ธฐ ํ๋๋0x100์ด ๋์ด,0x111๋์ ๋ค์ ํด์ ํ ์ ์์ต๋๋ค. - ์ฐ๋ฆฌ๋ ๋์ผํ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ๊ธฐ
0x110์ Tcache-bin ํ๋์ ํฌ๊ธฐ0x100์ Tcache-bin ํ๋๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ด์ค ํด์ ๊ฐ ๋ฐ์ํฉ๋๋ค. - ์ฐ๋ฆฌ๋ Tcache poisoning์ ์ฌ์ฉํ์ฌ ์ด์ค ํด์ ๋ฅผ ํ์ฉํฉ๋๋ค.
์ฐธ๊ณ ๋ฌธํ
Tip
AWS ํดํน ๋ฐฐ์ฐ๊ธฐ ๋ฐ ์ฐ์ตํ๊ธฐ:
HackTricks Training AWS Red Team Expert (ARTE)
GCP ํดํน ๋ฐฐ์ฐ๊ธฐ ๋ฐ ์ฐ์ตํ๊ธฐ:HackTricks Training GCP Red Team Expert (GRTE)
Azure ํดํน ๋ฐฐ์ฐ๊ธฐ ๋ฐ ์ฐ์ตํ๊ธฐ:
HackTricks Training Azure Red Team Expert (AzRTE)
HackTricks ์ง์ํ๊ธฐ
- ๊ตฌ๋ ๊ณํ ํ์ธํ๊ธฐ!
- **๐ฌ ๋์ค์ฝ๋ ๊ทธ๋ฃน ๋๋ ํ ๋ ๊ทธ๋จ ๊ทธ๋ฃน์ ์ฐธ์ฌํ๊ฑฐ๋ ํธ์ํฐ ๐ฆ @hacktricks_live๋ฅผ ํ๋ก์ฐํ์ธ์.
- HackTricks ๋ฐ HackTricks Cloud ๊นํ๋ธ ๋ฆฌํฌ์งํ ๋ฆฌ์ PR์ ์ ์ถํ์ฌ ํดํน ํธ๋ฆญ์ ๊ณต์ ํ์ธ์.


