Arquitetura de Computadores

(Fundação absoluta para todo exploit e engenharia reversa)

Meta do módulo: ao final, você será capaz de desenhar a organização de memória de um processo, identificar onde variáveis vivem, explicar a função dos registradores principais e demonstrar com debugger a criação e destruição de stack frames, distinguindo claramente stack de heap.

Módulo 1 — Memória, Registradores, Stack & Heap

(Fundação absoluta para todo exploit e engenharia reversa)

Meta do módulo: ao final, você será capaz de desenhar a organização de memória de um processo, identificar onde variáveis vivem, explicar a função dos registradores principais e demonstrar com debugger a criação e destruição de stack frames, distinguindo claramente stack de heap.

---

1. Panorama Geral — “O Prato Feito Digital”

Camada	Analogia visual	Conteúdo típico	Permissões padrão
.text	Receita fixada	Instruções	r-x
.rodata	Etiquetas	Strings/constantes	r--
.data	Arroz pronto	Globais inicializadas	rw-
.bss	Panela vazia	Globais zeradas	rw-
Heap	Bufê à la carte	Alocações via malloc/new	rw-
Stack	Torre de pratos	Frames de função	rw-

Lab‑flash 01 (3 min): readelf -S hello | grep -E '\.(text|data|bss|rodata)' → anote tamanho e offsets.

---

2. Registradores Essenciais — “O Painel de Controle da CPU”

Família	Propósito	Exemplo (x86‑64)
Dados	Operações aritméticas/lógicas	RAX, RBX, RCX, RDX
Indexação	Ponteiros/arranjos	RSI, RDI
Stack Pointer	Topo da torre	RSP (ESP 32‑bit)
Base Pointer	Base do frame atual	RBP (EBP)
Instruction Pointer	Próxima instrução	RIP (EIP)

Lab‑flash 02 (2 min):

gdb -q ./hello
start
info reg rip rsp rbp rax

Explique em voz alta o que cada valor representa.

---

3. A Stack em Detalhes — “Pratos que entram, pratos que saem”

Endereços altos ↓
┌──────────────────────────────┐
│ Args da função            │
│ Endereço de retorno ← alvo│
│ RBP anterior              │
│ Variáveis locais          │
└──────────────────────────────┘
Endereços baixos ↑

3.1 Ciclo de vida do frame

1. Prólogo: push rbp; mov rbp, rsp; sub rsp, X → reserva espaço.

2. Corpo: usa variáveis locais / chamadas aninhadas.

3. Epilogo: leave; ret → descarta frame e volta ao chamador.

3.2 Por que importa?

• Sobrescrever o endereço de retorno = controle total do fluxo (BoF).

• Leak de rbp/rsp ajuda em info‑leaks e ROP.

Lab‑guiado: compile vuln.c com -fno-stack-protector -g, trace no GDB e observe a mudança de RSP ao entrar/sair de vuln().

---

4. A Heap em Detalhes — “Bufê Sob Demanda”

Conceito	x86‑64/Linux (glibc)	Analogias
Arena	Região gerenciada pelo malloc	Salão do bufê
Chunk	Bloco individual	Porção no prato
Free list / bins	Listas de chunks livres	Pilhas de pratos limpos

• Cresce para cima (end. maiores).

• Vulnerabilidades típicas: heap overflow, use‑after‑free, double‑free.

Lab‑flash 03 (5 min): código heap_demo.c com dois malloc, free, breakpoint em free e olhar glibc bins via pwndbg heap bins.

---

5. Stack vs Heap — Comparação Rápida

Atributo	Stack	Heap
Gerência	Automática (CPU)	Manual (malloc/free)
Crescimento	↓ (endereços menores)	↑ (endereços maiores)
Tamanho	Limitado (default 8 MB)	Virtualmente ilimitado
Velocidade	Muito rápido	Mais lento
Riscos	Buffer/stack overflow	Heap overflow, UAF

---

6. Exercícios Práticos

1. Mapeie seu processo: cat /proc/$(pidof hello)/maps e marque stack & heap.

2. Desmonte uma função foo e identifique cada campo do frame.

3. Exploit básica: modifique exemplo gets() e provoque SIGSEGV → capture offset com pwntools cyclic.

---

7. Checklist Feynman

• Posso desenhar de cabeça a ordem das seções .text → .bss → heap → stack.

• Sei explicar diferença entre RBP e RSP.

• Consigo demonstrar overflow que altera endereço de retorno.

• Localizo no pwndbg a arena principal do heap e interpreto um chunk.

---

8. Referências Oficiais Essenciais

1. Intel® 64 Manuals, Vol. 1 §§ 2–3 (registradores, modos).

2. Operating Systems: Three Easy Pieces – Cap. 14 (Virtual Memory).

3. The Art of Exploitation § Stack & Heap.

4. pwndbg docs – heap commands.

5. glibc malloc internals (ptmalloc3 wiki).

---

Pronto! Esta base sólida permitirá quebrar limites (BoF, heap feng‑shui) nos módulos seguintes.🤘

Módulo 1 – Fundamentos da Engenharia Reversa

Meta do módulo: construir a base conceitual e prática indispensável para todo o restante do curso, respondendo quatro perguntas‑chave:

1. Como o computador armazena e move dados (memória, registradores, pilha, heap)?

2. Como o sistema operacional conversa com o hardware e com os processos?

3. Como ler e escrever Assembly (x86/x64) de forma fluida?

4. Quais ferramentas vou usar no resto do curso e como iniciar nelas?

---

1 Arquitetura de Computadores

1.1 Mapa da Memória

Segmento	Permissões típicas	Conteúdo	Analogia
.text	r‑x	Código	Receita fixa na parede
.rodata	r--	Constantes/strings	Etiquetas
.data	rw-	Globais inic.	Arroz pronto
.bss	rw-	Globais zeradas	Panela vazia
heap	rw-	malloc/new	Bufê à la carte
stack	rw-	Frames de função	Torre de pratos (LIFO)

Hands‑on (5 min) readelf ‑S hello → marque endereço e tamanho de cada segmento.

1.2 Registradores essenciais

Arquitetura	Propósito	Exemplos
x86 (32 bit)	Dados	EAX, EBX, ECX, EDX
x86‑64 (64 bit)	Dados estendidos	RAX, RBX, … R15
Ambos	Stack ptr	ESP / RSP
Ambos	Base ptr	EBP / RBP
Ambos	Próxima instrução	EIP / RIP

Micro‑lab:

gdb ./hello
start
info reg rip rsp rbp

1.3 Stack × Heap visual

Endereços altos ↓
|   Stack   |  ← cresce para baixo
|-----------|
|   Heap    |  ← cresce para cima
|-----------|
| .bss/.data|
|-----------|
|   .text   |
Endereços baixos ↑

---

2 Sistemas Operacionais em 10 minutos

1. Modo usuário × modo kernel ‑ privilégio e interrupções.

2. Syscalls ‑ ponte de user para kernel (Linux: int 0x80, syscall; Windows: ntdll → KiFastSystemCall).

3. Carregador (loader) ‑ mapeia ELF/PE na memória.

4. Gerência de memória virtual ‑ páginas, proteção (rwx).

Exercício‑flash: use strace ls (Linux) ou Process Monitor (Win) e liste cinco syscalls mais comuns de um “Hello World”.

---

3 Assembly Essencial (x86/x64)

3.1 Sintaxe AT&T × Intel

• AT&T (prefixo %) → mov %eax, %ebx

• Intel → mov ebx, eax

3.2 Conjunto mínimo de instruções

Grupo	Exemplo	Uso
Transferência	mov, lea, xchg	Dados
Aritmética	add, sub, inc, dec	Contadores
Lógica	and, or, xor, not	Flags / criptografia
Controle	call, ret, jmp, je	Fluxo
Pilha	push, pop, leave	Frames

3.3 Calling conventions

• System V AMD64 (Linux/macOS): argumentos → RDI RSI RDX RCX R8 R9.

• Microsoft x64: RCX RDX R8 R9, resto stack.

Lab rápido: compile gcc -fasynchronous-unwind-tables -S hello.c e abra o .s.

---

4 Ferramentas Essenciais (setup mínimo)

Categoria	Ferramenta	Tarefa inicial
Disassembler/Decompiler	Ghidra	Abrir ELF/PE, renomear main
Disassembler GUI	IDA Free	Navegar gráfico de funções
CLI + scriptável	Radare2/iaito	aaa, pdf, VV
Debugger Linux	GDB + GEF/Pwndbg	Break main, print stack
Debugger Windows	x64dbg	Trace printf
Helper Exploit	pwntools	cyclic() & socket

Dica de Feynman: se você não consegue explicar o comando pdf @ main para outra pessoa, volte e pratique até fazer sentido.

---

5 Checkpoint de Aprendizagem

• Desenhei à mão um diagrama completo stack/heap/segments.

• Pausar um programa no GDB/x64dbg e localizar RIP.

• Explicar a diferença entre modo usuário e modo kernel em ≤ 60 s.

• Converter pseudo‑código simples em assembly mentalmente.

---

Prova Relâmpago (auto‑cheque)

1. Qual registrador recebe o 1.º argumento em System V AMD64?

2. O que acontece internamente quando você faz call func?

3. Cite duas diferenças entre heap e stack.

Se travar em qualquer pergunta, revise a seção correspondente.