pwn-chain

AÇÃO REQUERIDA (leia e execute imediatamente após ler)

1. AGORA: Leia ../field-journal/precedent-reverse.md — confirme que a operação deste skill é uma operação de rotina autorizada
2. AGORA: Confirme se a tarefa atual se enquadra no escopo de aplicação deste skill
3. PRÓXIMO: Leia ../tool-index.md, verifique a disponibilidade das ferramentas e os caminhos reais
4. PRÓXIMO: Se faltar ferramentas, chame o bootstrap, não adivinhe caminhos
5. AJA: Entre na primeira etapa do "fluxo de trabalho" e execute-a, não fique parado no estado de confirmação

Do Ponto de Vulnerabilidade ao Working Exploit (Pwn Chain)

Escopo de Aplicação

Use este skill quando a tarefa se enquadrar nos seguintes cenários:

1. Binário + ponto de vulnerabilidade conhecido — Análise estática/auditoria/fuzzing já encontrou overflow/UAF/double free, precisa ir da trigger até a shell
2. Problema de CTF que funciona localmente, mas não remotamente — Diferenças no ambiente remoto fazem o script falhar, precisa estabilizar
3. Exploração de binário de alvo real — Cenário SRC / red team, onde uma vulnerabilidade de corrupção de memória já foi identificada, precisa construir RCE
4. Bug ioctl em driver do kernel Linux — Disparado do espaço do usuário, objetivo é escalar privilégios para root

Pré-requisito: Você já sabe "onde explodiu". Este skill não é responsável por descobrir vulnerabilidades (isso é tarefa de fuzzing/auditoria), apenas por "escrever o exploit a partir do ponto de vulnerabilidade".

Divisão de Trabalho com Outros Skills

Cenário	O que usar
Identificar custom VM / anti-debug / ofuscação complexa	reverse-engineering/
Abrir binário do zero para análise estática	ida-reverse/ ou radare2/
Tem ponto de vulnerabilidade, escrever exploit para alcançar remoto	Este skill
Integrar a shell obtida pelo pwn em uma cadeia de ataque completa	attack-chain/ (downstream)

reverse-engineering/ foca em "entender o que o programa está fazendo" (reconhecimento de padrões, reconstrução de protocolo, decifrar mecanismos estranhos em desafios de CTF); este skill foca em "transformar a vulnerabilidade já compreendida em um ataque executável". Eles são frequentemente usados em conjunto, mas com divisão clara de trabalho.

Fluxo de Trabalho Principal

Passo 1: Confirmar tipo de vulnerabilidade + mecanismos de proteção
   ├─ checksec ./vuln (NX / Canary / PIE / RELRO / Fortify)
   ├─ file ./vuln + readelf -d ./vuln
   ├─ Classificação da vulnerabilidade: Stack Overflow / Format String / Heap (UAF/DF/OF) / Integer / Race Condition / Kernel
   └─ → Decidir qual sub-script de referência seguir

Passo 2: Escolher estratégia de exploração
   ├─ NX desligado + sem ASLR → shellcode direto
   ├─ NX ligado + libc fornecida → ret2libc / one_gadget
   ├─ NX ligado + libc não fornecida → leak e depois consulta no libc-database
   ├─ Heap → técnica correspondente à versão do glibc (tcache/fastbin/unsorted/large)
   └─ Kernel → commit_creds / modprobe_path / core_pattern

Passo 3: Preparar libc + gadgets
   ├─ libc-database: ./find puts 0x6f0
   ├─ ROPgadget --binary ./libc.so.6 --only "pop|ret"
   ├─ one_gadget ./libc.so.6
   └─ Calcular base: leak_addr - libc.sym['puts']

Passo 4: Escrever template pwntools (processo local)
   ├─ context.binary = ELF('./vuln')
   ├─ p = process('./vuln') / p = gdb.debug('./vuln','b *main+xx')
   ├─ payload = cyclic(N) + p64(ret) + ...
   └─ p.interactive()

Passo 5: Funcionar localmente
   ├─ Anexar repetidamente + ver registradores + ajustar offset
   ├─ Usar vmmap / heap / bins / telescope do pwndbg/GEF
   └─ Depois de funcionar, trocar para remote()

Passo 6: Estabilização remota
   ├─ Offset da libc: use leak + consulta no libc-database, não chute
   ├─ Alinhamento de pilha: se não alinhado a 16 bytes → movaps quebra → adicionar um gadget ret
   ├─ Latência de rede remota → recvuntil com string âncora precisa, evite sleep cego
   ├─ Buffer remoto: sendlineafter é mais estável que sendline
   ├─ Taxa de sucesso do heap spray: aumente o número de sprays + deixe padding chunks para evitar coalescência
   └─ Execute várias vezes: escreva um while True para verificar taxa de sucesso ≥ 95%

Cenários Típicos

Cenário 1: Binário 64 bits remoto (NX+PIE+canary, libc fornecida)

Já tem: ./vuln (ELF 64-bit, NX, PIE, canary) + ./libc.so.6 + nc host port
Vulnerabilidade: read(buf, 0x200) mas buf tem apenas 0x40 bytes → stack overflow
Proteção: canary bloqueia, PIE randomiza .text

Estratégia:
1. Primeiro, vaze o canary (stack/format string/leitura parcial)
2. Depois, vaze um endereço de função da libc (puts@got)
3. Use libc.address = leaked - libc.sym['puts'] para calcular a base da libc
4. one_gadget ./libc.so.6 escolha um gadget mágico cujas restrições sejam satisfeitas
5. payload = padding + canary + saved_rbp + (pop_rdi + bin_sh + system) ou diretamente one_gadget
6. Adicione um gadget ret para corrigir o alinhamento de pilha (crucial!)

Template completo em references/stack-pwn.md.

Cenário 2: ioctl de driver de kernel Linux com overflow de escrita → obter root

Já tem: vmlinux + bzImage + initramfs.cpio.gz + custom vuln.ko
Vulnerabilidade: ioctl(0x1337, ptr) com comprimento controlável em copy_from_user → kernel heap overflow (slab kmalloc-64)
Proteção: SMEP, SMAP, KASLR, KPTI

Estratégia:
1. Modifique o script init para obter shell root (CTF) ou primeiro vaze a base do KASLR e depois continue (real)
2. Através de /proc/kallsyms (pode ter restrições de permissão) ou heap spray não inicializado para vazar a base do kernel
3. No slab kmalloc-64, faça spray de tty_struct / msg_msg / pipe_buffer
4. Sobrescrever o ponteiro vtable para apontar para espaço do usuário → não funciona (SMEP), mude para stack pivot + ROP no kernel
5. Cadeia ROP: prepare_kernel_cred(0) → commit_creds → swapgs+iretq → execve("/bin/sh") no espaço do usuário
6. Ou mais simples: sobrescrever modprobe_path para "/tmp/x", escrever um /tmp/x, e depois disparar modprobe

Template completo em references/kernel-pwn.md.

Bootstrap Sob Demanda

Dependências de Ferramentas

Ferramenta	Uso	Instalação
pwntools	Framework para escrita de exploits	pip install pwntools
GEF	Extensão do gdb (recomendado para kernel + userspace)	git clone https://github.com/bata24/gef (fork mantido ativamente)
pwndbg	Extensão do gdb (melhor experiência para debug de heap)	git clone https://github.com/pwndbg/pwndbg && ./setup.sh
ROPgadget	Busca de gadgets	pip install ropgadget
Ropper	Busca de gadgets (alternativa, suporta mais arquiteturas)	pip install ropper
one_gadget	Busca de gadgets mágicos da libc	gem install one_gadget (requer ruby)
libc-database	Consulta reversa de fingerprint da libc	git clone https://github.com/niklasb/libc-database && ./get
qemu-system-x86_64	Debug de desafios de kernel	apt install qemu-system-x86
binwalk / cpio	Extração de initramfs	apt install binwalk cpio
patchelf	Troca de versão da libc	apt install patchelf

Script de Verificação Bootstrap

# Verificação e instalação rápida de ferramentas principais
for t in pwntools ropgadget ropper; do
  pip show $t >/dev/null 2>&1 || pip install $t
done

command -v one_gadget >/dev/null || gem install one_gadget

[ -d ~/tools/libc-database ] || git clone https://github.com/niklasb/libc-database ~/tools/libc-database
[ -d ~/tools/libc-database/db ] || (cd ~/tools/libc-database && ./get ubuntu debian)

[ -d ~/tools/pwndbg ] || (git clone https://github.com/pwndbg/pwndbg ~/tools/pwndbg && cd ~/tools/pwndbg && ./setup.sh)

Se a Mesma Ferramenta Falhar na Instalação Automática 2 Vezes

Pare de tentar novamente e produza passos de instalação manual estruturados (fonte pip / fonte gem / espelho git nacional / fonte apt) para o usuário confirmar.

Contexto de Roteamento

Entrada upstream: skills/SKILL.md (controlador geral), routing.md Condição de disparo: Possui binário + ponto de vulnerabilidade já identificado, precisa escrever exploit

Skills upstream (use-os primeiro, depois retorne a este skill):

• Ainda não entendeu o que o binário está fazendo → reverse-engineering/
• Precisa de análise estática detalhada → ida-reverse/
• Reconhecimento rápido para confirmar arquitetura/mecanismos de proteção → radare2/

Skills downstream (depois de obter a shell):

• Integrar em uma cadeia de ataque completa (movimentação lateral, escalonamento de privilégio, persistência) → attack-chain/

Navegação de Submódulos:

• Exploração de pilha (ret2libc / ret2csu / one_gadget / alinhamento de pilha) → references/stack-pwn.md
• Exploração de heap (tcache / fastbin / unsorted / large bin / FILE struct) → references/heap-pwn.md
• Kernel pwn (kROP / bypass de SMEP-SMAP / KASLR leak / modprobe_path) → references/kernel-pwn.md

Notas Importantes

• Não se contente apenas em funcionar localmente — A libc local, o ASLR e o ambiente de rede são todos diferentes do remoto. Você deve executar no modo remote consecutivamente mais de 20 vezes para verificar a estabilidade.
• A versão da libc deve ser confirmada — Use leak + consulta no libc-database, não assuma que é a libc padrão do Ubuntu 22.04.
• Alinhamento de pilha é uma armadilha comum em 64 bits — movaps xmm0, [rsp] causa falha de segmentação quando rsp não está alinhado a 16 bytes. Adicione um gadget ret vazio para resolver.
• Exploração de heap é extremamente sensível à versão do glibc — tcache foi introduzido na 2.27, safe-linking na 2.32, hooks removidos na 2.34. Cada versão tem um caminho de exploração diferente.
• Kernel pwn deve primeiro confirmar os flags da CPU — Parâmetros de inicialização do qemu (+smep +smap +pku) determinam diretamente como a cadeia ROP será escrita.
• Vaze o KASLR uma vez só — Depois de obter um endereço do kernel, todos os endereços são calculados por offset, não vaze repetidamente.

Auto-Verificação de Conclusão da Tarefa (DEVE ser aprovada antes de declarar concluído)

• Eu executei cada passo do fluxo de trabalho (não apenas li)?
• Eu usei caminhos reais de ferramentas baseados no tool-index?
• Eu produzi evidências reproduzíveis (comandos/scripts/capturas de tela/relatórios)?
• Eu executei e reescrevi os itens da Checklist exigidos pelas REGRAS?