เคฌเฅเคจเคฟเคฏเคพเคฆเฅ เคเคพเคจเคเคพเคฐเฅ
เคเคเคเฅเคธ เคเฅ เคธเฅเคเฅเคฐ เคเคฐเคจเฅ เคเฅ เคฆเคเฅเคทเคคเคพ เคฎเฅเค เคธเฅเคงเคพเคฐ เคเคฐเคจเฅ เคเฅ เคฒเคฟเค, เคนเคฐ เคเคเค เคเฅเคตเคฒ เคเค เคฒเคฟเคเคเฅเคก เคฒเคฟเคธเฅเค เคฎเฅเค เคจเคนเฅเค เคนเฅเคคเคพ, เคฌเคฒเฅเคเคฟ เคเค เคชเฅเคฐเคเคพเคฐ เคนเฅเคคเฅ เคนเฅเคเฅค เคฏเฅ เคฌเคฟเคจ เคนเฅเค เคเคฐ 5 เคชเฅเคฐเคเคพเคฐ เคเฅ เคฌเคฟเคจ เคนเฅเคคเฅ เคนเฅเค: 62 เคเฅเคเฅ เคฌเคฟเคจ, 63 เคฌเคกเคผเฅ เคฌเคฟเคจ, 1 เค
เคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ, 10 เคซเคพเคธเฅเค เคฌเคฟเคจ เคเคฐ 64 เคเฅเคเฅเคถ เคฌเคฟเคจ เคชเฅเคฐเคคเคฟ เคฅเฅเคฐเฅเคกเฅค
เคชเฅเคฐเคคเฅเคฏเฅเค เค
เคธเฅเคฐเฅเคเฅเคก, เคเฅเคเฅ เคเคฐ เคฌเคกเคผเฅ เคฌเคฟเคจ เคเฅ เคฒเคฟเค เคชเฅเคฐเคพเคฐเคเคญเคฟเค เคชเคคเคพ เคเคธเฅ เคเคฐเฅ เคเฅ เค
เคเคฆเคฐ เคนเฅเคคเคพ เคนเฅเฅค เคเคเคกเฅเคเฅเคธ 0 เคเคพ เคเคชเคฏเฅเค เคจเคนเฅเค เคเคฟเคฏเคพ เคเคพเคคเคพ, 1 เค
เคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคนเฅ, เคฌเคฟเคจ 2-64 เคเฅเคเฅ เคฌเคฟเคจ เคนเฅเค เคเคฐ เคฌเคฟเคจ 65-127 เคฌเคกเคผเฅ เคฌเคฟเคจ เคนเฅเคเฅค
เคเฅเคเฅเคถ (เคชเฅเคฐเคคเคฟ-เคฅเฅเคฐเฅเคก เคเฅเคถ) เคฌเคฟเคจ
เคนเคพเคฒเคพเคเคเคฟ เคฅเฅเคฐเฅเคกเฅเคธ เค
เคชเคจเฅ เคเฅเคฆ เคเฅ เคนเฅเคช เคฐเคเคจเฅ เคเฅ เคเฅเคถเคฟเคถ เคเคฐเคคเฅ เคนเฅเค (เคฆเฅเคเฅเค Arenas เคเคฐ Subheaps ), เคเค เคชเฅเคฐเคเฅเคฐเคฟเคฏเคพ เคเคฟเคธเคฎเฅเค เคฌเคนเฅเคค เคธเคพเคฐเฅ เคฅเฅเคฐเฅเคกเฅเคธ เคนเฅเคคเฅ เคนเฅเค (เคเฅเคธเฅ เคเค เคตเฅเคฌ เคธเคฐเฅเคตเคฐ) เคฆเฅเคธเคฐเฅ เคฅเฅเคฐเฅเคกเฅเคธ เคเฅ เคธเคพเคฅ เคนเฅเคช เคธเคพเคเคพ เคเคฐเคจเฅ เคเฅ เคธเคเคญเคพเคตเคจเคพ เคนเฅเคคเฅ เคนเฅ เฅค เคเคธ เคฎเคพเคฎเคฒเฅ เคฎเฅเค, เคฎเฅเคเฅเคฏ เคธเคฎเคพเคงเคพเคจ เคฒเฅเคเคฐ เคเคพ เคเคชเคฏเฅเค เคนเฅ, เคเฅ เคฅเฅเคฐเฅเคกเฅเคธ เคเฅ เคฎเคนเคคเฅเคตเคชเฅเคฐเฅเคฃ เคฐเฅเคช เคธเฅ เคงเฅเคฎเคพ เคเคฐ เคธเคเคคเคพ เคนเฅ เฅค
เคเคธเคฒเคฟเค, เคเค เคเฅเคเฅเคถ เคเค เคซเคพเคธเฅเค เคฌเคฟเคจ เคเฅ เคคเคฐเคน เคนเฅเคคเคพ เคนเฅ เคชเฅเคฐเคคเคฟ เคฅเฅเคฐเฅเคก เคเคธ เคคเคฐเคน เคธเฅ เคเคฟ เคฏเคน เคเค เคธเคฟเคเคเคฒ เคฒเคฟเคเคเฅเคก เคฒเคฟเคธเฅเค เคนเฅ เคเฅ เคเคเคเฅเคธ เคเฅ เคฎเคฐเฅเค เคจเคนเฅเค เคเคฐเคคเคพเฅค เคชเฅเคฐเคคเฅเคฏเฅเค เคฅเฅเคฐเฅเคก เคเฅ เคชเคพเคธ 64 เคธเคฟเคเคเคฒเฅ-เคฒเคฟเคเคเฅเคก เคเฅเคเฅเคถ เคฌเคฟเคจ เคนเฅเคคเฅ เคนเฅเคเฅค เคชเฅเคฐเคคเฅเคฏเฅเค เคฌเคฟเคจ เคฎเฅเค เค
เคงเคฟเคเคคเคฎ 7 เคธเคฎเคพเคจ เคเคเคพเคฐ เคเฅ เคเคเคเฅเคธ เคนเฅ เคธเคเคคเฅ เคนเฅเค เคเฅ 64-เคฌเคฟเค เคธเคฟเคธเฅเคเคฎ เคชเคฐ 24 เคธเฅ 1032B เคเคฐ 32-เคฌเคฟเค เคธเคฟเคธเฅเคเคฎ เคชเคฐ 12 เคธเฅ 516B เคเฅ เคฌเฅเค เคนเฅเคคเฅ เคนเฅเคเฅค
เคเคฌ เคเค เคฅเฅเคฐเฅเคก เคเค เคเคเค เคเฅ เคซเฅเคฐเฅ เคเคฐเคคเคพ เคนเฅ, เคฏเคฆเคฟ เคฏเคน เคเฅเคเฅเคถ เคฎเฅเค เคเคตเคเคเคฟเคค เคเคฐเคจเฅ เคเฅ เคฒเคฟเค เคฌเคนเฅเคค เคฌเคกเคผเคพ เคจเคนเฅเค เคนเฅ เคเคฐ เคธเคเคฌเคเคงเคฟเคค เคเฅเคเฅเคถ เคฌเคฟเคจ เคญเคฐเคพ เคจเคนเฅเค เคนเฅ (เคชเคนเคฒเฅ เคธเฅ 7 เคเคเคเฅเคธ), เคคเฅ เคเคธเฅ เคตเคนเคพเค เคเคตเคเคเคฟเคค เคเคฟเคฏเคพ เคเคพเคเคเคพ เฅค เคฏเคฆเคฟ เคฏเคน เคเฅเคเฅเคถ เคฎเฅเค เคจเคนเฅเค เคเคพ เคธเคเคคเคพ, เคคเฅ เคเคธเฅ เคซเฅเคฐเฅ เคเคชเคฐเฅเคถเคจ เคเฅ เคตเฅเคถเฅเคตเคฟเค เคฐเฅเคช เคธเฅ เคเคฐเคจเฅ เคเฅ เคฒเคฟเค เคนเฅเคช เคฒเฅเค เคเคพ เคเคเคคเคเคพเคฐ เคเคฐเคจเคพ เคนเฅเคเคพเฅค
เคเคฌ เคเค เคเคเค เคเคตเคเคเคฟเคค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ , เคฏเคฆเคฟ เคเคตเคถเฅเคฏเค เคเคเคพเคฐ เคเคพ เคเค เคซเฅเคฐเฅ เคเคเค เคเฅเคเฅเคถ เคฎเฅเค เคนเฅ เคคเฅ เคเคธเคเคพ เคเคชเคฏเฅเค เคเคฐเฅเคเคพ , เคฏเคฆเคฟ เคจเคนเฅเค, เคคเฅ เคเคธเฅ เคตเฅเคถเฅเคตเคฟเค เคฌเคฟเคจ เคฎเฅเค เคเค เคเฅเคเคจเฅ เคฏเคพ เคเค เคจเคฏเคพ เคฌเคจเคพเคจเฅ เคเฅ เคฒเคฟเค เคนเฅเคช เคฒเฅเค เคเคพ เคเคเคคเคเคพเคฐ เคเคฐเคจเคพ เคนเฅเคเคพเฅค
เคเคธ เคฎเคพเคฎเคฒเฅ เคฎเฅเค เคเค เค
เคจเฅเคเฅเคฒเคจ เคญเฅ เคนเฅ, เคเคฌเคเคฟ เคนเฅเคช เคฒเฅเค เคนเฅเคจเฅ เคชเคฐ, เคฅเฅเคฐเฅเคก เค
เคชเคจเฅ เคเฅเคเฅเคถ เคเฅ เค
เคจเฅเคฐเฅเคงเคฟเคค เคเคเคพเคฐ เคเฅ เคนเฅเคช เคเคเคเฅเคธ (7) เคธเฅ เคญเคฐเฅเคเคพ , เคคเคพเคเคฟ เคฏเคฆเคฟ เคเคธเฅ เคเคฐ เค
เคงเคฟเค เคเฅ เคเคตเคถเฅเคฏเคเคคเคพ เคนเฅ, เคคเฅ เคเคธเฅ เคเฅเคเฅเคถ เคฎเฅเค เคฎเคฟเคฒ เคเคพเคเคเคพเฅค
```c #include #include
int main(void) { char *chunk; chunk = malloc(24); printf("Address of the chunk: %p\n", (void *)chunk); gets(chunk); free(chunk); return 0; }
Copy เคเคธเฅ เคธเคเคเคฒเคฟเคค เคเคฐเฅเค เคเคฐ เคฎเฅเคเฅเคฏ เคซเคผเคเคเฅเคถเคจ เคธเฅ ret เคเคชเคเฅเคก เคฎเฅเค เคเค เคฌเฅเคฐเฅเคเคชเฅเคเคเค เคเฅ เคธเคพเคฅ เคกเคฟเคฌเค เคเคฐเฅเคเฅค เคซเคฟเคฐ gef เคเฅ เคธเคพเคฅ เคเคช เคเคชเคฏเฅเค เคฎเฅเค tcache เคฌเคฟเคจ เคฆเฅเค เคธเคเคคเฅ เคนเฅเค:
```bash
gefโค heap bins
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Tcachebins for thread 1 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Tcachebins[idx=0, size=0x20, count=1] โ Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) Tcache Structs & Functions
เคจเคฟเคฎเฅเคจเคฒเคฟเคเคฟเคค เคเฅเคก เคฎเฅเค max bins เคเคฐ chunks per index เคฆเฅเคเคจเคพ เคธเคเคญเคต เคนเฅ, tcache_entry tcache_perthread_struct
tcache_entry เคเคฐ tcache_perthread_struct```c // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c
/* We want 64 entries. This is an arbitrary limit, which tunables can reduce. */
define TCACHE_MAX_BINS 64
define MAX_TCACHE_SIZE tidx2usize (TCACHE_MAX_BINS-1)
/* Only used to pre-fill the tunables. */
define tidx2usize(idx) (((size_t) idx) * MALLOC_ALIGNMENT + MINSIZE - SIZE_SZ)
/* When "x" is from chunksize(). */
define csize2tidx(x) (((x) - MINSIZE + MALLOC_ALIGNMENT - 1) / MALLOC_ALIGNMENT)
/* When "x" is a user-provided size. */
define usize2tidx(x) csize2tidx (request2size (x))
/* With rounding and alignment, the bins are... idx 0 bytes 0..24 (64-bit) or 0..12 (32-bit) idx 1 bytes 25..40 or 13..20 idx 2 bytes 41..56 or 21..28 etc. */
/* This is another arbitrary limit, which tunables can change. Each tcache bin will hold at most this number of chunks. */
define TCACHE_FILL_COUNT 7
/* Maximum chunks in tcache bins for tunables. This value must fit the range of tcache->counts[] entries, else they may overflow. */
define MAX_TCACHE_COUNT UINT16_MAX
[...]
typedef struct tcache_entry { struct tcache_entry next; / This field exists to detect double frees. */ uintptr_t key; } tcache_entry;
/* There is one of these for each thread, which contains the per-thread cache (hence "tcache_perthread_struct"). Keeping overall size low is mildly important. Note that COUNTS and ENTRIES are redundant (we could have just counted the linked list each time), this is for performance reasons. */ typedef struct tcache_perthread_struct { uint16_t counts[TCACHE_MAX_BINS]; tcache_entry *entries[TCACHE_MAX_BINS]; } tcache_perthread_struct;
Copy </details>
เคซเคเคเฅเคถเคจ `__tcache_init` เคตเคน เคซเคเคเฅเคถเคจ เคนเฅ เคเฅ `tcache_perthread_struct` เคเคฌเฅเคเฅเคเฅเค เคเฅ เคฒเคฟเค เคธเฅเคฅเคพเคจ เคฌเคจเคพเคคเคพ เคเคฐ เคเคตเคเคเคฟเคค เคเคฐเคคเคพ เคนเฅเฅค
<details>
<summary>tcache_init เคเฅเคก</summary>
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3241C1-L3274C2
static void
tcache_init(void)
{
mstate ar_ptr;
void *victim = 0;
const size_t bytes = sizeof (tcache_perthread_struct);
if (tcache_shutting_down)
return;
arena_get (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
if (!victim && ar_ptr != NULL)
{
ar_ptr = arena_get_retry (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
}
if (ar_ptr != NULL)
__libc_lock_unlock (ar_ptr->mutex);
/* In a low memory situation, we may not be able to allocate memory
- in which case, we just keep trying later. However, we
typically do this very early, so either there is sufficient
memory, or there isn't enough memory to do non-trivial
allocations anyway. */
if (victim)
{
tcache = (tcache_perthread_struct *) victim;
memset (tcache, 0, sizeof (tcache_perthread_struct));
}
} Tcache เคเคเคกเฅเคเฅเคธ
Tcache เคฎเฅเค เคเค เคฌเคฟเคจ เคนเฅเคคเฅ เคนเฅเค เคเฅ เคเคเคพเคฐ เคเคฐ เคชเฅเคฐเคคเฅเคฏเฅเค เคเคเคกเฅเคเฅเคธ เคเฅ เคชเคนเคฒเฅ เคเคเค เคเฅ เคฒเคฟเค เคชเฅเคฐเคพเคฐเคเคญเคฟเค เคชเฅเคเคเคเคฐเฅเคธ เคเคฐ เคชเฅเคฐเคคเฅเคฏเฅเค เคเคเคกเฅเคเฅเคธ เคเฅ เคฒเคฟเค เคเคเคเฅเคธ เคเฅ เคฎเคพเคคเฅเคฐเคพ เคเค เคเคเค เคเฅ เค
เคเคฆเคฐ เคธเฅเคฅเคฟเคค เคนเฅเคคเฅ เคนเฅ เฅค เคเคธเคเคพ เคฎเคคเคฒเคฌ เคนเฅ เคเคฟ เคเคธ เคเคพเคจเคเคพเคฐเฅ เคเฅ เคธเคพเคฅ เคเคเค เคเฅ เคขเฅเคเคขเคจเคพ (เคเคฎเคคเฅเคฐ เคชเคฐ เคชเคนเคฒเคพ), เคธเคญเฅ tcache เคชเฅเคฐเคพเคฐเคเคญเคฟเค เคฌเคฟเคเคฆเฅเคเค เคเคฐ Tcache เคเคเคเฅเคธ เคเฅ เคฎเคพเคคเฅเคฐเคพ เคเฅ เคขเฅเคเคขเคจเคพ เคธเคเคญเคต เคนเฅเฅค
เคซเคพเคธเฅเค เคฌเคฟเคจ
เคซเคพเคธเฅเค เคฌเคฟเคจ เคเฅ เคเฅเคเฅ เคเคเคเฅเคธ เคเฅ เคฒเคฟเค เคฎเฅเคฎเฅเคฐเฅ เคเคตเคเคเคจ เคเฅ เคคเฅเค เคเคฐเคจเฅ เคเฅ เคฒเคฟเค เคกเคฟเคเคผเคพเคเคจ เคเคฟเคฏเคพ เคเคฏเคพ เคนเฅ เคเฅ เคนเคพเคฒ เคนเฅ เคฎเฅเค เคฎเฅเคเฅเคค เคเคฟเค เคเค เคเคเคเฅเคธ เคเฅ เคคเฅเคตเคฐเคฟเคค-เคเคเฅเคธเฅเคธ เคธเคเคฐเคเคจเคพ เคฎเฅเค เคฐเคเคคเฅ เคนเฅเคเฅค เคฏเฅ เคฌเคฟเคจ เคเค เคฒเคพเคธเฅเค-เคเคจ, เคซเคฐเฅเคธเฅเค-เคเคเค (LIFO) เคฆเฅเคทเฅเคเคฟเคเฅเคฃ เคเคพ เคเคชเคฏเฅเค เคเคฐเคคเฅ เคนเฅเค, เคเคฟเคธเคเคพ เค
เคฐเฅเคฅ เคนเฅ เคเคฟ เคนเคพเคฒ เคนเฅ เคฎเฅเค เคฎเฅเคเฅเคค เคเคฟเคฏเคพ เคเคฏเคพ เคเคเค เคชเคนเคฒเฅ เคซเคฟเคฐ เคธเฅ เคเคชเคฏเฅเค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ เคเคฌ เคเค เคจเคฏเคพ เคเคตเคเคเคจ เค
เคจเฅเคฐเฅเคง เคนเฅเคคเคพ เคนเฅเฅค เคฏเคน เคตเฅเคฏเคตเคนเคพเคฐ เคเคคเคฟ เคเฅ เคฒเคฟเค เคซเคพเคฏเคฆเฅเคฎเคเคฆ เคนเฅ, เคเฅเคฏเฅเคเคเคฟ เคเค เคธเฅเคเฅเค (LIFO) เคเฅ เคถเฅเคฐเฅเคท เคธเฅ เคกเคพเคฒเคจเคพ เคเคฐ เคนเคเคพเคจเคพ เคเค เคเคคเคพเคฐ (FIFO) เคเฅ เคคเฅเคฒเคจเคพ เคฎเฅเค เคคเฅเค เคนเฅเคคเคพ เคนเฅเฅค
เคเคธเคเฅ เค
เคคเคฟเคฐเคฟเคเฅเคค, เคซเคพเคธเฅเค เคฌเคฟเคจ เคธเคฟเคเคเคฒเฅ เคฒเคฟเคเคเฅเคก เคฒเคฟเคธเฅเค เคเคพ เคเคชเคฏเฅเค เคเคฐเคคเฅ เคนเฅเค , เคกเคฌเคฒ เคฒเคฟเคเคเฅเคก เคจเคนเฅเค, เคเฅ เคเคคเคฟ เคเฅ เคเคฐ เคฌเคขเคผเคพเคคเคพ เคนเฅเฅค เคเฅเคเคเคฟ เคซเคพเคธเฅเค เคฌเคฟเคจ เคฎเฅเค เคเคเคเฅเคธ เคชเคกเคผเฅเคธเฅ เคเฅ เคธเคพเคฅ เคตเคฟเคฒเคฏ เคจเคนเฅเค เคนเฅเคคเฅ เคนเฅเค, เคเคธเคฒเคฟเค เคฎเคงเฅเคฏ เคธเฅ เคนเคเคพเคจเฅ เคเฅ เค
เคจเฅเคฎเคคเคฟ เคฆเฅเคจเฅ เคเฅ เคฒเคฟเค เคเค เคเคเคฟเคฒ เคธเคเคฐเคเคจเคพ เคเฅ เคเคตเคถเฅเคฏเคเคคเคพ เคจเคนเฅเค เคนเฅเคคเฅ เคนเฅเฅค เคเค เคธเคฟเคเคเคฒเฅ เคฒเคฟเคเคเฅเคก เคฒเคฟเคธเฅเค เคเคจ เคเคชเคฐเฅเคถเคจเฅเค เคเฅ เคฒเคฟเค เคธเคฐเคฒ เคเคฐ เคคเฅเค เคนเฅเคคเฅ เคนเฅเฅค
เคฌเฅเคจเคฟเคฏเคพเคฆเฅ เคฐเฅเคช เคธเฅ, เคฏเคนเคพเค เคเฅ เคนเฅเคคเคพ เคนเฅ เคตเคน เคฏเคน เคนเฅ เคเคฟ เคนเฅเคกเคฐ (เคชเคนเคฒเฅ เคเคเค เคเฅ เคเคพเคเค เคเฅ เคฒเคฟเค เคชเฅเคเคเคเคฐ) เคนเคฎเฅเคถเคพ เคเคธ เคเคเคพเคฐ เคเฅ เคจเคตเฅเคจเคคเคฎ เคฎเฅเคเฅเคค เคเคเค เคเฅ เคเคฐ เคเคถเคพเคฐเคพ เคเคฐ เคฐเคนเคพ เคนเฅเคคเคพ เคนเฅเฅค เคคเฅ:
เคเคฌ เคเคธ เคเคเคพเคฐ เคเคพ เคเค เคจเคฏเคพ เคเคเค เคเคตเคเคเคฟเคค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ, เคคเฅ เคนเฅเคกเคฐ เคเค เคฎเฅเคเฅเคค เคเคเค เคเฅ เคเคฐ เคเคถเคพเคฐเคพ เคเคฐ เคฐเคนเคพ เคนเฅเคคเคพ เคนเฅเฅค เคเฅเคเคเคฟ เคฏเคน เคฎเฅเคเฅเคค เคเคเค เคเคชเคฏเฅเค เคเฅ เคฒเคฟเค เค
เคเคฒเฅ เคเคเค เคเฅ เคเคฐ เคเคถเคพเคฐเคพ เคเคฐ เคฐเคนเคพ เคนเฅ, เคฏเคน เคชเคคเคพ เคนเฅเคกเคฐ เคฎเฅเค เคธเคเคเฅเคฐเคนเฅเคค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ เคคเคพเคเคฟ เค
เคเคฒเฅ เคเคตเคเคเคจ เคเฅ เคชเคคเคพ เคเคฒเฅ เคเคฟ เคเคชเคฒเคฌเฅเคง เคเคเค เคเคนเคพเค เคธเฅ เคชเฅเคฐเคพเคชเฅเคค เคเคฐเคจเคพ เคนเฅเฅค
เคเคฌ เคเค เคเคเค เคฎเฅเคเฅเคค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ, เคคเฅ เคฎเฅเคเฅเคค เคเคเค เคตเคฐเฅเคคเคฎเคพเคจ เคเคชเคฒเคฌเฅเคง เคเคเค เคเฅ เคชเคคเฅ เคเฅ เคธเคนเฅเคเคคเคพ เคนเฅ เคเคฐ เคเคธ เคจเค เคฎเฅเคเฅเคค เคเคฟเค เคเค เคเคเค เคเคพ เคชเคคเคพ เคนเฅเคกเคฐ เคฎเฅเค เคฐเคเคพ เคเคพเคเคเคพเฅค
เคเค เคฒเคฟเคเคเฅเคก เคฒเคฟเคธเฅเค เคเคพ เค
เคงเคฟเคเคคเคฎ เคเคเคพเคฐ 0x80 เคนเฅ เคเคฐ เคเคจเฅเคนเฅเค เคเคธ เคคเคฐเคน เคธเฅ เคตเฅเคฏเคตเคธเฅเคฅเคฟเคค เคเคฟเคฏเคพ เคเคฏเคพ เคนเฅ เคเคฟ 0x20 เคเคเคพเคฐ เคเคพ เคเค เคเคเค เคเคเคกเฅเคเฅเคธ 0 เคฎเฅเค เคนเฅเคเคพ, 0x30 เคเคเคพเคฐ เคเคพ เคเค เคเคเค เคเคเคกเฅเคเฅเคธ 1 เคฎเฅเค เคนเฅเคเคพ...
เคซเคพเคธเฅเค เคฌเคฟเคจ เคฎเฅเค เคเคเคเฅเคธ เคเฅ เคเคชเคฒเคฌเฅเคง เคเฅ เคฐเฅเคช เคฎเฅเค เคธเฅเค เคจเคนเฅเค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ, เคเคธเคฒเคฟเค เคเคจเฅเคนเฅเค เคเฅเค เคธเคฎเคฏ เคเฅ เคฒเคฟเค เคซเคพเคธเฅเค เคฌเคฟเคจ เคเคเคเฅเคธ เคเฅ เคฐเฅเคช เคฎเฅเค เคฐเคเคพ เคเคพเคคเคพ เคนเฅ เคฌเคเคพเคฏ เคเคธเคเฅ เคเคฟ เคตเฅ เคเคพเคฐเฅเค เคเคฐ เคเฅ เค
เคจเฅเคฏ เคฎเฅเคเฅเคค เคเคเคเฅเคธ เคเฅ เคธเคพเคฅ เคตเคฟเคฒเคฏ เคเคฐ เคธเคเฅเคเฅค
Copy // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
/*
Fastbins
An array of lists holding recently freed small chunks. Fastbins
are not doubly linked. It is faster to single-link them, and
since chunks are never removed from the middles of these lists,
double linking is not necessary. Also, unlike regular bins, they
are not even processed in FIFO order (they use faster LIFO) since
ordering doesn't much matter in the transient contexts in which
fastbins are normally used.
Chunks in fastbins keep their inuse bit set, so they cannot
be consolidated with other free chunks. malloc_consolidate
releases all chunks in fastbins and consolidates them with
other free chunks.
*/
typedef struct malloc_chunk * mfastbinptr;
#define fastbin (ar_ptr , idx) ((ar_ptr) -> fastbinsY[idx])
/* offset 2 to use otherwise unindexable first 2 bins */
#define fastbin_index (sz) \
(((( unsigned int ) (sz)) >> (SIZE_SZ == 8 ? 4 : 3 )) - 2 )
/* The maximum fastbin request size we support */
#define MAX_FAST_SIZE ( 80 * SIZE_SZ / 4 )
#define NFASTBINS ( fastbin_index ( request2size (MAX_FAST_SIZE)) + 1 ) ```c #include #include
int main(void) { char *chunks[8]; int i;
// Loop to allocate memory 8 times for (i = 0; i < 8; i++) { chunks[i] = malloc(24); if (chunks[i] == NULL) { // Check if malloc failed fprintf(stderr, "Memory allocation failed at iteration %d\n", i); return 1; } printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); }
// Loop to free the allocated memory for (i = 0; i < 8; i++) { free(chunks[i]); }
return 0; }
Copy เคงเฅเคฏเคพเคจ เคฆเฅเค เคเคฟ เคนเคฎ เคธเคฎเคพเคจ เคเคเคพเคฐ เคเฅ 8 เคเคเคเฅเคธ เคเฅ เคเฅเคธเฅ เคเคตเคเคเคฟเคค เคเคฐ เคฎเฅเคเฅเคค เคเคฐเคคเฅ เคนเฅเค เคคเคพเคเคฟ เคตเฅ tcache เคเฅ เคญเคฐ เคฆเฅเค เคเคฐ เคเค เคตเคพเค เคซเคพเคธเฅเค เคเคเค เคฎเฅเค เคธเคเคเฅเคฐเคนเฅเคค เคนเฅเฅค
เคเคธเฅ เคธเคเคเคฒเคฟเคค เคเคฐเฅเค เคเคฐ `main` เคซเคผเคเคเฅเคถเคจ เคธเฅ `ret` เคเคชเคเฅเคก เคฎเฅเค เคเค เคฌเฅเคฐเฅเคเคชเฅเคเคเค เคเฅ เคธเคพเคฅ เคกเคฟเคฌเค เคเคฐเฅเคเฅค เคซเคฟเคฐ `gef` เคเฅ เคธเคพเคฅ เคเคช เคฆเฅเค เคธเคเคคเฅ เคนเฅเค เคเคฟ tcache เคฌเคฟเคจ เคญเคฐเคพ เคนเฅเค เคนเฅ เคเคฐ เคเค เคเคเค เคซเคพเคธเฅเค เคฌเคฟเคจ เคฎเฅเค เคนเฅ:
```bash
gefโค heap bins
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Tcachebins for thread 1 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Tcachebins[idx=0, size=0x20, count=7] โ Chunk(addr=0xaaaaaaac1770, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac1750, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac1730, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac1710, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac16f0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac16d0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Fastbins for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Fastbins[idx=0, size=0x20] โ Chunk(addr=0xaaaaaaac1790, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
Fastbins[idx=1, size=0x30] 0x00 เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ
เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคเค เคเฅเคถ เคนเฅ เคเคฟเคธเคเคพ เคเคชเคฏเฅเค เคนเฅเคช เคชเฅเคฐเคฌเคเคงเค เคฆเฅเคตเคพเคฐเคพ เคฎเฅเคฎเฅเคฐเฅ เคเคตเคเคเคจ เคเฅ เคคเฅเคเคผ เคฌเคจเคพเคจเฅ เคเฅ เคฒเคฟเค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅเฅค เคฏเคน เคเคธ เคชเฅเคฐเคเคพเคฐ เคเคพเคฎ เคเคฐเคคเคพ เคนเฅ: เคเคฌ เคเค เคชเฅเคฐเฅเคเฅเคฐเคพเคฎ เคเค เคเฅเคเคกเคผเคพ เคฎเฅเคเฅเคค เคเคฐเคคเคพ เคนเฅ, เคเคฐ เคฏเคฆเคฟ เคฏเคน เคเฅเคเคกเคผเคพ เคเค tcache เคฏเคพ เคซเคพเคธเฅเค เคฌเคฟเคจ เคฎเฅเค เคเคตเคเคเคฟเคค เคจเคนเฅเค เคเคฟเคฏเคพ เคเคพ เคธเคเคคเคพ เคนเฅ เคเคฐ เคถเฅเคฐเฅเคท เคเฅเคเคกเคผเฅ เคเฅ เคธเคพเคฅ เคเคเคฐเคพ เคจเคนเฅเค เคฐเคนเคพ เคนเฅ, เคคเฅ เคนเฅเคช เคชเฅเคฐเคฌเคเคงเค เคคเฅเคฐเคเคค เคเคธเฅ เคเคฟเคธเฅ เคตเคฟเคถเฅเคท เคเฅเคเฅ เคฏเคพ เคฌเคกเคผเฅ เคฌเคฟเคจ เคฎเฅเค เคจเคนเฅเค เคฐเคเคคเคพเฅค เคเคธเคเฅ เคฌเคเคพเคฏ, เคฏเคน เคชเคนเคฒเฅ เคเคฟเคธเฅ เคญเฅ เคชเคกเคผเฅเคธเฅ เคฎเฅเคเฅเคค เคเฅเคเคกเคผเฅเค เคเฅ เคธเคพเคฅ เคฎเคฟเคฒเคพเคจเฅ เคเฅ เคเฅเคถเคฟเคถ เคเคฐเคคเคพ เคนเฅ เคคเคพเคเคฟ เคฎเฅเคเฅเคค เคฎเฅเคฎเฅเคฐเฅ เคเคพ เคเค เคฌเคกเคผเคพ เคฌเฅเคฒเฅเค เคฌเคจเคพเคฏเคพ เคเคพ เคธเคเฅเฅค เคซเคฟเคฐ, เคฏเคน เคเคธ เคจเค เคเฅเคเคกเคผเฅ เคเฅ "เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ" เคจเคพเคฎเค เคเค เคธเคพเคฎเคพเคจเฅเคฏ เคฌเคฟเคจ เคฎเฅเค เคฐเคเคคเคพ เคนเฅเฅค
เคเคฌ เคเค เคชเฅเคฐเฅเคเฅเคฐเคพเคฎ เคฎเฅเคฎเฅเคฐเฅ เคเฅ เคฒเคฟเค เคชเฅเคเคคเคพ เคนเฅ , เคคเฅ เคนเฅเคช เคชเฅเคฐเคฌเคเคงเค เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคเฅ เคเคพเคเค เคเคฐเคคเคพ เคนเฅ เคฏเคน เคฆเฅเคเคจเฅ เคเฅ เคฒเคฟเค เคเคฟ เคเฅเคฏเคพ เคตเคนเคพเค เคชเคฐเฅเคฏเคพเคชเฅเคค เคเคเคพเคฐ เคเคพ เคเค เคเฅเคเคกเคผเคพ เคนเฅเฅค เคฏเคฆเคฟ เคฏเคน เคเค เคชเคพเคคเคพ เคนเฅ, เคคเฅ เคเคธเคเคพ เคคเฅเคฐเคเคค เคเคชเคฏเฅเค เคเคฐเคคเคพ เคนเฅเฅค เคฏเคฆเคฟ เคเคธเฅ เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคฎเฅเค เคเคชเคฏเฅเคเฅเคค เคเฅเคเคกเคผเคพ เคจเคนเฅเค เคฎเคฟเคฒเคคเคพ เคนเฅ, เคคเฅ เคฏเคน เคเคธ เคธเฅเคเฅ เคฎเฅเค เคธเคญเฅ เคเฅเคเคกเคผเฅเค เคเฅ เคเคจเคเฅ เคเคเคพเคฐ เคเฅ เคเคงเคพเคฐ เคชเคฐ เคเฅเคเฅ เคฏเคพ เคฌเคกเคผเฅ เคฌเคฟเคจ เคฎเฅเค เคธเฅเคฅเคพเคจเคพเคเคคเคฐเคฟเคค เคเคฐ เคฆเฅเคคเคพ เคนเฅเฅค
เคงเฅเคฏเคพเคจ เคฆเฅเค เคเคฟ เคฏเคฆเคฟ เคเค เคฌเคกเคผเคพ เคเฅเคเคกเคผเคพ 2 เคเคงเฅเค เคฎเฅเค เคตเคฟเคญเคพเคเคฟเคค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ เคเคฐ เคฌเคพเคเฅ MINSIZE เคธเฅ เคฌเคกเคผเคพ เคนเฅ, เคคเฅ เคเคธเฅ เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคฎเฅเค เคตเคพเคชเคธ เคฐเคเคพ เคเคพเคเคเคพเฅค
เคคเฅ, เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคนเคพเคฒ เคนเฅ เคฎเฅเค เคฎเฅเคเฅเคค เคเฅ เคเค เคฎเฅเคฎเฅเคฐเฅ เคเฅ เคคเฅเคเฅ เคธเฅ เคชเฅเคจ: เคเคชเคฏเฅเค เคเคฐเคเฅ เคฎเฅเคฎเฅเคฐเฅ เคเคตเคเคเคจ เคเฅ เคคเฅเคเคผ เคเคฐเคจเฅ เคเคพ เคเค เคคเคฐเฅเคเคพ เคนเฅ เคเคฐ เคธเคฎเคฏ-เคเคชเคค เคเคฐเคจเฅ เคตเคพเคฒเฅ เคเฅเคเฅเค เคเคฐ เคตเคฟเคฒเคฏ เคเฅ เคเคตเคถเฅเคฏเคเคคเคพ เคเฅ เคเคฎ เคเคฐเคคเคพ เคนเฅเฅค
เคงเฅเคฏเคพเคจ เคฆเฅเค เคเคฟ เคญเคฒเฅ เคนเฅ เคเฅเคเคกเคผเฅ เคตเคฟเคญเคฟเคจเฅเคจ เคถเฅเคฐเฅเคฃเคฟเคฏเฅเค เคเฅ เคนเฅเค, เคฏเคฆเคฟ เคเค เคเคชเคฒเคฌเฅเคง เคเฅเคเคกเคผเคพ เคฆเฅเคธเคฐเฅ เคเคชเคฒเคฌเฅเคง เคเฅเคเคกเคผเฅ เคเฅ เคธเคพเคฅ เคเคเคฐเคพ เคฐเคนเคพ เคนเฅ (เคญเคฒเฅ เคนเฅ เคตเฅ เคฎเฅเคฒ เคฐเฅเคช เคธเฅ เคตเคฟเคญเคฟเคจเฅเคจ เคฌเคฟเคจเฅเค เคธเฅ เคธเคเคฌเคเคงเคฟเคค เคนเฅเค), เคคเฅ เคเคจเฅเคนเฅเค เคฎเคฟเคฒเคพเคฏเคพ เคเคพเคเคเคพเฅค
```c #include #include
int main(void) { char *chunks[9]; int i;
// Loop to allocate memory 8 times for (i = 0; i < 9; i++) { chunks[i] = malloc(0x100); if (chunks[i] == NULL) { // Check if malloc failed fprintf(stderr, "Memory allocation failed at iteration %d\n", i); return 1; } printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); }
// Loop to free the allocated memory for (i = 0; i < 8; i++) { free(chunks[i]); }
return 0; }
Copy เคงเฅเคฏเคพเคจ เคฆเฅเค เคเคฟ เคนเคฎ เคเค เคนเฅ เคเคเคพเคฐ เคเฅ 9 เคเคเคเฅเคธ เคเฅ เคเฅเคธเฅ เคเคตเคเคเคฟเคค เคเคฐ เคฎเฅเคเฅเคค เคเคฐเคคเฅ เคนเฅเค เคคเคพเคเคฟ เคตเฅ **tcache เคเฅ เคญเคฐ เคฆเฅเค** เคเคฐ เคเค เคตเคพเค เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคฎเฅเค เคธเคเคเฅเคฐเคนเฅเคค เคนเฅเคคเคพ เคนเฅ เคเฅเคฏเฅเคเคเคฟ เคฏเคน **fastbin เคเฅ เคฒเคฟเค เคฌเคนเฅเคค เคฌเคกเคผเคพ เคนเฅ** เคเคฐ เคจเฅเคตเคพเค เคฎเฅเคเฅเคค เคจเคนเฅเค เคเคฟเคฏเคพ เคเคฏเคพ เคนเฅ เคเคธเคฒเคฟเค เคจเฅเคตเคพเค เคเคฐ เคเค เคตเคพเค **เคถเฅเคฐเฅเคท เคเคเค เคเฅ เคธเคพเคฅ เคตเคฟเคฒเคฏ เคจเคนเฅเค เคนเฅเคคเฅ**เฅค
เคเคธเฅ เคธเคเคเคฒเคฟเคค เคเคฐเฅเค เคเคฐ `main` เคซเคผเคเคเฅเคถเคจ เคธเฅ `ret` เคเคชเคเฅเคก เคฎเฅเค เคเค เคฌเฅเคฐเฅเคเคชเฅเคเคเค เคเฅ เคธเคพเคฅ เคกเคฟเคฌเค เคเคฐเฅเคเฅค เคซเคฟเคฐ `gef` เคเฅ เคธเคพเคฅ เคเคช เคฆเฅเค เคธเคเคคเฅ เคนเฅเค เคเคฟ tcache เคฌเคฟเคจ เคญเคฐเคพ เคนเฅเค เคนเฅ เคเคฐ เคเค เคเคเค เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคฎเฅเค เคนเฅ:
```bash
gefโค heap bins
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Tcachebins for thread 1 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Tcachebins[idx=15, size=0x110, count=7] โ Chunk(addr=0xaaaaaaac1d10, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac1c00, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac1af0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac19e0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac18d0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac17c0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac12a0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Fastbins for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Fastbins[idx=0, size=0x20] 0x00
Fastbins[idx=1, size=0x30] 0x00
Fastbins[idx=2, size=0x40] 0x00
Fastbins[idx=3, size=0x50] 0x00
Fastbins[idx=4, size=0x60] 0x00
Fastbins[idx=5, size=0x70] 0x00
Fastbins[idx=6, size=0x80] 0x00
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Unsorted Bin for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
[+] unsorted_bins[0]: fw=0xaaaaaaac1e10, bk=0xaaaaaaac1e10
โ Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[+] Found 1 chunks in unsorted bin. เคเฅเคเฅ เคฌเคฟเคจ
เคเฅเคเฅ เคฌเคฟเคจ เคฌเคกเคผเฅ เคฌเคฟเคจเฅเค เคเฅ เคคเฅเคฒเคจเคพ เคฎเฅเค เคคเฅเค เคนเฅเคคเฅ เคนเฅเค เคฒเฅเคเคฟเคจ เคคเฅเค เคฌเคฟเคจเฅเค เคเฅ เคคเฅเคฒเคจเคพ เคฎเฅเค เคงเฅเคฎเฅ เคนเฅเคคเฅ เคนเฅเคเฅค
62 เคเฅ เคชเฅเคฐเคคเฅเคฏเฅเค เคฌเคฟเคจ เคฎเฅเค เคเค เคนเฅ เคเคเคพเคฐ เคเฅ เคเฅเคเคกเคผเฅ เคนเฅเคเคเฅ: 16, 24, ... (32-เคฌเคฟเค เคฎเฅเค เค
เคงเคฟเคเคคเคฎ เคเคเคพเคฐ 504 เคฌเคพเคเค เคเคฐ 64-เคฌเคฟเค เคฎเฅเค 1024)เฅค เคฏเคน เคเคธ เคฌเคฟเคจ เคเฅ เคเฅเคเคจเฅ เคเฅ เคเคคเคฟ เคฎเฅเค เคฎเคฆเคฆ เคเคฐเคคเคพ เคนเฅ เคเคนเคพเค เคธเฅเคฅเคพเคจ เคเคตเคเคเคฟเคค เคเคฟเคฏเคพ เคเคพเคจเคพ เคเคพเคนเคฟเค เคเคฐ เคเคจ เคธเฅเคเคฟเคฏเฅเค เคชเคฐ เคชเฅเคฐเคตเคฟเคทเฅเคเคฟเคฏเฅเค เคเฅ เคกเคพเคฒเคจเฅ เคเคฐ เคนเคเคพเคจเฅ เคฎเฅเคเฅค
เคฏเคน เคเคธ เคคเคฐเคน เคธเฅ เคนเฅ เคเคฟ เคเฅเคเฅ เคฌเคฟเคจ เคเคพ เคเคเคพเคฐ เคฌเคฟเคจ เคเฅ เค
เคจเฅเคเฅเคฐเคฎเคพเคเค เคเฅ เค
เคจเฅเคธเคพเคฐ เคเคฃเคจเคพ เคเฅ เคเคพเคคเฅ เคนเฅ:
เคธเคฌเคธเฅ เคเฅเคเคพ เคเคเคพเคฐ: 2*4*เค
เคจเฅเคเฅเคฐเคฎเคพเคเค (เคเฅเคธเฅ เค
เคจเฅเคเฅเคฐเคฎเคพเคเค 5 -> 40)
เคธเคฌเคธเฅ เคฌเคกเคผเคพ เคเคเคพเคฐ: 2*8*เค
เคจเฅเคเฅเคฐเคฎเคพเคเค (เคเฅเคธเฅ เค
เคจเฅเคเฅเคฐเคฎเคพเคเค 5 -> 80)
Copy // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
#define NSMALLBINS 64
#define SMALLBIN_WIDTH MALLOC_ALIGNMENT
#define SMALLBIN_CORRECTION (MALLOC_ALIGNMENT > CHUNK_HDR_SZ)
#define MIN_LARGE_SIZE ((NSMALLBINS - SMALLBIN_CORRECTION) * SMALLBIN_WIDTH)
#define in_smallbin_range (sz) \
(( unsigned long ) (sz) < ( unsigned long ) MIN_LARGE_SIZE)
#define smallbin_index (sz) \
((SMALLBIN_WIDTH == 16 ? ((( unsigned ) (sz)) >> 4 ) : ((( unsigned ) (sz)) >> 3 ))\
+ SMALLBIN_CORRECTION) เคเฅเคเฅ เคเคฐ เคฌเคกเคผเฅ เคฌเคฟเคจ เคเฅ เคฌเฅเค เคเคฏเคจ เคเคฐเคจเฅ เคเฅ เคฒเคฟเค เคซเคผเคเคเฅเคถเคจ:
Copy #define bin_index (sz) \
(( in_smallbin_range (sz)) ? smallbin_index (sz) : largebin_index (sz)) ```c #include #include
int main(void) { char *chunks[10]; int i;
// Loop to allocate memory 8 times for (i = 0; i < 9; i++) { chunks[i] = malloc(0x100); if (chunks[i] == NULL) { // Check if malloc failed fprintf(stderr, "Memory allocation failed at iteration %d\n", i); return 1; } printf("Address of chunk %d: %p\n", i, (void *)chunks[i]); }
// Loop to free the allocated memory for (i = 0; i < 8; i++) { free(chunks[i]); }
chunks[9] = malloc(0x110);
return 0; }
Copy เคจเฅเค เคเคฐเฅเค เคเคฟ เคนเคฎ เคเค เคนเฅ เคเคเคพเคฐ เคเฅ 9 เคเคเคเฅเคธ เคเฅ เคเฅเคธเฅ เคเคตเคเคเคฟเคค เคเคฐ เคฎเฅเคเฅเคค เคเคฐเคคเฅ เคนเฅเค เคคเคพเคเคฟ เคตเฅ **tcache เคเฅ เคญเคฐ เคฆเฅเค** เคเคฐ เคเค เคตเคพเค เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคฎเฅเค เคธเคเคเฅเคฐเคนเฅเคค เคนเฅเคคเคพ เคนเฅ เคเฅเคฏเฅเคเคเคฟ เคฏเคน **fastbin เคเฅ เคฒเคฟเค เคฌเคนเฅเคค เคฌเคกเคผเคพ เคนเฅ** เคเคฐ เคจเฅเคตเคพเค เคฎเฅเคเฅเคค เคจเคนเฅเค เคเคฟเคฏเคพ เคเคฏเคพ เคนเฅ เคเคธเคฒเคฟเค เคจเฅเคตเคพเค เคเคฐ เคเค เคตเคพเค **เคถเฅเคฐเฅเคท เคเคเค เคเฅ เคธเคพเคฅ เคตเคฟเคฒเคฏ เคจเคนเฅเค เคนเฅเคคเฅ**เฅค เคซเคฟเคฐ เคนเคฎ 0x110 เคเคพ เคเค เคฌเคกเคผเคพ เคเคเค เคเคตเคเคเคฟเคค เคเคฐเคคเฅ เคนเฅเค เคเฅ **เค
เคจเคธเฅเคฐเฅเคเฅเคก เคฌเคฟเคจ เคฎเฅเค เคเคเค เคเฅ เคเฅเคเฅ เคฌเคฟเคจ เคฎเฅเค เคฒเฅ เคเคพเคคเคพ เคนเฅ**เฅค
เคเคธเฅ เคธเคเคเคฒเคฟเคค เคเคฐเฅเค เคเคฐ `main` เคซเคผเคเคเฅเคถเคจ เคเฅ `ret` เคเคชเคเฅเคก เคฎเฅเค เคเค เคฌเฅเคฐเฅเคเคชเฅเคเคเค เคเฅ เคธเคพเคฅ เคกเคฟเคฌเค เคเคฐเฅเคเฅค เคซเคฟเคฐ `gef` เคเฅ เคธเคพเคฅ เคเคช เคฆเฅเค เคธเคเคคเฅ เคนเฅเค เคเคฟ tcache เคฌเคฟเคจ เคญเคฐเคพ เคนเฅเค เคนเฅ เคเคฐ เคเค เคเคเค เคเฅเคเฅ เคฌเคฟเคจ เคฎเฅเค เคนเฅ:
```bash
gefโค heap bins
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Tcachebins for thread 1 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Tcachebins[idx=15, size=0x110, count=7] โ Chunk(addr=0xaaaaaaac1d10, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac1c00, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac1af0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac19e0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac18d0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac17c0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ Chunk(addr=0xaaaaaaac12a0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Fastbins for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Fastbins[idx=0, size=0x20] 0x00
Fastbins[idx=1, size=0x30] 0x00
Fastbins[idx=2, size=0x40] 0x00
Fastbins[idx=3, size=0x50] 0x00
Fastbins[idx=4, size=0x60] 0x00
Fastbins[idx=5, size=0x70] 0x00
Fastbins[idx=6, size=0x80] 0x00
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Unsorted Bin for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
[+] Found 0 chunks in unsorted bin.
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Small Bins for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
[+] small_bins[16]: fw=0xaaaaaaac1e10, bk=0xaaaaaaac1e10
โ Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[+] Found 1 chunks in 1 small non-empty bins. Large bins
เคเฅเคเฅ เคฌเคฟเคจเฅเค เคเฅ เคตเคฟเคชเคฐเฅเคค, เคเฅ เคจเคฟเคถเฅเคเคฟเคค เคเคเคพเคฐ เคเฅ เคเฅเคเคกเคผเฅเค เคเคพ เคชเฅเคฐเคฌเคเคงเคจ เคเคฐเคคเฅ เคนเฅเค, เคชเฅเคฐเคคเฅเคฏเฅเค large bin เคเค เคถเฅเคฐเฅเคเคเคฒเคพ เคเฅ เคเฅเคเคกเคผเฅเค เคเฅ เคเคเคพเคฐ เคเฅ เคธเคเคญเคพเคฒเคคเคพ เคนเฅ เฅค เคฏเคน เค
เคงเคฟเค เคฒเคเฅเคฒเคพ เคนเฅ, เคเคฟเคธเคธเฅ เคธเคฟเคธเฅเคเคฎ เคเฅ เคตเคฟเคญเคฟเคจเฅเคจ เคเคเคพเคฐเฅเค เคเฅ เคธเคฎเคพเคฏเฅเคเคฟเคค เคเคฐเคจเฅ เคเฅ เค
เคจเฅเคฎเคคเคฟ เคฎเคฟเคฒเคคเฅ เคนเฅ เคฌเคฟเคจเคพ เคชเฅเคฐเคคเฅเคฏเฅเค เคเคเคพเคฐ เคเฅ เคฒเคฟเค เคเค เค
เคฒเค เคฌเคฟเคจ เคเฅ เคเคตเคถเฅเคฏเคเคคเคพ เคเฅเฅค
เคเค เคฎเฅเคฎเฅเคฐเฅ เคเคตเคเคเค เคฎเฅเค, เคฌเคกเคผเฅ เคฌเคฟเคจ เคเฅเคเฅ เคฌเคฟเคจเฅเค เคเฅ เคธเคฎเคพเคชเฅเคค เคนเฅเคจเฅ เคชเคฐ เคถเฅเคฐเฅ เคนเฅเคคเฅ เคนเฅเคเฅค เคฌเคกเคผเฅ เคฌเคฟเคจเฅเค เคเฅ เคฒเคฟเค เคฐเฅเคเค เคงเฅเคฐเฅ-เคงเฅเคฐเฅ เคฌเคขเคผเคคเฅ เคนเฅ, เคเคฟเคธเคเคพ เค
เคฐเฅเคฅ เคนเฅ เคเคฟ เคชเคนเคฒเคพ เคฌเคฟเคจ 512 เคธเฅ 576 เคฌเคพเคเคเฅเคธ เคคเค เคเฅ เคเฅเคเคกเคผเฅเค เคเฅ เคเคตเคฐ เคเคฐ เคธเคเคคเคพ เคนเฅ, เคเคฌเคเคฟ เค
เคเคฒเคพ 576 เคธเฅ 640 เคฌเคพเคเคเฅเคธ เคคเค เคเคตเคฐ เคเคฐเคคเคพ เคนเฅเฅค เคฏเคน เคชเฅเคเคฐเฅเคจ เคเคพเคฐเฅ เคฐเคนเคคเคพ เคนเฅ, เคธเคฌเคธเฅ เคฌเคกเคผเฅ เคฌเคฟเคจ เคฎเฅเค 1MB เคธเฅ เคเคชเคฐ เคเฅ เคธเคญเฅ เคเฅเคเคกเคผเฅ เคนเฅเคคเฅ เคนเฅเคเฅค
เคฌเคกเคผเฅ เคฌเคฟเคจ เคเฅเคเฅ เคฌเคฟเคจเฅเค เคเฅ เคคเฅเคฒเคจเคพ เคฎเฅเค เคธเคเคเคพเคฒเคจ เคฎเฅเค เคงเฅเคฎเฅ เคนเฅเคคเฅ เคนเฅเค เคเฅเคฏเฅเคเคเคฟ เคเคจเฅเคนเฅเค เคเคตเคเคเคจ เคเฅ เคฒเคฟเค เคธเคฐเฅเคตเคถเฅเคฐเฅเคทเฅเค เคซเคฟเค เคเฅเคเคจเฅ เคเฅ เคฒเคฟเค เคตเคฟเคญเคฟเคจเฅเคจ เคเฅเคเคกเคผเฅเค เคเฅ เคเคเคพเคฐ เคเฅ เคธเฅเคเฅ เคเฅ เคเฅเคฐเคฎเคฌเคฆเฅเคง เคเคฐ เคเฅเคเคจเฅ เคเฅ เคเคตเคถเฅเคฏเคเคคเคพ เคนเฅเคคเฅ เคนเฅเฅค เคเคฌ เคเค เคเฅเคเคกเคผเคพ เคฌเคกเคผเฅ เคฌเคฟเคจ เคฎเฅเค เคกเคพเคฒเคพ เคเคพเคคเคพ เคนเฅ, เคคเฅ เคเคธเฅ เคเฅเคฐเคฎเคฌเคฆเฅเคง เคเคฐเคจเคพ เคนเฅเคคเคพ เคนเฅ, เคเคฐ เคเคฌ เคฎเฅเคฎเฅเคฐเฅ เคเคตเคเคเคฟเคค เคเฅ เคเคพเคคเฅ เคนเฅ, เคคเฅ เคธเคฟเคธเฅเคเคฎ เคเฅ เคธเคนเฅ เคเฅเคเคกเคผเคพ เคเฅเคเคจเคพ เคนเฅเคคเคพ เคนเฅเฅค เคฏเคน เค
เคคเคฟเคฐเคฟเคเฅเคค เคเคพเคฐเฅเคฏ เคเคจเฅเคนเฅเค เคงเฅเคฎเคพ เคฌเคจเคพเคคเคพ เคนเฅ, เคฒเฅเคเคฟเคจ เคเฅเคเคเคฟ เคฌเคกเคผเฅ เคเคตเคเคเคจ เคเฅเคเฅ เคเคตเคเคเคจเฅเค เคเฅ เคคเฅเคฒเคจเคพ เคฎเฅเค เคเคฎ เคธเคพเคฎเคพเคจเฅเคฏ เคนเฅเคคเฅ เคนเฅเค, เคฏเคน เคเค เคธเฅเคตเฅเคเคพเคฐเฅเคฏ เคตเฅเคฏเคพเคชเคพเคฐ-เคฌเคเคฆ เคนเฅเฅค
เคฏเคนเคพเค เคนเฅเค:
32 เคฌเคฟเคจ 64B เคฐเฅเคเค เคเฅ (เคเฅเคเฅ เคฌเคฟเคจเฅเค เคเฅ เคธเคพเคฅ เคเคเคฐเคพเคคเฅ เคนเฅเค)
16 เคฌเคฟเคจ 512B เคฐเฅเคเค เคเฅ (เคเฅเคเฅ เคฌเคฟเคจเฅเค เคเฅ เคธเคพเคฅ เคเคเคฐเคพเคคเฅ เคนเฅเค)
8 เคฌเคฟเคจ 4096B เคฐเฅเคเค เคเฅ (เคเฅเค เคเฅเคเฅ เคฌเคฟเคจเฅเค เคเฅ เคธเคพเคฅ เคเคเคฐเคพเคคเฅ เคนเฅเค)
4 เคฌเคฟเคจ 32768B เคฐเฅเคเค เคเฅ
2 เคฌเคฟเคจ 262144B เคฐเฅเคเค เคเฅ
1 เคฌเคฟเคจ เคถเฅเคท เคเคเคพเคฐเฅเค เคเฅ เคฒเคฟเค
```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
#define largebin_index_32(sz)
(((((unsigned long) (sz)) >> 6) <= 38) ? 56 + (((unsigned long) (sz)) >> 6) :
((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :
((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :
((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :
((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :
126)
#define largebin_index_32_big(sz)
(((((unsigned long) (sz)) >> 6) <= 45) ? 49 + (((unsigned long) (sz)) >> 6) :
((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :
((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :
((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :
((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :
126)
// XXX It remains to be seen whether it is good to keep the widths of // XXX the buckets the same or whether it should be scaled by a factor // XXX of two as well. #define largebin_index_64(sz)
(((((unsigned long) (sz)) >> 6) <= 48) ? 48 + (((unsigned long) (sz)) >> 6) :
((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :
((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :
((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :
((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :
126)
#define largebin_index(sz)
(SIZE_SZ == 8 ? largebin_index_64 (sz)
: MALLOC_ALIGNMENT == 16 ? largebin_index_32_big (sz)
: largebin_index_32 (sz))
Copy </details>
<details>
<summary>เคเค เคฌเคกเคผเคพ เคเฅเคเคกเคผเคพ เคเคฆเคพเคนเคฐเคฃ เคเฅเคกเคผเฅเค</summary>
```c
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *chunks[2];
chunks[0] = malloc(0x1500);
chunks[1] = malloc(0x1500);
free(chunks[0]);
chunks[0] = malloc(0x2000);
return 0;
} 2 เคฌเคกเคผเฅ เคเคตเคเคเคจ เคเคฟเค เคเคพเคคเฅ เคนเฅเค, เคซเคฟเคฐ เคเค เคเฅ เคฎเฅเคเฅเคค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ (เคเคธเฅ เค
เคธเคเคฐเคเคฟเคค เคฌเคฟเคจ เคฎเฅเค เคกเคพเคฒเคคเฅ เคนเฅเค) เคเคฐ เคเค เคฌเคกเคผเคพ เคเคตเคเคเคจ เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ (เคฎเฅเคเฅเคค เคเค เคเฅ เค
เคธเคเคฐเคเคฟเคค เคฌเคฟเคจ เคธเฅ เคฌเคกเคผเฅ เคฌเคฟเคจ เคฎเฅเค เคฒเฅ เคเคพเคคเฅ เคนเฅเค)เฅค
เคเคธเฅ เคธเคเคเคฒเคฟเคค เคเคฐเฅเค เคเคฐ main เคซเคผเคเคเฅเคถเคจ เคธเฅ ret เคเคชเคเฅเคก เคฎเฅเค เคเค เคฌเฅเคฐเฅเคเคชเฅเคเคเค เคเฅ เคธเคพเคฅ เคกเคฟเคฌเค เคเคฐเฅเคเฅค เคซเคฟเคฐ gef เคเฅ เคธเคพเคฅ เคเคช เคฆเฅเค เคธเคเคคเฅ เคนเฅเค เคเคฟ tcache เคฌเคฟเคจ เคญเคฐเคพ เคนเฅเค เคนเฅ เคเคฐ เคเค เคเฅเคเคกเคผเคพ เคฌเคกเคผเฅ เคฌเคฟเคจ เคฎเฅเค เคนเฅ:
Copy gefโค heap bin
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Tcachebins for thread 1 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
All tcachebins are empty
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Fastbins for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Fastbins[idx =0, size=0x20] 0x00
Fastbins[idx =1, size=0x30] 0x00
Fastbins[idx =2, size=0x40] 0x00
Fastbins[idx =3, size=0x50] 0x00
Fastbins[idx =4, size=0x60] 0x00
Fastbins[idx =5, size=0x70] 0x00
Fastbins[idx =6, size=0x80] 0x00
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Unsorted Bin for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
[+] Found 0 chunks in unsorted bin.
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Small Bins for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
[+] Found 0 chunks in 0 small non-empty bins.
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ Large Bins for arena at 0xfffff7f90b00 โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
[+] large_bins[100]: fw = 0xaaaaaaac1290, bk = 0xaaaaaaac1290
โ Chunk (addr = 0xaaaaaaac12a0, size = 0x1510, flags = PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA )
[+] Found 1 chunks in 1 large non-empty bins. เคถเฅเคฐเฅเคท เคญเคพเค
Copy // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
/*
Top
The top-most available chunk (i.e., the one bordering the end of
available memory) is treated specially. It is never included in
any bin, is used only if no other chunk is available, and is
released back to the system if it is very large (see
M_TRIM_THRESHOLD). Because top initially
points to its own bin with initial zero size, thus forcing
extension on the first malloc request, we avoid having any special
code in malloc to check whether it even exists yet. But we still
need to do so when getting memory from system, so we make
initial_top treat the bin as a legal but unusable chunk during the
interval between initialization and the first call to
sysmalloc. (This is somewhat delicate, since it relies on
the 2 preceding words to be zero during this interval as well.)
*/
/* Conveniently, the unsorted bin can be used as dummy top on first call */
#define initial_top (M) ( unsorted_chunks (M)) เคฌเฅเคจเคฟเคฏเคพเคฆเฅ เคฐเฅเคช เคธเฅ, เคฏเคน เคเค เคเฅเคเคกเคผเคพ เคนเฅ เคเคฟเคธเคฎเฅเค เคธเคญเฅ เคตเคฐเฅเคคเคฎเคพเคจ เคฎเฅเค เคเคชเคฒเคฌเฅเคง เคนเฅเคช เคถเคพเคฎเคฟเคฒ เคนเฅเคเฅค เคเคฌ malloc เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ, เคฏเคฆเคฟ เคเคชเคฏเฅเค เคเคฐเคจเฅ เคเฅ เคฒเคฟเค เคเฅเค เคเคชเคฒเคฌเฅเคง เคฎเฅเคเฅเคค เคเฅเคเคกเคผเคพ เคจเคนเฅเค เคนเฅ, เคคเฅ เคฏเคน เคถเฅเคฐเฅเคท เคเฅเคเคกเคผเคพ เค
เคชเคจเคพ เคเคเคพเคฐ เคเคเคพ เคฆเฅเคเคพ เคเคตเคถเฅเคฏเค เคธเฅเคฅเคพเคจ เคฆเฅเคจเฅ เคเฅ เคฒเคฟเคเฅค
Top Chunk เคเคพ เคชเฅเคเคเคเคฐ malloc_state เคธเคเคฐเคเคจเคพ เคฎเฅเค เคธเคเคเฅเคฐเคนเฅเคค เคนเฅเคคเคพ เคนเฅเฅค
เคเคธเคเฅ เค
เคฒเคพเคตเคพ, เคถเฅเคฐเฅเคเคค เคฎเฅเค, เค
เคจเคธเฅเคฐเฅเคเฅเคก เคเฅเคเคกเคผเฅ เคเคพ เคเคชเคฏเฅเค เคถเฅเคฐเฅเคท เคเฅเคเคกเคผเฅ เคเฅ เคฐเฅเคช เคฎเฅเค เคเคฟเคฏเคพ เคเคพ เคธเคเคคเคพ เคนเฅเฅค
```c #include #include
int main(void) { char *chunk; chunk = malloc(24); printf("Address of the chunk: %p\n", (void *)chunk); gets(chunk); return 0; }
Copy `main` เคเฅ `ret` เคเคชเคเฅเคก เคฎเฅเค เคฌเฅเคฐเฅเค เคชเฅเคเคเค เคเฅ เคธเคพเคฅ เคเคธเฅ เคธเคเคเคฒเคฟเคค เคเคฐ เคกเคฟเคฌเค เคเคฐเคจเฅ เคเฅ เคฌเคพเคฆ เคฎเฅเคเคจเฅ เคฆเฅเคเคพ เคเคฟ malloc เคจเฅ เคชเคคเคพ `0xaaaaaaac12a0` เคฒเฅเคเคพเคฏเคพ เคเคฐ เคฏเฅ เคเคเคเฅเคธ เคนเฅเค:
```bash
gefโค heap chunks
Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[0x0000aaaaaaac1010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................]
Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[0x0000aaaaaaac12a0 41 41 41 41 41 41 41 00 00 00 00 00 00 00 00 00 AAAAAAA.........]
Chunk(addr=0xaaaaaaac12c0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[0x0000aaaaaaac12c0 41 64 64 72 65 73 73 20 6f 66 20 74 68 65 20 63 Address of the c]
Chunk(addr=0xaaaaaaac16d0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[0x0000aaaaaaac16d0 41 41 41 41 41 41 41 0a 00 00 00 00 00 00 00 00 AAAAAAA.........]
Chunk(addr=0xaaaaaaac1ae0, size=0x20530, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) โ top chunk เคเคนเคพเค เคฏเคน เคฆเฅเคเคพ เคเคพ เคธเคเคคเคพ เคนเฅ เคเคฟ เคถเฅเคฐเฅเคท เคเฅเคเคกเคผเคพ เคชเคคเฅ 0xaaaaaaac1ae0 เคชเคฐ เคนเฅเฅค เคฏเคน เคเฅเค เคเคถเฅเคเคฐเฅเคฏ เคเฅ เคฌเคพเคค เคจเคนเฅเค เคนเฅ เคเฅเคฏเฅเคเคเคฟ เค
เคเคคเคฟเคฎ เคเคตเคเคเคฟเคค เคเฅเคเคกเคผเคพ 0xaaaaaaac12a0 เคชเคฐ เคฅเคพ เคเคฟเคธเคเคพ เคเคเคพเคฐ 0x410 เคฅเคพ เคเคฐ 0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0เฅค
เคฏเคน เคญเฅ เคธเคเคญเคต เคนเฅ เคเคฟ เคถเฅเคฐเฅเคท เคเฅเคเคกเคผเฅ เคเฅ เคฒเคเคฌเคพเค เคเคธเคเฅ เคเฅเคเคกเคผเฅ เคเฅ เคนเฅเคกเคฐ เคชเคฐ เคฆเฅเคเฅ เคเคพ เคธเคเฅ:
Copy gefโค x/8wx 0xaaaaaaac1ae0 - 16
0xaaaaaaac1ad0: 0x00000000 0x00000000 0x00020531 0x00000000
0xaaaaaaac1ae0: 0x00000000 0x00000000 0x00000000 0x00000000 เค
เคเคคเคฟเคฎ เคถเฅเคท
เคเคฌ malloc เคเคพ เคเคชเคฏเฅเค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ เคเคฐ เคเค เคเฅเคเคกเคผเคพ เคตเคฟเคญเคพเคเคฟเคค เคเคฟเคฏเคพ เคเคพเคคเคพ เคนเฅ (เคเคฆเคพเคนเคฐเคฃ เคเฅ เคฒเคฟเค, เค
เคธเคเคฐเคเคฟเคค เคฌเคฟเคจ เคธเฅ เคฏเคพ เคถเฅเคฐเฅเคท เคเฅเคเคกเคผเฅ เคธเฅ), เคคเฅ เคตเคฟเคญเคพเคเคฟเคค เคเฅเคเคกเคผเฅ เคเฅ เคถเฅเคท เคธเฅ เคฌเคจเคพเค เคเค เคเฅเคเคกเคผเฅ เคเฅ เค
เคเคคเคฟเคฎ เคถเฅเคท เคเคนเคพ เคเคพเคคเคพ เคนเฅ เคเคฐ เคเคธเคเคพ เคชเฅเคเคเคเคฐ malloc_state เคธเคเคฐเคเคจเคพ เคฎเฅเค เคธเคเคเฅเคฐเคนเฅเคค เคนเฅเคคเคพ เคนเฅเฅค
เคเคตเคเคเคจ เคชเฅเคฐเคตเคพเคน
เคเฅเค เคเคฐเฅเค:
เคฎเฅเคเฅเคค เคชเฅเคฐเคตเคพเคน
เคเฅเค เคเคฐเฅเค:
เคนเฅเคช เคซเคผเคเคเฅเคถเคเคธ เคธเฅเคฐเคเฅเคทเคพ เคเคพเคเค
เคนเฅเคช เคฎเฅเค เคญเคพเคฐเฅ เคเคชเคฏเฅเค เคเคฟเค เคเคพเคจเฅ เคตเคพเคฒเฅ เคซเคผเคเคเฅเคถเคเคธ เคฆเฅเคตเคพเคฐเคพ เคเคฟเค เคเค เคธเฅเคฐเคเฅเคทเคพ เคเคพเคเคเฅเค เคเฅ เคเคพเคเค เคเคฐเฅเค:
เคธเคเคฆเคฐเฅเคญ
เคนเฅเคเคฟเคเค เคเฅเคฐเคฟเคเฅเคธ เคธเคพเคเคพ เคเคฐเฅเค เคเคฐ HackTricks HackTricks Cloud
HackTricks Training AWS Red Team Expert (ARTE)
HackTricks Training GCP Red Team Expert (GRTE)