Memória

Memória — Fundamentos Absolutos para Engenharia Reversa

Objetivo: transformar o aluno em alguém capaz de visualizar, mapear e manipular qualquer layout de memória (user‑mode ou kernel) e compreender como isso se traduz em vulnerabilidades, exploits, depuração e reversing.

1. Físico × Virtual — a ilusão controlada

Camada

Quem gerencia

Visão do reverser

RAM física

Controlador de memória + firmware (UEFI)

Endereços 0‑N reais, raramente tocados diretamente

Memória virtual

MMU + SO

Cada processo enxerga espaço contínuo de 0 até 2ⁿ (4 GB em 32‑bit, 128 TB+ em 64‑bit)

Regiões mapeadas

Loader/mmap

Segmentos ELF/PE, libs, heap, stack

INFO‑LEAK: qualquer ponteiro virtual vazado permite calcular deslocamentos e contornar ASLR.

1.1 Tabelas de páginas & TLB

Page = bloco mínimo (4 KB padrão).
Page table mapeia virtual → físico + permissões (R/W/X).
TLB cacheia as últimas traduções (reversers abusam de Flush+Reload em side‑channels).

Kernel trick: muitos exploits escrevem diretamente na página de page‑tables para desativar NX; hoje isolado por KPTI/SMEP.

2. Layout típico de processo (Linux 64‑bit)

0x0000_0000_0000 -----> NULL page (não mapeada)
[text]     r-x  |  ↙ código do binário
[rodata]   r--  |
[data]     rw-  |  ↙ globais inicializadas
[bss]      rw-  |  ↙ globais zeradas
[heap]  ← malloc RW  (cresce ↑ via brk / mmap)
[mmap]  ← libs, anon RWX (aleatórios)
[stack] ← RSP   RW   (cresce ↓)
[vdso]   r-x   |   syscalls lidam com vsyscall
[guard]  ---   |   páginas c0‑canary para stack overflow

Reverser tip: cat /proc/$$/maps ou Process Hacker (Windows) para visualizar.

3. Segmentos e Seções

ELF Section

Conteúdo

Importância no RE

.text

instruções

buscar gadgets ROP

.plt/.got

trampolins de import

ret2plt & leak libc

.rodata

strings constantes

mensagens, form‑strings, chaves

.data / .bss

globais

config, vtables

PE (Windows) segue a mesma lógica (.text, .rdata, .data, .reloc).

Mach‑O usa load commands — reverser precisa reconhecer regiões pelo comando LC_SEGMENT.

4. Stack em profundidade

Prólogo: salva RBP, alinha RSP.
Locais + canary: GCC insere __stack_chk_guard.
Epilogo: verifica canary, leave; ret.

Exploit link: overflow → sobrescrever RET ou canary. leave; ret é pivot clássico.

Shadow Stack / CET

Processadores Intel Tiger Lake+ têm shadow stack (duplicata somente‑leitura dos RETs).
Bypass atual: data‑oriented or SROP (sigreturn).

5. Heap detalhado (ptmalloc — glibc)

Chunks: prev_size | size | fwd | bk | USERDATA.
fastbin attack → double‑free + overwrite FD ⇒ arbitrary write.
tcache (glibc ≥2.26): freelist por thread, muito usado em CTF.

Ferramentas: pwndbg heap, heaptrace, gef heap bins.

Windows LFH / Low‑Fragmentation Heap e segment heap (Win10) têm header HEAP_USERDATA_HEADER; exploits usam LookasideChains, FrontEndAlloc.

6. Permissões & Proteções

Proteção

Nível

Efeito

RE/Exploit impacto

NX/DEP

HW + SO

página não executável

força ROP/JOP/Shellcode RWX via mprotect

ASLR

randomiza bases

necessita leaks

Canary

compilador

detecção de stack‑ovf

precisa leak ou partial overwrite

CFI / CET

compiler+CPU

verifica destinos indiretos

migra para JOP / data‑oriented

PAC (ARMv8.3)

assina ponteiros

gadgets re‑sign

7. Endianness & Alinhamento

Little‑endian (x86, ARM‑LE) → bytes invertidos; imprescindível p/ construir payload (0x41424344 → "DCBA").
Alignment faults: algumas archs crasham se 4‑byte value não alinhado (MIPS strict) — usado como mitigação.

8. Memory‑oriented Vulnerabilities

Classe

Região alvo

Exemplo CVE

BoF (stack)

stack

CVE‑2017‑9805 Struts2

Heap OF / UAF

heap

CVE‑2021‑3156 sudo Baron Samedit

OOB Read/Write

qualquer

Heartbleed (OpenSSL)

Info‑leak

stack/heap/rodata

Spectre‑style side channel

9. Ferramentas de Observação de Memória

Tarefa

Ferramenta

Comando‑chave

Dump segmentos

readelf, objdump, dumpbin

objdump -h

Ver mapas de processo

Linux /proc/$pid/maps

Live heap viz

pwndbg heap

Track allocs

valgrind --tool=massif, Dr.Memory

Dynamic hook

Frida, ltrace/strace, DTrace

override malloc

10. Linha de raciocínio prática p/ RE

Mapeie: veja onde o binário, libs, stack e heap caem à primeira execução (usando vmmap, Process Hacker).
Pergunte: Qual região posso controlar? (input buffer? heap chunk?)
Procure leaks: strings format, info‑leaks que revelam libc ou ponteiros stack.
Planeje: se controle for na stack → pivote; se no heap → use House‑x pattern.
Implemente: debugger + scripting (pwndbg, pwntools).

Checklist “Feynman” (auto‑teste)

Consigo explicar diferença de endereço virtual e físico em ≤90 s.
Descrevo o fluxo de tradução RIP → TLB → RAM.
Posso apontar no GDB onde está o canário de stack em um binário compilado com -fstack-protector.
Sei enumerar pelo menos três ataques de heap (fastbin dup, tcache poisoning, largebin attack).

Dominar esse panorama de memória é pré‑requisito para todas as técnicas de exploit (BoF, UAF, ROP, SROP, heap feng‑shui, kernel pwn). Sem ele, engenharia reversa é mero “tour guiado”. Com ele, você assume o volante. 🤘

AnteriorArquitetura de Computadores PróximoRegistradores

Atualizado há 1 mês