Exploração Educacional de Heap

Este repositório serve para aprender várias técnicas de exploração de heap. Usamos as versões do Libc do Ubuntu como padrão-ouro. Cada técnica é verificada para funcionar nas versões correspondentes do Ubuntu. Você pode executar apt source libc6 para baixar o código-fonte do Libc que está usando em um sistema operacional baseado em Debian. Você também pode clicar em ▶️ para depurar a técnica no seu navegador usando gdb.

Tivemos a ideia durante uma reunião de hackers e implementamos as seguintes técnicas:

Arquivo	▶️	Técnica	Glibc-Version	Patch	Desafios de CTF Aplicáveis
first_fit.c		Demonstrando o comportamento first-fit do malloc do glibc.
calc_tcache_idx.c		Demonstrando o cálculo do índice tcache do glibc.
fastbin_dup.c	▶️	Enganando o malloc para retornar um ponteiro de heap já alocado, abusando da freelist fastbin.	< 2.43	patch
fastbin_dup_into_stack.c	▶️	Enganando o malloc para retornar um ponteiro quase arbitrário, abusando da freelist fastbin.	< 2.43	patch	9447-search-engine, 0ctf 2017-babyheap
fastbin_dup_consolidate.c	▶️	Enganando o malloc para retornar um ponteiro de heap já alocado ao colocar um ponteiro tanto na freelist fastbin quanto no top chunk.	< 2.43

O GnuLibc está em constante desenvolvimento e várias das técnicas acima levaram a verificações de consistência introduzidas na lógica do malloc/free. Consequentemente, essas verificações quebram regularmente algumas das técnicas e exigem ajustes para contorná-las (se possível). Abordamos esse problema mantendo várias versões da mesma técnica para cada versão do Glibc que exigiu um ajuste. A estrutura é glibc_<version>/technique.c.

Tem um bom exemplo? Adicione aqui! Tente colocar toda a técnica em um único .c -- é muito mais fácil aprender assim.

Começando

Configuração Rápida

certifique-se de ter os seguintes pacotes/ferramentas instalados: patchelf zstd wget (claro, também build-essential ou similar para compiladores, make, ...)
além disso, /usr/bin/python deve ser/apontar para o seu binário python (ex.: /usr/bin/python3)```shell git clone https://github.com/shellphish/how2heap cd how2heap make clean base ./malloc_playground

Observe que isso vinculará os binários com a libc do seu sistema. Se você quiser experimentar outras versões da libc, consulte `Complete Setup`.

## Configuração Completa

Você encontrará problemas de versionamento de símbolos (veja [isto](https://github.com/shellphish/how2heap/issues/169)) se tentar usar `LD_PRELOAD` em libcs para um binário compilado na sua máquina host.
Temos duas maneiras de contornar isso.

### Método 1: vincular com uma libc mais antiga
Este método diz ao linker para vincular o binário alvo com a libc alvo.```shell
git clone https://github.com/shellphish/how2heap
cd how2heap
H2H_USE_SYSTEM_LIBC=N make v2.23

Isso vinculará todos os binários às libcs correspondentes. O melhor é que ele vem com símbolos de depuração. Agora você pode brincar com qualquer versão de libc na sua máquina host. Neste exemplo, ele compilará todos os binários glibc-2.23 e os vinculará à libc-2.23. Você pode alterar o número para brincar com outras versões de libc.

Método 2: usar docker

Esta abordagem usa Docker para compilar binários dentro de um contêiner ubuntu antigo, de modo que seja executável com a versão de libc alvo.```shell git clone https://github.com/shellphish/how2heap cd how2heap

the next command will prepare the target binary so it runs with

the expected libc version

make base ./glibc_run.sh 2.30 ./malloc_playground -d -p

now you can play with the binary with glibc-2.30

and even debug it with the correct symbols

readelf -d -W malloc_playground | grep RUNPATH # or use checksec readelf -l -W malloc_playground | grep interpreter gdb -q -ex "start" ./malloc_playground

# Ferramentas de Exploração de Heap

Existem algumas ferramentas de exploração de heap por aí.

## Malloc Playground

O arquivo `malloc_playground.c` fornecido é o código-fonte de um programa que solicita ao usuário comandos para alocar e liberar memória interativamente.

## Pwngdb

Examine o heap do glibc no gdb: https://github.com/scwuaptx/Pwngdb

## pwndbg

Um plugin do gdb focado em exploração que oferece a capacidade de visualizar/manipular o heap do glibc: https://github.com/pwndbg/pwndbg

## gef

Outro excelente plugin do gdb que oferece a capacidade de examinar o heap do glibc: https://github.com/hugsy/gef

## heap-viewer

Examine o heap do glibc no IDA Pro: https://github.com/danigargu/heap-viewer

## heaptrace

Ajuda você a visualizar operações de heap substituindo endereços por símbolos: https://github.com/Arinerron/heaptrace

# Outros recursos

Alguns bons recursos sobre exploração de heap, aproximadamente em ordem inversa de publicação, são:

## Tutoriais úteis de exploração de heap
- Visão geral das técnicas de exploração de heap do GLIBC (https://0x434b.dev/overview-of-glibc-heap-exploitation-techniques/) <!-- 2022 -->
- Tutorial aprofundado do glibc (https://heap-exploitation.dhavalkapil.com/) - livro e amostras de exploits <!-- 2022 -->
- Técnicas de exploração de heap que funcionam no glibc-2.31 (https://github.com/StarCross-Tech/heap_exploit_2.31) <!-- 2020 -->
- Introdução descomplicada ao heap do userland do Linux (https://sensepost.com/blog/2017/painless-intro-to-the-linux-userland-heap/) <!-- 2017 -->
- ptmalloc fanzine, um conjunto de recursos e exemplos relacionados a ataques de metadados no ptmalloc (http://tukan.farm/2016/07/26/ptmalloc-fanzine/) <!-- 2016 -->
- Glibc Adventures: The Forgotten Chunk (https://github.com/bash-c/slides/blob/master/pwn_heap/Glibc%20Adventures:%20The%20forgotten%20chunks.pdf) - exploração avançada de heap <!-- 2015 -->

## Exploração histórica de heap (A História)
- Pseudomonarchia jemallocum (http://www.phrack.org/issues/68/10.html) <!-- 2012 -->
- The House Of Lore: Reloaded (http://phrack.org/issues/67/8.html) <!-- 2010 -->
- Malloc Des-Maleficarum (http://phrack.org/issues/66/10.html) - algumas técnicas de exploração de malloc <!-- 2009 -->
- Mais uma técnica de exploração de free() (http://phrack.org/issues/66/6.html) <!-- 2009 -->
- O uso de set_head para derrotar o wilderness (http://phrack.org/issues/64/9.html) <!-- 2007 -->
- Entendendo o heap ao quebrá-lo (https://www.blackhat.com/presentations/bh-usa-07/Ferguson/Whitepaper/bh-usa-07-ferguson-WP.pdf) - explica a implementação do heap e alguns exploits <!-- 2007 -->
- Técnicas de exploração de heap do OS X (http://phrack.org/issues/63/5.html) <!-- 2005 -->
- The Malloc Maleficarum (http://seclists.org/bugtraq/2005/Oct/118) <!-- 2005 -->
- Exploiting The Wilderness (http://seclists.org/vuln-dev/2004/Feb/25) <!-- 2004 -->
- Exploits avançados do malloc de Doug lea (http://phrack.org/issues/61/6.html) <!-- 2003 -->

# Hardening
Existem algumas medidas de "hardening" embutidas no glibc, como `export MALLOC_CHECK_=1` (ativa algumas verificações), `export MALLOC_PERTURB_=1` (os dados são sobrescritos), `export MALLOC_MMAP_THRESHOLD_=1` (sempre usar mmap()), ...

Mais informações: [mcheck()](http://www.gnu.org/software/libc/manual/html_node/Heap-Consistency-Checking.html), [mallopt()](http://www.gnu.org/software/libc/manual/html_node/Malloc-Tunable-Parameters.html).

Há também algum suporte a rastreamento como [mtrace()](http://manpages.ubuntu.com/mtrace), [malloc_stats()](http://manpages.ubuntu.com/malloc_stats), [malloc_info()](http://manpages.ubuntu.com/malloc_info), [memusage](http://manpages.ubuntu.com/memusage), e em outras funções dessa família.

how2heap

Mais Populares