Realizando Análise de Exploração Binária

Apenas para testes de segurança autorizados e desafios CTF.

Analise binários ELF em busca de vetores de exploração usando checksec, ROPgadget e pwntools para desenvolvimento de buffer overflow e cadeias ROP.

Quando Usar

• Analisando binários ELF durante testes de penetração autorizados para identificar vulnerabilidades de corrupção de memória
• Resolvendo desafios de exploração binária em competições CTF
• Avaliando a eficácia de mitigações de compilador (NX, ASLR, canários de pilha, PIE, RELRO) em binários alvo
• Desenvolvendo exploits de prova de conceito para relatórios de vulnerabilidade para demonstrar o impacto
• Treinando engenheiros de segurança em técnicas de desenvolvimento de exploits para conscientização defensiva
• Validando se os patches de segurança para vulnerabilidades de buffer overflow são eficazes

Não use contra sistemas sem autorização explícita por escrito. Técnicas de exploração binária podem causar instabilidade no sistema e devem ser aplicadas apenas em ambientes controlados (VMs de laboratório, plataformas CTF, pentests autorizados com documentos de escopo).

Pré-requisitos

• Sistema Linux (Ubuntu/Debian recomendado) para desenvolvimento de exploits
• Python 3.8+ com pwntools (pip install pwntools)
• GDB com plugin pwndbg ou GEF para depuração aprimorada
• ROPgadget para descoberta de gadgets de cadeia ROP (pip install ROPgadget)
• checksec (incluído com pwntools ou independente via apt install checksec)
• Binário vulnerável alvo compilado para teste (por exemplo, de pwnable.kr, ROP Emporium ou binários de teste personalizados)
• Compreensão básica das convenções de chamada x86/x86_64 e layout da pilha

Fluxo de Trabalho

Etapa 1: Instalar o Kit de Ferramentas de Exploração

# Install pwntools and dependencies
pip install pwntools ROPgadget

# Install GDB with pwndbg plugin
git clone https://github.com/pwndbg/pwndbg
cd pwndbg && ./setup.sh

# Alternatively, install GEF (GDB Enhanced Features)
# bash -c "$(curl -fsSL https://gef.blah.cat/sh)"

# Install supporting tools
sudo apt install -y gdb nasm gcc-multilib libc6-dbg

# Verify installation
python3 -c "from pwn import *; print('pwntools version:', version)"
checksec --version
ROPgadget --version

Etapa 2: Analisar Proteções de Binário com checksec

Antes de escrever qualquer exploit, liste as mitigações de segurança compiladas no binário:

from pwn import *

# Load the target binary
binary_path = "./vulnerable_server"
elf = ELF(binary_path)

# checksec output explains what mitigations are in place
print(f"Architecture: {elf.arch}")
print(f"Bits: {elf.bits}")
print(f"Endianness: {elf.endian}")
print()

# Key security properties
# RELRO: Full = GOT is read-only, Partial = GOT header read-only, No = writable GOT
# Stack Canary: Detects stack buffer overflows via random canary value
# NX (No-eXecute): Prevents executing code on the stack (DEP)
# PIE: Position Independent Executable, randomizes base address
# ASLR: OS-level address randomization (check /proc/sys/kernel/randomize_va_space)

# Also available via command line:
# checksec --file=./vulnerable_server

# Command-line checksec output example:
checksec --file=./vulnerable_server
# RELRO           STACK CANARY      NX            PIE
# Partial RELRO   No canary found   NX disabled   No PIE

# Check ASLR status on the system
cat /proc/sys/kernel/randomize_va_space
# 0 = disabled, 1 = conservative, 2 = full randomization

Etapa 3: Encontrar o Offset do Buffer Overflow

Determine exatamente quantos bytes são necessários para sobrescrever o endereço de retorno:

from pwn import *

context.binary = ELF("./vulnerable_server")
context.log_level = "info"

# Method 1: Use cyclic pattern to find exact offset
# Generate a unique cyclic pattern
pattern_length = 200
pattern = cyclic(pattern_length)
print(f"Generated cyclic pattern of length {pattern_length}")

# Send the pattern to the binary
p = process("./vulnerable_server")
p.sendline(pattern)
p.wait()

# After the crash, read the value in RIP/EIP from core dump or GDB
# Then find the offset:
# For 64-bit: crashed_value = p.corefile.fault_addr
# Or manually from GDB: "info registers rip" after crash
crashed_rip = 0x6161616c  # Example value from crash
offset = cyclic_find(crashed_rip)
print(f"Offset to return address: {offset} bytes")

# Method 2: Use GDB with pwndbg to find offset interactively
# In GDB:
#   pwndbg> cyclic 200
#   pwndbg> run < <(python3 -c "from pwn import *; print(cyclic(200).decode())")
#   pwndbg> cyclic -l $rsp   (or cyclic -l <value in RIP>)

…