Large Bin Attack

{% hint style="success" %} Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE)

Support HackTricks

Confira os planos de assinatura!
Junte-se ao 💬 grupo do Discord ou ao grupo do telegram ou siga-nos no Twitter 🐦 @hacktricks_live.
Compartilhe truques de hacking enviando PRs para o HackTricks e HackTricks Cloud repositórios do github.

{% endhint %}

Basic Information

Para mais informações sobre o que é um large bin, confira esta página:

{% content-ref url="bins-and-memory-allocations.md" %} bins-and-memory-allocations.md {% endcontent-ref %}

É possível encontrar um ótimo exemplo em how2heap - large bin attack.

Basicamente, aqui você pode ver como, na versão "atual" mais recente do glibc (2.35), não é verificado: P->bk_nextsize permitindo modificar um endereço arbitrário com o valor de um chunk de large bin se certas condições forem atendidas.

Nesse exemplo, você pode encontrar as seguintes condições:

Um chunk grande é alocado
Um chunk grande menor que o primeiro, mas no mesmo índice, é alocado
Deve ser menor, então no bin deve ir primeiro
(Um chunk para evitar a fusão com o chunk superior é criado)
Então, o primeiro chunk grande é liberado e um novo chunk maior que ele é alocado -> Chunk1 vai para o large bin
Então, o segundo chunk grande é liberado
Agora, a vulnerabilidade: O atacante pode modificar chunk1->bk_nextsize para [target-0x20]
Então, um chunk maior que o chunk 2 é alocado, assim o chunk2 é inserido no large bin sobrescrevendo o endereço chunk1->bk_nextsize->fd_nextsize com o endereço do chunk2

{% hint style="success" %} Existem outros cenários potenciais, a questão é adicionar ao large bin um chunk que seja menor que um chunk X atual no bin, então ele precisa ser inserido logo antes dele no bin, e precisamos ser capazes de modificar o bk_nextsize de X, pois é lá que o endereço do chunk menor será escrito. {% endhint %}

Este é o código relevante do malloc. Comentários foram adicionados para entender melhor como o endereço foi sobrescrito:

{% code overflow="wrap" %}

/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
{
fwd = bck; // fwd = p1
bck = bck->bk; // bck = p1->bk

victim->fd_nextsize = fwd->fd; // p2->fd_nextsize = p1->fd (Note that p1->fd is p1 as it's the only chunk)
victim->bk_nextsize = fwd->fd->bk_nextsize; // p2->bk_nextsize = p1->fd->bk_nextsize
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // p1->fd->bk_nextsize->fd_nextsize = p2
}

{% endcode %}

Isso pode ser usado para sobrescrever a variável global global_max_fast da libc para então explorar um ataque de fast bin com chunks maiores.

Você pode encontrar outra ótima explicação desse ataque em guyinatuxedo.

Outros exemplos

La casa de papel. HackOn CTF 2024
Ataque de large bin na mesma situação em que aparece em how2heap.
A primitiva de escrita é mais complexa, porque global_max_fast é inútil aqui.
FSOP é necessário para finalizar a exploração.