PricingLoginStart free
Cyber Security Academy · Aula

Fundamentos de Assembly x86/x64 para Engenharia Reversa

Leia MOV, CMP, JNE, CALL e RET e acompanhe o fluxo de dados pelos registradores e pela pilha.

Aula 2 de 413 etapas

Fundamentos de Assembly x86/x64 para Engenharia Reversa é uma aula grátis de Cyber Security Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Cyber Security Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Cyber Security Academy inclui 4 aulas no total.

Por que usar linguagem de montagem na engenharia reversa

O descompilador do Ghidra é útil, mas imperfeito — ele não reconhece algumas construções, infere tipos incorretamente e não consegue descompilar código ofuscado. Ler diretamente a linguagem de montagem fornece a referência real. Um analista de engenharia reversa precisa ler a linguagem de montagem, não escrevê-la.

Registradores

Principais registradores x86-64:

  • RAX — acumulador, valores de retorno
  • RBX, RCX, RDX — uso geral
  • RSI, RDI — índice de origem/destino, primeiro/segundo argumentos da função
  • RSP — ponteiro da pilha
  • RBP — ponteiro de base (quadro da pilha)
  • RIP — ponteiro de instrução

Convenção de chamada de funções (Linux x64)

Argumentos passados em registradores (ABI System V AMD64):

  1. RDI
  2. RSI
  3. RDX
  4. RCX
  5. R8
  6. R9

O valor de retorno fica em RAX. Argumentos adicionais são colocados na pilha.

Instruções essenciais

Instruções fundamentais a reconhecer:

mov rax, rbx    ; copy rbx to rax
push rax        ; push rax onto stack
pop rbx         ; pop top of stack into rbx
add rax, 8      ; rax = rax + 8
sub rsp, 0x20   ; allocate 32 bytes on stack
call 0x401234   ; call function at address
ret             ; return to caller
lea rax, [rbp-0x10] ; load address of local var

Saltos condicionais

Comparações e desvios:

cmp rax, 0      ; set flags based on rax - 0
test rax, rax   ; test rax & rax (check if zero)
jz  0x401234    ; jump if zero
jnz 0x401234    ; jump if not zero
jl  0x401234    ; jump if less (signed)
jge 0x401234    ; jump if >= (signed)
je  0x401234    ; jump if equal

Ler uma função simples

Reconhecendo padrões comuns:

; if (x == 0) return 1;
mov eax, [rbp-4]    ; load x
test eax, eax       ; x == 0?
jnz .notZero        ; if not zero, skip
mov eax, 1          ; return value = 1
ret
.notZero:
...

Reconhecer operações com cadeias de caracteres

Operações comuns com cadeias de caracteres e memória:

; memcpy(dest, src, n):
; rdi=dest, rsi=src, rdx=n
rep movsb           ; copy RCX bytes from RSI to RDI

; strlen-like loop:
.loop:
  cmp byte [rsi], 0 ; check for null terminator
  je  .done
  inc rsi
  jmp .loop

Configuração e desmontagem do quadro da pilha

Toda função começa e termina com:

; Prologue:
push rbp            ; save caller frame
mov  rbp, rsp       ; set up new frame
sub  rsp, 0x30      ; allocate local vars

; Epilogue:
leave               ; mov rsp, rbp; pop rbp
ret

Identificar laços

Laços na desmontagem:

  • Um salto para trás (um endereço menor) indica um laço
  • Um contador em um registrador é decrementado com dec/sub
  • A instrução loop decrementa RCX e salta se o valor não for zero

Ler instruções de seleção

As instruções de seleção geralmente são compiladas em tabelas de saltos:

; Jump table pattern:
cmp eax, 5          ; check if case > max
ja  .default        ; jump to default
lea rcx, [jump_table]
mov rax, [rcx + rax*8]  ; index into table
jmp rax              ; jump to case handler

Constantes SIMD e criptográficas

Procure constantes numéricas que identifiquem algoritmos:

  • Caixa S do AES: primeiros bytes 63 7C 77 7B...
  • Hash inicial do SHA-256: 0x6a09e667, 0xbb67ae85...
  • MD5: 0xd76aa478

Reconhecer essas constantes identifica instantaneamente as funções criptográficas.

Verificação rápida: linguagem de montagem x64

Na ABI System V x86-64, qual registrador contém o primeiro argumento de uma chamada de função?

Responda na aula interativa

Recapitulação da lição

A engenharia reversa x86-64 exige conhecer os principais registradores (RAX, RDI, RSI, RSP, RIP), as convenções de chamada de funções (argumentos em RDI/RSI/RDX...) e padrões comuns (prólogos, laços, comparações e tabelas de saltos). Você não precisa escrever linguagem de montagem — apenas lê-la. Constantes criptográficas no código identificam algoritmos sem executar o binário.

Grátis para começar

Aprenda Cyber Security Academy com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
76
Aulas
303
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Fundamentos de Assembly x86/x64 para Engenharia Reversa” é grátis?

Sim — o texto completo de “Fundamentos de Assembly x86/x64 para Engenharia Reversa” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Cyber Security Academy, atualize para CoddyKit PRO. O curso de Cyber Security Academy inclui 4 aulas no total.

O que vou aprender em “Fundamentos de Assembly x86/x64 para Engenharia Reversa”?

Leia MOV, CMP, JNE, CALL e RET e acompanhe o fluxo de dados pelos registradores e pela pilha. Você pratica Cyber Security Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Cyber Security Academy?

Nenhuma experiência prévia é necessária. Cyber Security Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Fundamentos de Assembly x86/x64 para Engenharia Reversa”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Cyber Security Academy?

Sim. Cada aula de Cyber Security Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Ghidra: Navegação e Anotação de Binários
  2. Fundamentos de Assembly x86/x64 para Engenharia Reversa
  3. Análise Dinâmica com GDB e pwndbg
  4. Desofuscação e Técnicas Antianálise
← Voltar para Cyber Security Academy