mirror of https://github.com/carlospolop/hacktricks synced 2024-11-26 14:40:37 +00:00

Translator 8bf08c51a7 Translated ['README.md', 'backdoors/salseo.md', 'binary-exploitation/arb

2024-07-18 17:35:13 +00:00

14 KiB

Raw Blame History

free

{% hint style="success" %} Impara e pratica l'hacking su AWS: HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks

Controlla i piani di abbonamento!
Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
Condividi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud github repos.

{% endhint %}

Riepilogo Ordine Gratuito

(Nessun controllo è spiegato in questo riepilogo e alcuni casi sono stati omessi per brevità)

Se l'indirizzo è nullo, non fare nulla
Se il chunk è stato mappato, smapparlo e terminare
Chiama _int_free:
Se possibile, aggiungi il chunk al tcache
Se possibile, aggiungi il chunk al fast bin
Chiama _int_free_merge_chunk per consolidare il chunk se necessario e aggiungerlo alla lista non ordinata

__libc_free

Free chiama __libc_free.

Se l'indirizzo passato è Null (0) non fare nulla.
Controlla il tag del puntatore
Se il chunk è mappato, smappalo e basta
Se no, aggiungi il colore e chiama _int_free su di esso

Codice __lib_free

```c void __libc_free (void *mem) { mstate ar_ptr; mchunkptr p; /* chunk corresponding to mem */

if (mem == 0) /* free(0) has no effect */ return;

/* Quickly check that the freed pointer matches the tag for the memory. This gives a useful double-free detection. */ if (__glibc_unlikely (mtag_enabled)) *(volatile char *)mem;

int err = errno;

p = mem2chunk (mem);

if (chunk_is_mmapped (p)) /* release mmapped memory. / { / See if the dynamic brk/mmap threshold needs adjusting. Dumped fake mmapped chunks do not affect the threshold. */ if (!mp_.no_dyn_threshold && chunksize_nomask (p) > mp_.mmap_threshold && chunksize_nomask (p) <= DEFAULT_MMAP_THRESHOLD_MAX) { mp_.mmap_threshold = chunksize (p); mp_.trim_threshold = 2 * mp_.mmap_threshold; LIBC_PROBE (memory_mallopt_free_dyn_thresholds, 2, mp_.mmap_threshold, mp_.trim_threshold); } munmap_chunk (p); } else { MAYBE_INIT_TCACHE ();

/* Mark the chunk as belonging to the library again. */ (void)tag_region (chunk2mem (p), memsize (p));

ar_ptr = arena_for_chunk (p); _int_free (ar_ptr, p, 0); }

__set_errno (err); } libc_hidden_def (__libc_free)

</details>

## \_int\_free <a href="#int_free" id="int_free"></a>

### Inizio di \_int\_free <a href="#int_free" id="int_free"></a>

Inizia con alcuni controlli per assicurarsi che:

* il **puntatore** sia **allineato**, altrimenti genera l'errore `free(): invalid pointer`
* la **dimensione** non sia inferiore al minimo e che la **dimensione** sia anche **allineata**, altrimenti genera l'errore: `free(): invalid size`

<details>

<summary>Inizio di \_int\_free</summary>
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4493C1-L4513C28

#define aligned_OK(m) (((unsigned long) (m) &MALLOC_ALIGN_MASK) == 0)

static void
_int_free (mstate av, mchunkptr p, int have_lock)
{
INTERNAL_SIZE_T size;        /* its size */
mfastbinptr *fb;             /* associated fastbin */

size = chunksize (p);

/* Little security check which won't hurt performance: the
allocator never wraps around at the end of the address space.
Therefore we can exclude some size values which might appear
here by accident or by "design" from some intruder.  */
if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
|| __builtin_expect (misaligned_chunk (p), 0))
malloc_printerr ("free(): invalid pointer");
/* We know that each chunk is at least MINSIZE bytes in size or a
multiple of MALLOC_ALIGNMENT.  */
if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
malloc_printerr ("free(): invalid size");

check_inuse_chunk(av, p);

_int_free tcache

Inizialmente cercherà di allocare questo chunk nel tcache correlato. Tuttavia, vengono eseguiti alcuni controlli in precedenza. Scorrerà tutti i chunk del tcache nello stesso indice del chunk liberato e:

Se ci sono più voci rispetto a mp_.tcache_count: free(): troppi chunk rilevati nel tcache
Se l'entry non è allineata: free(): chunk non allineato rilevato nel tcache 2
se il chunk liberato era già stato liberato e è presente come chunk nel tcache: free(): doppia liberazione rilevata nel tcache 2

Se tutto va bene, il chunk viene aggiunto al tcache e la funzione ritorna.

// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4515C1-L4554C7
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size);
if (tcache != NULL && tc_idx < mp_.tcache_bins)
{
/* Check to see if it's already in the tcache.  */
tcache_entry *e = (tcache_entry *) chunk2mem (p);

/* This test succeeds on double free.  However, we don't 100%
trust it (it also matches random payload data at a 1 in
2^<size_t> chance), so verify it's not an unlikely
coincidence before aborting.  */
if (__glibc_unlikely (e->key == tcache_key))
{
tcache_entry *tmp;
size_t cnt = 0;
LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
for (tmp = tcache->entries[tc_idx];
tmp;
tmp = REVEAL_PTR (tmp->next), ++cnt)
{
if (cnt >= mp_.tcache_count)
malloc_printerr ("free(): too many chunks detected in tcache");
if (__glibc_unlikely (!aligned_OK (tmp)))
malloc_printerr ("free(): unaligned chunk detected in tcache 2");
if (tmp == e)
malloc_printerr ("free(): double free detected in tcache 2");
/* If we get here, it was a coincidence.  We've wasted a
few cycles, but don't abort.  */
}
}

if (tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (p, tc_idx);
return;
}
}
}
#endif

_int_free fast bin

Inizia controllando che la dimensione sia adatta per il fast bin e verifica se è possibile impostarla vicino al top chunk.

Successivamente, aggiungi il chunk liberato in cima al fast bin mentre esegui alcuni controlli:

Se la dimensione del chunk non è valida (troppo grande o piccola) scatena: free(): invalid next size (fast)
Se il chunk aggiunto era già in cima al fast bin: double free or corruption (fasttop)
Se la dimensione del chunk in cima ha una dimensione diversa dal chunk che stiamo aggiungendo: invalid fastbin entry (free)

_int_free Fast Bin

```c // From f942a732d3/malloc/malloc.c (L4556C2-L4631C4)

/* If eligible, place chunk on a fastbin so it can be found and used quickly in malloc. */

if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())

#if TRIM_FASTBINS /* If TRIM_FASTBINS set, don't place chunks bordering top into fastbins */ && (chunk_at_offset(p, size) != av->top) #endif ) {

if (__builtin_expect (chunksize_nomask (chunk_at_offset (p, size)) <= CHUNK_HDR_SZ, 0) || __builtin_expect (chunksize (chunk_at_offset (p, size))

= av->system_mem, 0)) { bool fail = true; /* We might not have a lock at this point and concurrent modifications of system_mem might result in a false positive. Redo the test after getting the lock. */ if (!have_lock) { __libc_lock_lock (av->mutex); fail = (chunksize_nomask (chunk_at_offset (p, size)) <= CHUNK_HDR_SZ || chunksize (chunk_at_offset (p, size)) >= av->system_mem); __libc_lock_unlock (av->mutex); }

if (fail) malloc_printerr ("free(): invalid next size (fast)"); }

free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ);

atomic_store_relaxed (&av->have_fastchunks, true); unsigned int idx = fastbin_index(size); fb = &fastbin (av, idx);

/* Atomically link P to its fastbin: P->FD = *FB; *FB = P; */ mchunkptr old = *fb, old2;

if (SINGLE_THREAD_P) { /* Check that the top of the bin is not the record we are going to add (i.e., double free). */ if (__builtin_expect (old == p, 0)) malloc_printerr ("double free or corruption (fasttop)"); p->fd = PROTECT_PTR (&p->fd, old); fb = p; } else do { / Check that the top of the bin is not the record we are going to add (i.e., double free). */ if (__builtin_expect (old == p, 0)) malloc_printerr ("double free or corruption (fasttop)"); old2 = old; p->fd = PROTECT_PTR (&p->fd, old); } while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2)) != old2);

/* Check that size of fastbin chunk at the top is the same as size of the chunk that we are adding. We can dereference OLD only if we have the lock, otherwise it might have already been allocated again. */ if (have_lock && old != NULL && __builtin_expect (fastbin_index (chunksize (old)) != idx, 0)) malloc_printerr ("invalid fastbin entry (free)"); }

### _int_free finale <a href="#int_free" id="int_free"></a>

Se il chunk non era ancora allocato su nessun bin, chiama `_int_free_merge_chunk`

<details>

<summary>_int_free finale</summary>
```c
/*
Consolidate other non-mmapped chunks as they arrive.
*/

else if (!chunk_is_mmapped(p)) {

/* If we're single-threaded, don't lock the arena.  */
if (SINGLE_THREAD_P)
have_lock = true;

if (!have_lock)
__libc_lock_lock (av->mutex);

_int_free_merge_chunk (av, p, size);

if (!have_lock)
__libc_lock_unlock (av->mutex);
}
/*
If the chunk was allocated via mmap, release via munmap().
*/

else {
munmap_chunk (p);
}
}

_int_free_merge_chunk

Questa funzione cercherà di unire il chunk P di DIMENSIONE byte con i suoi vicini. Mettere il chunk risultante nell'elenco dei bin non ordinati.

Alcuni controlli vengono eseguiti:

Se il chunk è il chunk superiore: double free or corruption (top)
Se il chunk successivo è al di fuori dei limiti dell'arena: double free or corruption (out)
Se il chunk non è contrassegnato come usato (nel prev_inuse del chunk successivo): double free or corruption (!prev)
Se il chunk successivo ha una dimensione troppo piccola o troppo grande: free(): invalid next size (normal)
se il chunk precedente non è in uso, cercherà di consolidare. Ma, se il prev_size differisce dalla dimensione indicata nel chunk precedente: corrupted size vs. prev_size while consolidating

Codice \_int\_free\_merge\_chunk

```c // From f942a732d3/malloc/malloc.c (L4660C1-L4702C2)

/* Try to merge chunk P of SIZE bytes with its neighbors. Put the resulting chunk on the appropriate bin list. P must not be on a bin list yet, and it can be in use. */ static void _int_free_merge_chunk (mstate av, mchunkptr p, INTERNAL_SIZE_T size) { mchunkptr nextchunk = chunk_at_offset(p, size);

/* Lightweight tests: check whether the block is already the top block. / if (__glibc_unlikely (p == av->top)) malloc_printerr ("double free or corruption (top)"); / Or whether the next chunk is beyond the boundaries of the arena. */ if (__builtin_expect (contiguous (av) && (char *) nextchunk

= ((char ) av->top + chunksize(av->top)), 0)) malloc_printerr ("double free or corruption (out)"); / Or whether the block is actually not marked used. */ if (__glibc_unlikely (!prev_inuse(nextchunk))) malloc_printerr ("double free or corruption (!prev)");

INTERNAL_SIZE_T nextsize = chunksize(nextchunk); if (__builtin_expect (chunksize_nomask (nextchunk) <= CHUNK_HDR_SZ, 0) || __builtin_expect (nextsize >= av->system_mem, 0)) malloc_printerr ("free(): invalid next size (normal)");