House of Orange

{% 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 %}

Informações Básicas

Código

Encontre um exemplo em https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_orange.c
A técnica de exploração foi corrigida neste patch então isso não está mais funcionando (funcionando em versões anteriores a 2.26)
Mesmo exemplo com mais comentários em https://guyinatuxedo.github.io/43-house_of_orange/house_orange_exp/index.html

Objetivo

Abusar da função malloc_printerr

Requisitos

Sobrescrever o tamanho do top chunk
Vazamentos de libc e heap

Contexto

Algumas informações de fundo necessárias dos comentários de este exemplo:

A questão é que, em versões mais antigas da libc, quando a função malloc_printerr era chamada, ela iterava através de uma lista de structs _IO_FILE armazenadas em _IO_list_all, e na verdade executava um ponteiro de instrução naquela struct.
Este ataque irá forjar uma struct _IO_FILE falsa que escreveremos em _IO_list_all, e fará com que malloc_printerr seja executado.
Então, ele irá executar qualquer endereço que tenhamos armazenado na tabela de saltos das structs _IO_FILE, e obteremos execução de código.

Ataque

O ataque começa conseguindo obter o top chunk dentro do unsorted bin. Isso é alcançado chamando malloc com um tamanho maior que o tamanho atual do top chunk, mas menor que mmp_.mmap_threshold (o padrão é 128K), que de outra forma acionaria a alocação mmap. Sempre que o tamanho do top chunk é modificado, é importante garantir que o top chunk + seu tamanho esteja alinhado à página e que o bit prev_inuse do top chunk esteja sempre definido.

Para obter o top chunk dentro do unsorted bin, aloque um chunk para criar o top chunk, mude o tamanho do top chunk (com um overflow no chunk alocado) para que top chunk + tamanho esteja alinhado à página com o bit prev_inuse definido. Em seguida, aloque um chunk maior que o novo tamanho do top chunk. Note que free nunca é chamado para colocar o top chunk no unsorted bin.

O antigo top chunk agora está no unsorted bin. Supondo que possamos ler dados dentro dele (possivelmente devido a uma vulnerabilidade que também causou o overflow), é possível vazar endereços da libc a partir dele e obter o endereço de _IO_list_all.

Um ataque de unsorted bin é realizado abusando do overflow para escrever topChunk->bk->fwd = _IO_list_all - 0x10. Quando um novo chunk é alocado, o antigo top chunk será dividido, e um ponteiro para o unsorted bin será escrito em _IO_list_all.

O próximo passo envolve reduzir o tamanho do antigo top chunk para caber em um small bin, especificamente definindo seu tamanho para 0x61. Isso serve a dois propósitos:

Inserção no Small Bin 4: Quando malloc escaneia o unsorted bin e vê este chunk, ele tentará inseri-lo no small bin 4 devido ao seu pequeno tamanho. Isso faz com que o chunk termine na cabeça da lista do small bin 4, que é a localização do ponteiro FD do chunk de _IO_list_all já que escrevemos um endereço próximo em _IO_list_all via ataque de unsorted bin.
Acionando uma Verificação de Malloc: Essa manipulação do tamanho do chunk fará com que malloc execute verificações internas. Quando ele verifica o tamanho do chunk falso de avanço, que será zero, isso aciona um erro e chama malloc_printerr.

A manipulação do small bin permitirá que você controle o ponteiro de avanço do chunk. A sobreposição com _IO_list_all é usada para forjar uma estrutura _IO_FILE falsa. A estrutura é cuidadosamente elaborada para incluir campos-chave como _IO_write_base e _IO_write_ptr definidos para valores que passam nas verificações internas da libc. Além disso, uma tabela de saltos é criada dentro da estrutura falsa, onde um ponteiro de instrução é definido para o endereço onde código arbitrário (por exemplo, a função system) pode ser executado.

Para resumir a parte restante da técnica:

Reduzir o Antigo Top Chunk: Ajustar o tamanho do antigo top chunk para 0x61 para caber em um small bin.
Configurar a Estrutura Falsa _IO_FILE: Sobrepor o antigo top chunk com a estrutura falsa _IO_FILE e definir os campos adequadamente para sequestrar o fluxo de execução.

O próximo passo envolve forjar uma estrutura falsa _IO_FILE que se sobrepõe ao antigo top chunk atualmente no unsorted bin. Os primeiros bytes desta estrutura são elaborados cuidadosamente para incluir um ponteiro para um comando (por exemplo, "/bin/sh") que será executado.

Campos-chave na estrutura falsa _IO_FILE, como _IO_write_base e _IO_write_ptr, são definidos para valores que passam nas verificações internas da libc. Além disso, uma tabela de saltos é criada dentro da estrutura falsa, onde um ponteiro de instrução é definido para o endereço onde código arbitrário pode ser executado. Normalmente, este seria o endereço da função system ou outra função que pode executar comandos de shell.

O ataque culmina quando uma chamada para malloc aciona a execução do código através da estrutura manipulada _IO_FILE. Isso efetivamente permite a execução de código arbitrário, resultando tipicamente em um shell sendo gerado ou outro payload malicioso sendo executado.

Resumo do Ataque:

Configurar o top chunk: Alocar um chunk e modificar o tamanho do top chunk.
Forçar o top chunk para o unsorted bin: Alocar um chunk maior.
Vazar endereços da libc: Usar a vulnerabilidade para ler do unsorted bin.
Realizar o ataque de unsorted bin: Escrever em _IO_list_all usando um overflow.
Reduzir o antigo top chunk: Ajustar seu tamanho para caber em um small bin.
Configurar uma estrutura falsa _IO_FILE: Forjar uma estrutura de arquivo falsa para sequestrar o fluxo de controle.
Acionar a execução de código: Alocar um chunk para executar o ataque e rodar código arbitrário.

Essa abordagem explora mecanismos de gerenciamento de heap, vazamentos de informações da libc e overflows de heap para alcançar a execução de código sem chamar diretamente free. Ao elaborar cuidadosamente a estrutura falsa _IO_FILE e colocá-la na localização correta, o ataque pode sequestrar o fluxo de controle durante operações padrão de alocação de memória. Isso permite a execução de código arbitrário, resultando potencialmente em um shell ou outras atividades maliciosas.

Referências