Fundamentos de Engenharia Reversa
Apoie este trabalho
  • 🙌Apresentação
  • 🥇Introdução
    • 👀Antes de começar
  • 🔢Números
    • Sistemas de Numeração
    • O Byte
    • Números Negativos
    • Cálculos com Binários
  • 🧵Cadeias de Texto
    • ASCII
    • Unicode
    • C Strings
  • 🗂️Arquivos
    • Formatos
  • 💼O formato PE
    • Cabeçalhos
      • MS-DOS
      • COFF
      • Opcional
      • Diretórios de Dados
      • Cabeçalhos das Seções
    • Seções
    • Import Table
    • Endereçamento
  • 🚗Execução de Programas
    • Executáveis
    • Bibliotecas
    • Processos
  • 🖼️Windows API
    • Caixas de Mensagens
    • Manipulação de Arquivos
    • Acesso ao Registro
  • ⚙️Assembly
    • Registradores
    • Instruções Básicas
    • Funções e Pilha
  • 🐞Depuração
    • O Debugger
    • Disassembly
    • Breakpoints
    • Manipulação do Fluxo
    • Patches
  • Apêndices
    • Tabela ASCII
    • Tabela ISO-8859-1/Latin-1
    • Exemplos de Código em Assembly
    • Funções da API do Windows
    • Ferramentas
  • Referências
Powered by GitBook
On this page
  • Realce de Instruções
  • Step Into/Over
  • Run

Was this helpful?

Edit on GitHub
Export as PDF
  1. Depuração

Disassembly

PreviousO DebuggerNextBreakpoints

Last updated 12 hours ago

Was this helpful?

Ao observar a região que chamamos de disassembly, você verá cinco colunas onde a primeira exibe algumas informações e relações entre endereços. A segunda mostra os endereços em si. A terceira mostra os bytes do opcode e dos operandos das instruções. A quarta mostra os mnemônicos onde podemos ler Assembly e por fim, a quinta mostra alguns comentários, sejam estes gerados automaticamente pelo debugger ou adicionados por você.

Realce de Instruções

Perceba que por padrão o debugger já realça (highlight em inglês) vários aspectos das instruções na janela de disassembly. As instruções CALL estão com fundo azul e os destinos das chamadas com fundo amarelo quando o endereço é conhecido. Os saltos também são realçados com fundo amarelo. Dessa forma é possível identificar rapidamente as instruções que alteram o fluxo do execução do programa.

O endereço para o qual o ponteiro de instrução (RIP) aponta é destacado com um fundo preto.

Na coluna de comentários, temos os comentários automáticos em marrom.

É importante lembrar que no arquivo há somente os bytes referentes às instruções (terceira coluna). Todo o resto é interpretação do debugger para que a nossa experiência seja mais agradável.

Step Into/Over

Neste primeiro momento, o debugger está parado e a próxima instrução a ser executada é justamente o que chamamos de EP (EntryPoint).

O primeiro comando que aprenderemos é o Step over, que pode ser ativado de pelo menos quatro maneiras:

  1. Menu Debug -> Step over.

  2. Botão Step over na barra de botões (é o sétimo botão).

  3. Tecla de atalho F8.

  4. Digitando um dos comandos a seguir na barra de comandos: StepOver/step/sto/st

Se você emitir este comando uma vez, verá que o debugger vai executar uma única instrução e parar. Na janela do disassembly, você vai perceber que o cursor (RIP) "pulou uma linha" e a instrução anterior foi executada. No caso de nosso binário de teste, é a instrução SUB RSP, 98. Após sua execução, perceba que o valor de RSP foi atualizado.

Você pode seguir teclando F8 até alcançar a primeira instrução CALL, destacada por um fundo azul claro.

O comando Step over sobre uma CALL faz com que o debugger execute a rotina apontada pela instrução e "volte" para o endereço imediatamente após a CALL. Você não verá essa execução, pois o debugger não a instrumentará. Caso queira observar o que foi executado "dentro" da CALL, é necessário utilizar o Step into (F7). Vamos fazer dois testes:

  1. Com o RIP apontado para a CALL em 140001019, tecle F8. Você verá que a execução simplesmente "passa para a linha abaixo da CALL". Isso quer dizer que ela foi executada, mas você "não viu no debugger".

  2. Agora reinicie o programa no debugger (Ctrl + F2), vá teclando F8 até chegar sobre a CALL novamente e tecle F7, que é o Step into. Perceba que o debugger agora "entrou" na CALL. Não se preocupe em analisar essa função. Ela pertence à API do Windows e seu funcionamento é conhecido. Pode reiniciar o programa em Debug -> Restart.

Run

Outro comando importante é o Run (F9). Ele simplesmente inicia a execução a partir do RIP de todas as instruções subsequentes e só para se encontrar um breakpoint (nosso próximo assunto), uma exceção ou se o programa for encerrado. Se você der este comando, verá a execução terminada em menos de um segundo, o que significa que o programa rodou até o final e saiu. Aí basta reiniciar o programa (Ctrl + F2) para recomeçar nossos estudos. ;)

Na próxima seção, vamos entender os pontos de paradas, mais conhecidos como breakpoints.

🐞