Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-18 17:16:10 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/libc-heap/large-bin-attack.md

5.4 KiB
Raw Blame History

Ataque ao Large Bin

Aprenda hacking na AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks:

Informação Básica

Para mais informações sobre o que é um large bin, consulte 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 última versão "atual" do glibc (2.35), não é verificado: P->bk_nextsize permitindo modificar um endereço arbitrário com o valor de um pedaço de large bin se certas condições forem atendidas.

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

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

{% hint style="success" %} Existem outros cenários potenciais, a ideia é adicionar ao large bin um pedaço que seja menor do que um pedaço X atual no bin, então ele precisa ser inserido logo antes dele no bin, e precisamos ser capazes de modificar o bk_nextsize do X, pois é onde o endereço do pedaço 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 poderia 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 conforme aparece em how2heap.
  • A primitiva de escrita é mais complexa, porque global_max_fast é inútil aqui.
  • FSOP é necessário para concluir o exploit.
Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks: