Malware costuma ser empacotado (comprimido/cifrado) para dificultar a análise — o strings não revela nada até você desempacotar (dinâmica: rodar e capturar a memória já descompactada). Reconhecer packing é parte da triagem.

PARTE D — Noções de vulnerability research (o outro uso do RE)

O RE também serve para achar vulnerabilidades em software — a base da pesquisa de segurança. Em alto nível:

Buffer overflow: escrever mais dados do que o espaço reservado na memória → sobrescrever regiões vizinhas → no pior caso, controlar o fluxo do programa (executar código). É a classe clássica de falha de memória (A.3).
As defesas modernas (por isso overflows ficaram mais difíceis): ASLR (embaralha os endereços de memória), DEP/NX (marca memória de dados como não-executável), stack canaries (um valor sentinela que detecta a sobrescrita).
A lição arquitetural: linguagens memory-safe (Rust, Go, e as gerenciadas como JS/Python) eliminam a maioria dessas classes por design — é por isso que a escolha de linguagem é uma decisão de segurança (liga ao Módulo 9).

Para o seu stack (web/cloud/JS/TS), bugs de memória quase não aparecem — por isso esta fase é opcional para você. Mas entender por que você está protegido (memory-safe) é valioso.

PARTE E — Labs práticos 🧪

Comece por RE de "brinquedo" (crackmes) antes de qualquer malware. Malware real, só no lab isolado (B.3).

Lab 1 — Compilar e ver o assembly (🟢) — o primeiro contato

printf '#include <stdio.h>\nint main(){int x=2+2; printf("%d\\n",x); return 0;}' > lab.c
gcc -o lab lab.c
file lab            # tipo/arquitetura (ELF)
strings lab | head  # textos legíveis
objdump -d lab | grep -A20 '<main>:'   # o assembly do main

Observe: o seu 2+2 virou instruções. Lição: é isso que o RE lê (A.1/A.2).

Lab 2 — Ghidra num binário simples (🟢)

Abra o lab (ou um crackme) no Ghidra e veja o decompile (pseudo-C). Lição: a ferramenta reconstrói a lógica do binário (B.1).

Lab 3 — crackmes.one (🟢) — RE para iniciante

Baixe um crackme fácil de crackmes.one e tente descobrir a "senha" lendo o binário (estática + dinâmica). São feitos para aprender, legalmente. Lição: RE na prática, sem risco.

Lab 4 — strings/triagem (🟢)

Rode strings + consulte o hash de um arquivo no VirusTotal. Lição: a triagem inicial de um artefato (C.2).

Lab 5 — Cursos guiados (🟢, gratuitos)

Malware Unicorn — RE101/RE102 (curso gratuito e excelente de RE).
pwn.college (fundamentos de exploração/RE, acadêmico e gratuito).
Montar uma REMnux/FLARE-VM para ter o ambiente pronto.

PARTE F — Autoavaliação ✅

Responda de memória:

Por que linguagens compiladas exigem RE e as interpretadas nem tanto?
Você precisa decorar assembly? O que precisa, então?
Qual a diferença entre análise estática e dinâmica?
Por que malware só pode ser analisado em VM isolada sem rede?
O que é um IoC e para que serve depois da análise?
O que é YARA e com qual fase anterior ele se conecta?
O que é buffer overflow e cite duas defesas modernas.

<details><summary>👉 Gabarito</summary>

Compiladas distribuem o binário (código de máquina, ilegível) → precisa reverter; interpretadas distribuem o código-fonte/bytecode, mais fácil de ler (A.1).
Não. Você precisa reconhecer padrões (if = comparação+salto; laço = salto para trás; call = função) (A.2).
Estática: ler o binário parado (strings, Ghidra). Dinâmica: rodar e observar o comportamento (debugger/sandbox) (B.1/B.2).
Para o malware não escapar nem se comunicar com o C2 / infectar sua rede real; o snapshot permite reverter (B.3).
Indicador de comprometimento (hash, IP/domínio de C2, arquivo). Serve para detecção (YARA/Sigma) e threat intel (C.1).
Linguagem de regras para detectar malware por padrões. Conecta-se ao Blue Team (10) e ao Purple (12) — vira detecção (C.3).
Escrever além do espaço reservado na memória, podendo controlar o fluxo. Defesas: ASLR, DEP/NX, stack canaries (D).</details>

Checklist prático:

[ ] Compilei um C e li o assembly do main (objdump)
[ ] Abri um binário no Ghidra e vi o decompile
[ ] Resolvi um crackme fácil (crackmes.one)
[ ] Fiz triagem com strings + hash/VirusTotal
[ ] Montei (ou entendi) uma VM de análise isolada (REMnux/FLARE-VM)
[ ] Sei o que é YARA e escrevi/li uma regra simples
[ ] Entendo buffer overflow e as defesas (ASLR/DEP/canary)

Conclusão: 5/7 do quiz + 1 crackme resolvido. (Lembre: esta fase é opcional para o seu eixo.)